文章目录
运算符重载知识结构：
运算符重载的概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型
1. 加号运算符重载
作用:实现两个自定义数据类型相加的运算
1.1 通过成员函数重载
class Person
{
public:
//成员函数重载+号
Person operator+(Person &p)
{
Person temp;
temp.m_A = this->m_A + p.m_A;
temp.m_B = this->m_B + p.m_B;
return temp;
}
int m_A;
int m_B;
};
void test01()
{
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 10;
p2.m_B = 10;
Person p3 = p1 + p2;
cout << "p3.m_A:" << p3.m_A << endl;
cout << "p3.m_B:" << p3.m_B << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
1.2 通过全局函数重载
class Person
{
public:
int m_A;
int m_B;
};
//全局函数重载+号
Person operator+(Person &p1, Person &p2)
{
Person temp;
temp.m_A = p1.m_A + p2.m_A;
temp.m_B = p1.m_B + p2.m_B;
return temp;
}
void test01()
{
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 10;
p2.m_B = 10;
Person p3 = p1 + p2;
cout << "p3.m_A:" << p3.m_A << endl;
cout << "p3.m_B:" << p3.m_B << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
注：运算符重载也可以发生函数重载
class Person
{
public:
int m_A;
int m_B;
};
//全局函数重载+号
Person operator+(Person &p1, Person &p2)
{
Person temp;
temp.m_A = p1.m_A + p2.m_A;
temp.m_B = p1.m_B + p2.m_B;
return temp;
}
//运算符发生函数重载
Person operator+(Person &p1, int num)
{
Person temp;
temp.m_A = p1.m_A + num;
temp.m_B = p1.m_B + num;
return temp;
}
void test01()
{
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 10;
p2.m_B = 10;
Person p3 = p1 + p2;
cout << "p3.m_A:" << p3.m_A << endl;
cout << "p3.m_B:" << p3.m_B << endl;
Person p4 = p1 + 100;
cout << "p4.m_A:" << p4.m_A << endl;
cout << "p4.m_B:" << p4.m_B << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
2. 左移运算符重载
2.1 通过成员函数重载
不会利用成员函数重载<<运算符，因为无法实现cout 在左侧
class Person
{
//利用成员函数重载 左移运算符 p.operator<<(cout)简化为 p << cout
//不会利用成员函数重载<<运算符，因为无法实现cout 在左侧
//void operator<<(cout)
//{
//}
public:
int m_A;
int m_B;
};
void test01()
{
Person p1;
p1.m_A = 10;
p1.m_B = 10;
//Person p2;
//p2.m_A = 10;
//p2.m_B = 10;
cout << p1; //想要重载<<，使得这行代码能正常调用
}
2.2 通过全局函数重载
class Person
{
friend ostream& operator<<(ostream &cout, Person &p); //利用友元，让全局函数访问Person的私有属性
public:
Person(int a, int b)
{
m_A = a;
m_B = b;
}
private:
int m_A;
int m_B;
};
//通过全局函数重载
ostream& operator<<(ostream &cout, Person &p) //本质为operator <<(cout,p)简化为cout << p
{
cout << "m_A = " << p.m_A << "m_B = " << p.m_B;
return cout;
}
void test01()
{
Person p1(10,10);
//p1.m_A = 10;
//p1.m_B = 10;
//Person p2;
//p2.m_A = 10;
//p2.m_B = 10;
cout << p1 << endl; //想要重载<<，使得这行代码能正常调用
}
int main()
{
test01();
system("pause");
return 0;
}
注：链式编程思想，全局函数重载的返回值为ostream&
3. 递增运算符重载
3.1 前置递增
注意：前置递增需要返回引用，为的是一直对一个数据进行递增
//自定义整型
class MyInteger
{
friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
MyInteger()
{
m_Num = 0;
}
//重载前置++运算符 返回引用是为了一直对一个数据进行递增
MyInteger& operator++()
{
m_Num++;
return *this;
}
private:
int m_Num;
};
//重载左移运算
ostream& operator<<(ostream& cout, MyInteger myint)
{
cout << myint.m_Num;
return cout;
}
void test01()
{
MyInteger myint;
cout << ++(++myint) << endl;
cout << myint << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
3.2 后置递增
注意：后置递增需要返回值，因为不可以返回局部变量的引用
//自定义整型
class MyInteger
{
friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
MyInteger()
{
m_Num = 0;
}
//重载前置++运算符 返回引用是为了一直对一个数据进行递增
MyInteger& operator++()
{
m_Num++;
return *this;
}
//重载后置++运算符
//void operator++(int) int代表占位参数，可用于区分前置与后置递增
MyInteger operator++(int)
{
//先记录当时的结果
MyInteger temp = *this;
//后递增
m_Num++;
//最后将记录结果做返回
return temp;
}
private:
int m_Num;
};
//重载左移运算
ostream& operator<<(ostream& cout, MyInteger myint)
{
cout << myint.m_Num;
return cout;
}
void test01()
{
MyInteger myint;
cout << myint++ << endl;
cout << myint << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
注：以为返回的不是引用，所以链式编程的思想没有体现。后置递增的代码是存在缺陷的，如假设myint.m_Num=0,根据C语言的语法，(myint++)++的值还是0，而myint输出的结果应该是2。但是因为不是引用传递，所以上述代码myint输出的结果是1。
4. 赋值运算符重载
C++编译器至少给一个类添加4个函数
- 默认构造函数（无参数，函数体为空）
- 默认析构函数（无参数，函数体为空）
- 默认拷贝构造函数，对属性进行值拷贝
- 赋值运算符operator=,对属性进行值拷贝
默认赋值运算带来的问题：会导致内存的重复释放
class Person
{
public:
Person(int age)
{
m_Age = new int(age);
}
~Person()
{
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
}
int *m_Age;
};
void test01()
{
Person p1(18);
Person p2(20);
p2 = p1;
}
int main()
{
test01();
system("pause");
return 0;
}
对于test01函数假设p1先执行析构函数，则堆区的数据已经被释放了。那么当p2执行析构代码时，需要将堆区的数据再释放一次，就造成了堆区数据重复释放的问题。
赋值运算符重载代码：
class Person
{
public:
Person(int age)
{
m_Age = new int(age);
}
~Person()
{
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
}
//重载赋值运算符
Person& operator=(Person &p)
{
//应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
//深拷贝
m_Age = new int(*p.m_Age);
return *this;
}
int *m_Age;
};
void test01()
{
Person p1(18);
Person p2(20);
p3 = p2 = p1;
}
int main()
{
test01();
system("pause");
return 0;
}
重载函数返回引用，能实现链式编程的思想。
5. 关系运算符重载
以==运算符的重载为例：
class Person
{
public:
Person(string name,int age)
{
m_Name = name;
m_Age = age;
}
//重载==运算符
bool operator==(Person &p)
{
if (m_Age == p.m_Age&& m_Name == p.m_Name)
{
return true;
}
else
{
return false;
}
}
string m_Name;
int m_Age;
};
void test01()
{
Person p1("Tom", 18);
Person p2("Tom", 18);
if (p1 == p2)
{
cout << "p1和p2是相等的" << endl;
}
}
int main()
{
test01();
system("pause");
return 0;
}
6. 函数调用运算符重载
- 函数调用运算符()也可以重载
- 由于重载后使用的方式非常像函数的调用，因此称为仿函数
- 仿函数没有固定的写法，非常灵活
class MyPrint
{
public:
//重载函数调用运算符
void operator()(string text)
{
cout << text << endl;
}
};
void MyPrint02(string text)
{
cout << text << endl;
}
void test01()
{
MyPrint myprint;
myprint("Hello World"); //仿函数调用
MyPrint02("Hello World"); //全局函数调用
}
//仿函数非常灵活，没有固定的写法
class MyAdd
{
public:
int operator()(int num1, int num2)
{
return num1 + num2;
}
};
void test02()
{
MyAdd myadd;
int ret = myadd(100, 100);
cout << "ret =" << ret << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
