C++中运算符的重载

分类：C&C++作者：ZhiboZhao

运算符重载相当于运算符的函数重载，用于对已有的运算符进行重新定义，赋予其另一种功能，以适应不同的数据类型。我们之前提到过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: 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("张三",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	// 两次自增之后

原文地址：https://www.cnblogs.com/zhaozhibo

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

浅谈C/C++中的static和extern关键字
一.C语言中的static关键字 在C语言中，static可以用来修饰局部变量，全局变量以及函数。在不同的情况下static的作用不尽相同。 (1)修饰局部变量 一般情况下，对于局部变量是存放在栈区的，并且局部变量的生命周期在该语句块执行结束时便结束了。但是如果用static进行修饰的话，该变量便存
浅谈C/C++中的指针和数组（二）
浅谈C/C++中的指针和数组（二） 前面已经讨论了指针和数组的一些区别，然而在某些情况下，指针和数组是等同的，下面讨论一下什么时候指针和数组是相同的。C语言标准对此作了说明：规则1：表达式中的数组名被编译器当做一个指向该数组第一个元素的指针； 注：下面几种情况例外 1)数组名作为sizeof的操作数
浅谈C/C++中的指针和数组（一）
浅谈C/C++中的指针和数组（一）指针是C/C++的精华，而指针和数组又是一对欢喜冤家，很多时候我们并不能很好的区分指针和数组，对于刚毕业的计算机系的本科生很少有人能够熟练掌握指针以及数组的用法和区别。造成这种原因可能跟现在大学教学以及现在市面上流行的很多C或者C++教程有关，这些教程虽然通俗易懂，
从两个例子分析C语言的声明
从两个例子分析C语言的声明 在读《C专家编程》一书的第三章时，书中谈到C语言的声明问题，《C专家编程》这本书只有两百多页，却花了一章的内容去阐述这个问题，足以看出这个问题的重要性，要想透彻理解C语言的声明问题仅仅看书是远远不够的，需要平时多实践并大量阅读别人写的代码。下面借鉴《C专家编程》书中的两个
C语言文件操作解析(一)
C语言文件操作解析(一)在讨论C语言文件操作之前，先了解一下与文件相关的东西。一.文本文件和二进制文件 文本文件的定义：由若干行字符构成的计算机文件，存在于计算机系统中。文本文件只能存储文件中的有效字符信息，不能存储图像、声音等信息。狭义上的二进制文件则指除开文本文件之外的文件，如图片、DOC文档。
C语言文件操作解析(三)
C语言文件操作解析(三) 在前面已经讨论了文件打开操作，下面说一下文件的读写操作。文件的读写操作主要有4种，字符读写、字符串读写、块读写以及格式化读写。一.字符读写 字符读写主要使用两个函数fputc和fgetc，两个函数的原型是: int fputc(int ch,FILE *fp);若写入成功则
浅谈C语言中的位段
浅谈C语言中的位段 位段(bit-field)是以位为单位来定义结构体(或联合体)中的成员变量所占的空间。含有位段的结构体(联合体)称为位段结构。采用位段结构既能够节省空间，又方便于操作。 位段的定义格式为: type [var]:digits 其中type只能为int，unsigned int，s
C语言文件操作解析(五)之EOF解析
C语言文件操作解析(五)之EOF解析 在C语言中，有个符号大家都应该很熟悉，那就是EOF(End of File)，即文件结束符。但是很多时候对这个理解并不是很清楚，导致在写代码的时候经常出错，特别是在判断文件是否到达文件末尾时，常常出错。1.EOF是什么? 在VC中查看EOF的定义可知: #def
关于VC++6.0中getline函数的一个bug
关于VC+ʶ.0中getline函数的一个bug 最近在调试程序时，发现getline函数在VC+ʶ.0和其他编译器上运行结果不一样，比如有如下这段程序：#include &lt;iostream&gt;#include &lt;string&gt;using namespace std;int
浅谈C/C++的浮点数在内存中的存储方式
C/C++浮点数在内存中的存储方式 任何数据在内存中都是以二进制的形式存储的，例如一个short型数据1156，其二进制表示形式为00000100 10000100。则在Intel CPU架构的系统中，存放方式为 10000100(低地址单元) 00000100(高地址单元)，因为Intel CPU
浅析C/C++中的switch/case陷阱
浅析C/C++中的switch/case陷阱 先看下面一段代码： 文件main.cpp#includeusing namespace std;int main(int argc, char *argv[]){ int a =0; switch(a) { case ...
浅谈C/C++中的typedef和#define
浅谈C/C++中的typedef和#define 在C/C++中，我们平时写程序可能经常会用到typedef关键字和#define宏定义命令，在某些情况下使用它们会达到相同的效果，但是它们是有实质性的区别，一个是C/C++的关键字，一个是C/C++的宏定义命令，typedef用来为一个已有的数据类型
关于数组指针的一道面试题
看下面一道面试题：#include&lt;stdio.h&gt;#include&lt;stdlib.h&gt;int main(void) { int a[5]={1,2,3,4,5}; int *ptr=(int *)(&amp;aʱ); printf(&quot;%d,%d&quot;,*(
浅谈C语言中的联合体
联合体union 当多个数据需要共享内存或者多个数据每次只取其一时，可以利用联合体(union)。在C Programming Language 一书中对于联合体是这么描述的： 1)联合体是一个结构； 2)它的所有成员相对于基地址的偏移量都为0； 3)此结构空间要大到足够容纳最&quot;宽&quo
从一个程序的Bug解析C语言的类型转换
从一个程序的Bug解析C语言的类型转换 先看下面一段程序，这段程序摘自《C 专家编程》：#include&lt;stdio.h&gt;int array[]={23,34,12,17,204,99,16};#define TOTAL_ELEMENTS (sizeof(array)/sizeof(ar
大端和小端
大端和小端 嵌入式开发者应该对大端和小端很熟悉。在内存单元中数据是以字节为存储单位的，对于多字节数据，在小端模式中，低字节数据存放在低地址单元，而在大端模式中，低字节数据存放在高地址单元。比如一个定义一个short型的变量a，赋值为1，由于short型数据占2字节。在小端模式中，其存放方式为0X40
位运算和sizeof运算符
位运算和sizeof运算符 C语言中提供了一些运算符可以直接操作整数的位，称为位运算，因此位运算中的操作数都必须是整型的。位运算的效率是比较高的，而且位运算运用好的话会达到意想不到的效果。位运算主要有6种：与(&amp;)，或(|)，取反(~)，异或(^)，左移(&gt;)。1.位运算中的类型转换位
C语言文件操作解析(四)
C语言文件操作解析(四)在文件操作中除了打开操作以及读写操作，还有几种比较常见的操作。下面介绍一下这些操作中涉及到的函数。一.移动位置指针的函数 rewind函数和fseek函数，这两个函数的原型是:void rewind(FILE *fp); 将位置指针移动到文件首 int fseek(FILE
结构体字节对齐
结构体字节对齐 在用sizeof运算符求算某结构体所占空间时，并不是简单地将结构体中所有元素各自占的空间相加，这里涉及到内存字节对齐的问题。从理论上讲，对于任何变量的访问都可以从任何地址开始访问，但是事实上不是如此，实际上访问特定类型的变量只能在特定的地址访问，这就需要各个变量在空间上按一定的规则排
C语言文件操作解析(二)
C语言文件操作解析(二)C语言中对文件进行操作必须首先打开文件，打开文件主要涉及到fopen函数。fopen函数的原型为 FILE* fopen(const char *path,const char *mode) 其中path为文件路径，mode为打开方式 1)对于文件路径，只需注意若未明确给出绝
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot