C++中运算符的重载
运算符重载相当于运算符的函数重载，用于对已有的运算符进行重新定义，赋予其另一种功能，以适应不同的数据类型。我们之前提到过C++中的函数重载，可以根据形参的不同调用不同的函数，那么运算符重载跟函数重载的实现形式差不多，运算符重载的一般写法为返回值 operator运算符(参数列表)。
下面就根据几个简要的例子来简单实现一下加法，左移以及自增运算符的重载，还有赋值，关系运算符等可以自己实现。首先自定义一个 person 类，通过运算符重载，实现 对person 类的对象中 age 属性的一系列操作。
class person{
public:
int age;
string name;
// 值传递构造函数
person(string name,int age);
// 拷贝构造函数
person(person& p);
void show(); // 回显函数，显示类内成员的数值
};
person::person(string name,int age){
this->age = age; // this指针区分调用者
this->name = name;
}
person::person(person& p){
this->age = p.age;
this->name = p.name;
}
void person::show(){
cout << "name: " << name << "\tage: " << age << endl;
}
一、加法运算符重载
运算符重载可以表示为成员函数，也可以表示为全局函数
1.1 成员函数
class person{
public:
int age;
string name;
// 值传递构造函数
person(string name,int age);
// 拷贝构造函数
person(person& p);
void show();
person operator+(person& p); // 加法重载函数
};
// 加法重载函数的实现，第一个`person`代表返回值，第二个`person`代表域
person person::operator+(person& p){
person tmp(p); // 调用拷贝构造函数给对象 p 赋值
tmp.age = this->age + p.age;
tmp.name = this->name; // 将第一个变量的 name 成员作为 name 的结果
return tmp;
}
person p1("张三", 25); // 调用值传递拷贝函数给对象赋值
person p2("李四", 27); // 调用值传递靠别函数给对象赋值
person p3 = p1+p2; // 加法运算符重载，实现两个类中的 age 成员相加
p3.show();
上述重载的过程其实就是 p1调用 operator+ 函数，相当于 p1.operator+(p2)。在这个过程中，p2 作为参数传递给 operator，完成相加后，由于返回类型为值传递，因此 return *this其实就是返回 p1 拷贝出来的一个副本，必须在调用时重新赋值。输出结果如下：
name: 张三 age: 52
1.2 全局函数写法
在成员函数的写法中，由于在调用加法重载时已经指定了一个对象 ( this 指针指向的对象 )，所以重载函数内只需要再传递一个参数即可。但是全局函数不属于任何一个对象，因此在进行重载时需要传入两个参数。函数实现如下：
person operator+(person& p1, person& p2){
person tmp(p1); // 调用拷贝构造函数给对象 p 赋值
tmp.age = p1.age + p2.age;
tmp.name = p1.name; // 将第一个变量的 name 成员作为 name 的结果
return tmp;
}
person p1("张三", 25); // 调用值传递拷贝函数给对象赋值
person p2("李四", 27); // 调用值传递靠别函数给对象赋值
person p3 = p1+p2; // 加法运算符重载，实现两个类中的 age 成员相加
p3.show();
输出结果如下：
name: 张三 age: 52
1.3 链式编程
对于内置数据类型的加法运算符来说，可以实现 a+b+c 类型的操作，这种情况下先执行 a+b ，返回值再与 c 相加。这样就必须确保返回值也是 person 数据类型。根据这个结论，上述两种运算符重载的写法返回值均为 person 类型，因此链式编程的实现为：
person p1("张三", 25);
person p2("李四", 27);
person p3("王五", 32);
person p4 = p1+p2+p3;
p4.show();
输出结果为：
name: 张三 age: 84
二、左移运算符重载
左移运算符主要用于 cout << "abs" 等的输出，也可以表示为成员函数或者全局函数。根据对比发现，左移运算符需要两个参数，cout 和 person，且已知 cout 属于 ostream 类。
2.1 成员函数写法
成员函数只能实例化一个 person 对象，然后 cout 作为函数参数，写法如下：
class person{
public:
int age;
string name;
// 值传递构造函数
person(string name,int age);
// 拷贝构造函数
person(person& p);
void show();
person operator+(person& p); // 加法运算符重载
void operator<<(ostream& cout); // 左移运算符重载
};
// 左移运算符重载函数实现，由于 cout 全局只能有一个，若使用值传递的方式，则在传递过程中需要进行拷贝。因此只能使用引用传递的方式
void person::operator<<(ostream& cout){
cout << "name: " << name << "\tage: " << age << endl;
}
person p1("张三", 25);
p1 << cout; // 其实就是 p1.operator<<(cout) 的简写
输出结果为：
name: 张三 age: 25
这种写法与我么通常使用的方式刚好相反，因此左移运算符一般不采取成员函数的形式来实现，通常使用全局函数来实现。在这里如果对引用不是很清楚的可以移步另一篇文章：C++中指针与引用详解 - ZhiboZhao - 博客园 (cnblogs.com)。
2.2 全局函数写法
void operator<<(ostream& cout, person p){
cout << "name: " <<p.name << "\tage: " << p.age << endl;
}
person p1("张三", 25);
cout << p1;
输出结果为：
name: 张三 age: 25
2.3 链式编程
通常使用左移运算符时，能够实现 cout << a << b <<...<< endl 的效果，此过程中先执行 cout << a，返回值再执行 下一个左移运算符。因此返回值必须是 ostream 类型。
// 返回值为 ostream 类型，又因为 cout 只有一个，因此以引用的方式返回
ostream& operator<<(ostream& cout, person p){
cout << "name: " <<p.name << "\tage: " << p.age << endl;
return cout;
}
person p1("张三", 25);
person p2("李四", 27);
cout << p1 << p2;
输出结果为：
name: 张三 age: 25
name: 李四 age: 27
三、递增运算符重载
递增运算符++有两种表现形式，分为前置和后置。
- 当为前置方式时"++p"，p的值先自增1，然后再返回增1后的p值
- 当为后置方式时"p++"，先返回p的值，p的值再自增1
比如：p=5, 那么 a = p++ 执行结束后 a=5， p=6， 如果 a=++p 执行结束后，a=6，p=6。所以我们重载运算符需要分别实现这两种形式。总的来说，前置运算符和后置运算符如果在不使用返回值的情况下，二者的作用一样，都是使参数自增；当使用返回值时，前置运算符返回自增后的参数，而后置运算符返回自增之前的参数。
3.1 成员函数写法
3.1.1 前置运算符实现
前置运算符的作用：1）自增 2）返回自增之后的参数，因此实现代码为：
class person{
public:
int age;
string name;
// 值传递构造函数
person(string name,int age);
// 拷贝构造函数
person(person& p);
void show();
person operator++(); // 前置自增运算符
void operator<<(ostream& cout); // 左移运算符重载
};
person person::operator++(){
age++; // age自增
return *this; // 返回自增之后的对象
}
person p1("张三", 25);
person p3 = ++p1; // 调用自增运算符重载函数
cout << "p3: " << p3;
cout << "p1: " << p1;
输出结果如下：
p3: name: 张三 age: 26 // 前置自增运算符的返回值
p1: name: 张三 age: 26 // 自增之后
根据输出结果可以知道，重载的前置自增运算符能够实现期望的功能。
3.1.2 后置运算符实现
后置运算符的作用：1）自增 2）返回自增之前的参数，在函数内定义 int 占位符作为形参，来实现与前置自增运算符的区分。因此实现代码为：
class person{
public:
int age;
string name;
// 值传递构造函数
person(string name,int age);
// 拷贝构造函数
person(person& p);
void show();
person operator+(person& p);
person operator++(); // 前置自增运算符
person operator++(int); // 后置自增运算符
void operator<<(ostream& cout); // 左移运算符重载
};
person p2("李四", 27);
person p4 = p2++; // 调用后置运算符
cout << "p4: " << p4;
cout << "p2: " << p2;
输出结果如下：
p4: name: 李四 age: 27 // 后置自增运算符的返回值
p2: name: 李四 age: 28 // 自增之后
3.2 全局函数写法
需要注意的是，由于全局函数不属于任何一个对象，因此形参为引用或者指针传递时才能修改原数据。代码实现如下：
// 前置自增运算符实现
person operator++(person& p){
p.age++;
return p;
}
// 后置自增运算符实现
person operator++(person& p, int){
person tmp = p;
p.age++;
return tmp;
}
person p1("张三", 25);
person p2("李四", 27);
// 前置自增运算符测试
person p3 = ++p1;
cout << "p3: " << p3;
cout << "p1: " << p1;
// 后置自增运算符测试
person p4 = p2++;
cout << "p4: " << p4;
cout << "p2: " << p2;
输出结果：
p3: name: 张三 age: 26 // 前置自增运算符的返回值
p1: name: 张三 age: 26 // 自增之后
p4: name: 李四 age: 27 // 后置自增运算符的返回值
p2: name: 李四 age: 28 // 自增之后
3.3 链式编程
由于后置自增运算符没有链式实现，因此我们仅仅以前置自增运算符进行说明。首先我们先使用上述全局函数实现的自增重载函数进行链式测试，代码如下：
person p1("张三", 25);
person p3 = ++(++p1);
cout << "p3: " << p3;
cout << "p1: " << p1;
输出如下：
p3: name: 张三 age: 27 // 两次前置自增之后的返回值
p1: name: 张三 age: 26 // 两次自增之后
这个输出结果是不对的，我们期望经过两次前置递增之后，p1.age 同样也递增两次变为 27，p2.age 也递增两次变为 29。通过分析发现：我们每次通过值传递的方式进行返回，所以在作为第一轮递增之后，++p1 返回了一个临时创建的副本，继续进行下一次的递增，导致第二次的递增没有发生在 p1 身上。解决这种问题的办法就是将值返回改为返回引用。
以成员函数实现改写后的代码为例：
class person{
public:
int age;
string name;
// 值传递构造函数
person(string name,int age);
// 拷贝构造函数
person(person& p);
void show();
person operator+(person& p);
person& operator++(); // 前置自增运算符
person operator++(int); // 后置自增运算符
void operator<<(ostream& cout); // 左移运算符重载
};
person& person::operator++(){
age++;
return *this;
}
person person::operator++(int){
person tmp(*this);
age++;
return tmp;
}
person p1("张三", 25);
person p3 = ++(++p1);
cout << "p3: " << p3;
cout << "p1: " << p1;
输出结果如下：
p3: name: 张三 age: 27 // 两次前置自增之后的返回值
p1: name: 张三 age: 27 // 两次自增之后
