C++中运算符的重载

概述运算符重载相当于运算符的函数重载，用于对已有的运算符进行重新定义，赋予其另一种功能，以适应不同的数据类型。我们之前提到过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("张三",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("张三",27);cout << p1 << p2;

输出结果为：

name: 张三      age: 25name: 李四      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("张三",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	// 两次自增之后

总结

以上是内存溢出为你收集整理的C++中运算符的重载全部内容，希望文章能够帮你解决C++中运算符的重载所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。