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

三、递增运算符重载

递增运算符++有两种表现形式，分为前置和后置。

1. 当为前置方式时"++p"，p的值先自增1，然后再返回增1后的p值
2. 当为后置方式时"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	// 两次自增之后