写在开头
参考《黑马c++核心编程》
4.5 运算符重载
运算符重载概念:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型
4.5.1 加号运算符重载
作用:实现两个自定义数据类型相加的运算
#include <bits/stdc++.h>
using namespace std;
class Person
{
public:
int m_A;
int m_B;
public:
Person() {};//无参默认构造
Person(int a, int b)//有参构造
{
this->m_A = a;
this->m_B = b;
}
//成员函数实现+号运算符重载
Person operator+(const Person& p)
{
Person temp;
temp.m_A = this->m_A + p.m_A;
temp.m_B = this->m_B + p.m_B;
return temp;
}
};
//Person operator+(const Person& p1,const Person& p2)
//{
// Person temp(0, 0);
// temp.m_A = p1.m_A + p2.m_A;
// temp.m_B = p1.m_B + p2.m_B;
// return temp;
//}
Person operator+(const Person& p, const int val)
{
Person temp;
temp.m_A = p.m_A + val;
temp.m_B = p.m_B + val;
return temp;
}
void test()
{
Person p1(10, 10);
Person p2(20, 20);
Person p3 = p1 + p2;//相当于p2.operator+(p1);
cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;
Person p4 = p3 + 10;
cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;
}
int main()
{
test();
return 0;
}
总结1:对于内置的数据类型表达式的运算符是不可能改变的
总结2:不要滥用运算符重载
4.5.2 左移运算符重载
作用:可以输出自定义数据类型
#include <bits/stdc++.h>
using namespace std;
class Person
{
friend ostream& operator<<(ostream& cout, Person& p);
private:
int m_A;
int m_B;
public:
Person(int a, int b)
{
this->m_A = a;
this->m_B = b;
}
//成员函数实现不了p<<cout我们想要的效果
//void operator << (Person& p) {}
};
//全局函数实现左移重载
//ostream对象只能有一个
ostream& operator<<(ostream& cout, Person& p)
{
cout << "a:" << p.m_A << "b:" << p.m_B;//无法直接访问,需要写友元函数
return cout;
}
void test()
{
Person p1(10,20);
cout << p1 << "helloworld" << endl;
}
int main()
{
test();
return 0;
}
总结:重载左移运算配合友元可以实现输出自定义数据类型
4.5.3 递增运算符重载
作用:通过重载递增运算符,实现自己的整数数据
#include <bits/stdc++.h>
using namespace std;
class MyInteger
{
friend ostream& operator<<(ostream& cout, MyInteger myint);
private:
int m_Num;
public:
MyInteger()
{
m_Num = 0;
}
//前置++
MyInteger& operator++()//返回引用的目的是链式操作的影响
{
//先++
m_Num++;
//再返回
return *this;//类的非静态成员函数返回对象本身用return *this
}
//后置++
MyInteger operator++(int)
{
//先返回
MyInteger temp = *this;//记录当前本身的值,然后让本身的值++,但是返回的是以前的
m_Num++;
return temp;
}
};
ostream& operator<<(ostream& cout, MyInteger myint)
{
cout << myint.m_Num << endl;
return cout;
}
void test01()
{
MyInteger myInt;
cout << ++myInt << endl;
cout << myInt << endl;
}
void test02()
{
MyInteger myInt;
cout << myInt++ << endl;
cout << myInt << endl;
}
int main()
{
test01();
test02();
return 0;
}
总结:迁至递增返回引用,后置递增返回
4.5.4 赋值运算符重载
cpp编译器至少给一个类添加4个函数
- 默认构造函数(无参,函数体为空)
- 默认析构函数(无参,函数体为空)
- 默认拷贝构造函数,对属性进行值拷贝
- 赋值运算符 operator=,对属性进行值拷贝
如果类中属性指向堆区,做赋值操作时也会出现深浅拷贝问题
#include <bits/stdc++.h>
using namespace std;
class Person
{
public:
int* m_Age;//年龄指针
Person(int age)
{
//将年龄数据开辟到堆区
m_Age = new int(age);
}
Person& operator=(Person& p)
{
if (m_Age != NULL)//先初始化
{
delete m_Age;
m_Age = NULL;
}
//编译器提供的代码是浅拷贝
//m_Age=p.m_Age;
//提供深拷贝 解决浅拷贝问题
m_Age = new int(*p.m_Age);
return *this;
}
~Person()
{
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
}
};
void test01()
{
Person p1(18);
Person p2(20);
Person p3(30);
p3 = p2 = p1;//赋值操作
cout << "p1的年龄为:" << *p1.m_Age << endl;
cout << "p2的年龄为:" << *p2.m_Age << endl;
cout << "p3的年龄为:" << *p3.m_Age << endl;
}
int main()
{
test01();
return 0;
}
4.4.5 关系运算符重载
**作用:**重载关系运算符,可以让两个自定义对象进行对比操作
#include <bits/stdc++.h>
using namespace std;
class Person
{
public:
string m_Name;
int m_Age;
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
};
bool operator==(Person& p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
return true;
return false;
}
bool operator!=(Person& p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
return false;
return true;
}
};
void test01()
{
Person a("孙悟空", 18);
Person b("孙悟空", 18);
if (a == b)
{
cout << "a和b相等" << endl;
}
else cout << "a和b不相等" << endl;
if (a != b)cout << "a和b不相等" << endl;
else cout << "a和b相等" << endl;
}
int main()
{
test01();
return 0;
}
4.5.6 函数调用运算符重载
- 函数调用运算符()也可以重载
- 由于重载后使用的方式非常想函数的调用,因此成为仿函数
- 仿函数没有固定的写法,非常灵活
#include <bits/stdc++.h>
using namespace std;
class MyPrint
{
public:
void operator()(string text)
{
cout << text << endl;
}
};
void test01()
{
//重载的()操作符 也成为仿函数
MyPrint myFunc;
myFunc("hello world");
}
int main()
{
test01();
return 0;
}
4.6 继承
继承是面向对象三大特征之一
在定义一些类时,下级别的成员除了拥有上一级的共性,还有自己的特性,这个时候我们就可以考虑利用继承的技术,减少重复代码。
4.6.1 继承的基本语法
示例
#include <bits/stdc++.h>
using namespace std;
class BasePage
{
public:
void header()
{
cout << "首页、公开课、登录、注册...(公共头部)" << endl;
}
void footer()
{
cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
}
void left()
{
cout << "Java, Python, cpp...(公共分类列表)" << endl;
}
};
//java页面
class Java :public BasePage
{
public:
void content()
{
cout << "Java学科视频" << endl;
}
};
void test01()
{
cout << "Java下载视频页面如下:" << endl;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
}
int main()
{
test01();
return 0;
}
总结
继承的好处:可以减少重复的代码
class A:class B;
A类称为子类 或 派生类
B类称为父类 或 基类
派生类中的成员,包含两大部分:
一类是从基类继承过来的,一类是自己增加的成员
从基类继承过来的表现其共性,而新增成员体现了其个性
4.6.2 继承方式
继承的语法: class 子类:继承方式 父类
继承方式一共有三种
- 公共继承
- 保护继承
- 私有继承
#include <bits/stdc++.h>
using namespace std;
class Base1
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
//公共继承
class Son1 :public Base1
{
public:
void func()
{
m_A;//可访问public权限
m_B;//可访问protected权限
//m_C;//私有权限不可访问
}
};
void myClass()
{
Son1 s1;
s1.m_A;//其他类只能访问公共权限
//s1.m_B;不可访问
//s1.m_C;//不可访问
}
//保护继承
class Base2
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son2 :protected Base2
{
public:
void func()
{
m_A;//可访问protected权限
m_B;//可访问protected权限
//m_C;//私有权限不可访问
}
};
void myClass2()
{
Son2 s;
//s.m_A//不可访问,保护全新啊
}
class Base3
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son3 :private Base3
{
public:
void func()
{
m_A;//可访问private权限
m_B;//可访问private权限
//m_C;//不可访问
}
};
class GrandSon3 :public Son3
{
public:
void func()
{
//Son3是似有继承,所以继承Son3的属性在GrandSon3中都无法访问到
//m_A;
//m_B;
//m_C;
}
};
int main()
{
myClass();
myClass2();
}
4.6.3 继承中的对象模型
问题:从父类继承过来的成员,那些属于子类对象中?
示例
:
#include <bits/stdc++.h>
using namespace std;
class Base
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;//私有成员只是被隐藏了,但是还是会被继承下去
};
//公共继承
class Son :public Base
{
public:
int m_D;
};
void test01()
{
cout << "sizeof Son = " << sizeof(Son) << endl;
}
int main()
{
test01();
return 0;
}
4.6.4 继承中构造和析构顺序
子类继承父类后,当创建子类对象,也会调用父类的构造函数
问题:父类和子类的构造和析构顺序谁先谁后?
示例:
#include <bits/stdc++.h>
using namespace std;
class Base
{
public:
Base()
{
cout << "Base的构造函数!" << endl;
}
~Base()
{
cout << "Base的析构函数" << endl;
}
};
class Son :public Base
{
public:
Son()
{
cout << "Son的构造函数!" << endl;
}
~Son()
{
cout << "Son的析构函数" << endl;
}
};
void test01()
{
//继承中 先调用父类的构造函数,再调哟个子类的构造函数,析构顺序与构造相反
Son s;
}
int main()
{
test01();
return 0;
}
总结:继承中 先调用父类的构造函数,再调用子类的构造函数,析构顺序与构造相反
4.6.5 继承同类成员处理方式
问题:当子类与父类出现同名成员,如何通过子类对象,访问到子类或父类中同名的数据呢?
- 访问子类同名成员 直接访问即可
- 访问父类同名成员 需要加作用域
示例
#include <bits/stdc++.h>
using namespace std;
class Base
{
public:
int m_A;
public:
Base()
{
m_A = 100;
}
void func()
{
cout << "Base - func()调用" << endl;
}
void func(int a)
{
cout << "Base - func(int a)调用" << endl;
}
};
class Son :public Base
{
public:
int m_A;
Son()
{
m_A = 200;
}
//当子类与父类拥有同名的成员函数,子类会隐藏父类中所有版本的同名成员函数
//如果想访问父类中被隐藏的同名成员函数,需要加父类的作用域
void func()
{
cout << "Son - func()的调用" << endl;
}
};
void test01()
{
Son s;
cout << "Son下的m_A= " << s.m_A << endl;
cout << "Base下的m_A= " << s.Base::m_A << endl;
s.func();
s.Base::func();
s.Base::func(10);
}
int main()
{
test01();
return 0;
}
总结:
- 子类对象可以直接访问到子类中同名成员
- 子类对象加作用域可以访问到父类同名成员
- 当子类与父类拥有同名的成员函数,子类会隐藏父类中同名成员函数,加作用域可以访问到父类中同名函数
4.6.6 继承同名静态成员处理方式
问题:继承中同名的静态成员在子类对象上如何进行访问?
静态成员和非静态成员出现同名,处理方式一致
- 访问子类同名成员 直接访问即可
- 访问父类同名成员 需要加作用域
#include <bits/stdc++.h>
using namespace std;
class Base
{
public:
static void func()
{
cout << "Base - static void func()" << endl;
}
static void func(int a)
{
cout << "Base - static void func(int a)" << endl;
}
static int m_A;
};
int Base::m_A = 100;
class Son :public Base
{
public:
static void func()
{
cout << "Son - static void func()" << endl;
}
static int m_A;
};
int Son::m_A = 200;
//同名成员函数
void test01()
{
//通过对象访问
cout << "通过对象访问" << endl;
Son s;
cout << "Son 下 m_A = " << s.m_A << endl;
cout << "Base 下 m_A = " << s.Base::m_A << endl;
//通过类名访问
cout << "通过类名访问" << endl;
cout << "Son 下 m_A = " << Son::m_A << endl;
cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}
void test02()
{
//通过对象访问
cout << "通过对象访问::" << endl;
Son s;
s.func();
s.Base::func();
cout << "通过类名访问:" << endl;
Son::func();
Son::Base::func();
//出现同名,子类会隐藏掉父类中所有同名成员,需要加作用域访问
Son::Base::func(100);
}
int main()
{
test01();
test02();
}
4.6.7 多继承语法
cpp允许一个类继承多个类
语法:class 子类 :继承方式 父类1,继承方式,父类2
多继承可能会引发父类中同名成员出现,所以加作用域区分
cpp实际开发中不建议使用多态
示例
#include <bits/stdc++.h>
using namespace std;
class Base1
{
public:
Base1()
{
m_A = 100;
}
int m_A;
};
class Base2
{
public:
Base2()
{
m_A = 200;
}
int m_A;
};
class Son :public Base2, public Base1
{
public:
Son()
{
m_C = 300;
m_D = 400;
}
int m_C;
int m_D;
};
void test01()
{
Son s;
cout << "sizeof Son = " << sizeof(s) << endl;
cout << s.Base1::m_A << endl;
cout << s.Base2::m_A << endl;
}
int main()
{
test01();
return 0;
}
4.6.8 菱形继承
菱形继承概念:
两个派生类继承同一个基类
又有某个类同时继承两个派生类
这种继承被称为菱形继承,或者钻石继承
典型的菱形继承案例
菱形继承问题:
- 羊继承了动物的数据,驼同样继承了动物的数据,当草泥马使用数据时,就会产生二义性
- 草泥马继承自动物的数据继承了两份,实则只需要一份就好
示例
#include <bits/stdc++.h>
using namespace std;
class Animal
{
public:
int m_Age;
};
//继承前加virtual关键字后,变成虚继承
//此时公共的父类Animal称为虚基类
class Sheep :virtual public Animal {};
class Tuo :virtual public Animal {};
class sheepTuo :public Sheep, public Tuo {};
void test01()
{
sheepTuo st;
st.Sheep::m_Age = 100;
st.Tuo::m_Age = 200;
cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
cout << "st.m_Age = " << st.m_Age << endl;
}//类似于数据共享
int main()
{
test01();
system("pause");
return 0;
}