一、什么是运算符重载，解决了什么问题？
运算符重载指的是对已有的运算符，如：+ - * / 等重新进行定义，以适应不同的数据类型进行相应的运算。
为什么要重载运算符，对于操作系统基本的数据类型，如 int， float等，编译器知道如何进行运算。但是对于我们自定义的数据类型，比如我想实现两个结构体或者类的相加。编译器就不知道如何对其进行运算了。这个时候我们就需要重载相应的运算符。
二、运算符重载格式
operator 运算符(args…)
例如，operator+() 重载+运算符
operator*()重载*运算符
三、运算符重载示例
3.1 “+” 加法运算符重载
因为每个人都可以实现该成员函数，且函数名各不相同，你也可以叫AddStudent。为了统一名称，编译器提供了operator+。
#include <iostream>
using namespace std;
class Student{
public:
// 3.1 类的成员函数实现+重载
Student Add(Student& s) // 我们自己实现的Add
{
Student tmp;
tmp.m_A = this->m_A + s.m_A;
tmp.m_B = this->m_B + s.m_B;
return tmp;
}
Student operator+(Student& s) // operator+ 是编译器提供的统一的+运算符重载的名称
{
Student tmp;
tmp.m_A = this->m_A + s.m_A;
tmp.m_B = this->m_B + s.m_B;
return tmp;
}
public:
int m_A;
int m_B;
};
// 3.2 全局函数实现+重载
Student operator+(Student &s1, Student &s2)
{
Student tmp;
tmp.m_A = s1.m_A + s2.m_A;
tmp.m_B = s1.m_B + s2.m_B;
return tmp;
}
int main(int argc, char* argv[])
{
Student s1, s2;
s1.m_A = 10;
s1.m_B = 10;
s2.m_A = 20;
s2.m_B = 20;
std::cout << " =========== Add ========"<< std::endl;
Student s3 = s1.Add(s2);
std::cout << "s3.A = "<< s3.m_A << " B = "<< s3.m_B << std::endl;
std::cout << " =========== operator+ ========" << std::endl;
// Student s4 = s1.operator+(s2); // 可简写为：Student s4 = s1 + s2;
Student s4 = s1 + s2;
std::cout << "s4.A = "<< s4.m_A << " B = "<< s4.m_B << std::endl;
std::cout << " =========== operator+(Student &s1, Student &s2) ========" << std::endl;
// Student s6 = operator+(s1, s2);
Student s6 = s1 + s2; // 可简写为：Student s6 = s1 + s2;
std::cout << "s6.A = "<< s6.m_A << " B = "<< s6.m_B << std::endl;
return 0;
}
小结：
对于基本数据类型表达式的运算符无法重载。
不要滥用运算符重载，比如故意将运算符+重载为减法的功能。
3.2 “<<” 左移运算符重载
#include <iostream>
using namespace std;
class Student{
public:
// 成员函数实现左移运算符
// void operator<<(Student& s){} // 不可避免调用形式 s1.operator<<(s) 简化版本 s1 << s
// void operator<<(cout){} // 不可避免调用形式 s1.operator<<(cout) 简化版本 s1 << cout，不满足cout在左侧，所以左移运算符只能使用全局函数重载
public:
int m_A;
int m_B;
};
// 改造前，全局函数实现左移运算符重载
void operator<<(ostream& cout, Student& s)
{
cout << "s.a = " << s.m_A << " s.b = " << s.m_B;
}
// 改造后，全局函数实现左移运算符重载
ostream& operator<<(ostream& cout, Student& s)
{
cout << "s.a = " << s.m_A << " s.b = " << s.m_B;
return cout;
}
int main(int argc, char* argv[])
{
Student s1, s2;
s1.m_A = 10;
s1.m_B = 10;
s2.m_A = 20;
s2.m_B = 20;
std::cout << "[s1] "<< s1; // 改造前
std::cout << "[s1] "<< s1 << " [s2] "<< s2 << std::endl; // 改造后，支持
return 0;
}
运行结果：
改造前：
改造后：
注意，此时 std::cout << “p” << s1 ; 我们是没有加换行的，如果加了换行代码（std::cout << “p” << s1 << std::endl;）会报错。为什么呢？因为我们用来实现的左移运算符重载的全局函数的返回值是void。如果要继续输出，我们的返回值就必须还是cout的类型。这就是链式编程思想。
3.3 “++” 自增运算符重载
#include <iostream>
using namespace std;
class Myinteger{
public:
friend ostream& operator<<(ostream& cout, Myinteger m); // 声明该函数为本类的友元函数，可以访问本类的私有成员
Myinteger(){m_Num = 0;}
// 前置++运算符重载，返回值必须是引用
// 比如：(++(++a)) 是对a加两次，如果返回值不是引用，那么(++(++Myinteger)) 就不是同一个对象
Myinteger& operator++(){
m_Num++;
return *this;
}
// 后置++运算符重载 因为同一作用域下，函数返回值不同不能作为函数重载的依据,需要加int占位。
// 后置++ 是先返回值，再运算
Myinteger operator++(int){
Myinteger tmp = *this;
m_Num++;
return tmp; // 注意，这里的tmp是临时变量，离开作用域会销毁，如果返回值是引用，继续使用该临时对象就是非法操作
}
private:
int m_Num;
};
ostream& operator<<(ostream& cout, Myinteger m)
{
cout << m.m_Num;
return cout;
}
int main(int argc, char* argv[])
{
std::cout << "========= int =========" << std::endl;
int a = 0;
std::cout << "++a = " << ++a << std::endl;
std::cout << "a = " << a << std::endl;
std::cout << "a++ = " << a++ << std::endl;
std::cout << "a = " << a << std::endl;
std::cout << "========= Myinteger =========" << std::endl;
Myinteger m;
std::cout << "++m = " << ++m << std::endl;
std::cout << "m = " << m << std::endl;
std::cout << "m++ = " << m++ << std::endl;
std::cout << "m = " << m << std::endl;
return 0;
}
运行结果：
3.4 “=” 赋值运算符重载
class Person{
public:
Person(int age)
{
m_Age = new int(age); // 在堆上维护一块空间
}
~Person(){ // 在析构函数中释放堆上的空间
if (m_Age){
delete m_Age;
m_Age = nullptr;
}
}
Person& operator=(Person& p){
//先判断堆上是否存在旧数据，如果有清除干净
if (m_Age){
delete m_Age;
m_Age = nullptr;
}
// 执行深拷贝
m_Age = new int(*p.m_Age);
// 返回对象本身，链式编程思想
return *this;
}
public:
int *m_Age;
};
int main(int argc, char* argv[])
{
Person p1(10);
std::cout << "p1.age: " << *p1.m_Age << std::endl;
Person p2(20);
Person p3(30);
std::cout << "赋值前 p2.age: " << *p2.m_Age << " p3.age: "<< *p3.m_Age<< std::endl;
p3 = p2 = p1; // 链式编程
std::cout << "赋值后 p2.age: " << *p2.m_Age << " p3.age: "<< *p3.m_Age<< std::endl;
return 0;
}
运行结果：
编译器默认提供的赋值是简单的值拷贝，浅拷贝缺陷，同一块内存释放两次，造成程序崩溃！
3.5 关系运算符重载（< > == <= ）
#include <iostream>
using namespace std;
class Person{
public:
Person(int val){
m_a = val;
}
bool operator<=(Person& p)
{
return m_a <= p.m_a ? true : false;
}
bool operator<(Person& p)
{
return m_a < p.m_a ? true : false;
}
bool operator>(Person& p)
{
return m_a > p.m_a ? true : false;
}
bool operator==(Person& p)
{
return m_a == p.m_a ? true : false;
}
private:
int m_a;
};
int main(int argc, char* argv[])
{
Person p1(20);
Person p2(30);
Person p3(30);
if (p1 < p2){
std::cout << "p1 < p2" << std::endl;
}
if (p2 > p1){
std::cout << "p2 > p1" << std::endl;
}
if (p3 == p2){
std::cout << "p3 == p2" << std::endl;
}
if (p3 <= p2){
std::cout << "p3 <= p2" << std::endl;
}
return 0;
}
运行结果：
3.6 “()”函数调用运算符重载
- 函数调用运算符“()”也可以重载
- 重载后的使用方式跟函数调用类似，因此称为仿函数
- 仿函数非常灵活，没有固定的写法
class MyPrint{
public:
void operator()(std::string str){
std::cout << str << std::endl;
}
};
void MyPrint_Func(std::string str){
std::cout << str << std::endl;
}
class MyAdd{
public:
int operator()(int a, int b){
return a+b;
}
};
int MyAdd_Func(int a, int b){
return a+b;
}
int main(int argc, char* argv[])
{
MyPrint print;
print("hello word!"); // 仿函数，顾名思义跟函数调用类似，都是 返回值 函数名+(形参);
MyPrint_Func("hello word!"); // 函数调用
int a = 10, b = 20;
MyAdd add;
std::cout << "add res: " << add(a, b) << std::endl; // 仿函数，顾名思义跟函数调用类似，都是 返回值 函数名+(形参);
std::cout << "MyAdd_Func res: " << MyAdd_Func(a, b) << std::endl; // 函数调用
//匿名对象，顾名思义对象没有显示的名字，且这行代码结束，对象被回收
std::cout << "匿名对象: " << MyAdd()(20, 30) << std::endl;
return 0;
}
运行结果：
725
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
