C++中运算符重载【详细讲解】

已于 2024-01-17 14:31:46 修改
阅读量524 收藏 2
点赞数 4
文章标签： c++ 开发语言 visual studio
于 2023-10-13 15:27:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45688108/article/details/133811436
版权

1、运算符重载的目的

通过运算符重载实现使用同一个运算符可以完成不同的运算功能。类比着函数重载来学习，运算符重载也是在编译阶段完成的。

运算符重载------就是对现有的运算符进行重新定义，赋予其另外一种能力，为了操作不同的数据类型。【注意：是重载，不影响运算符原来的功能】

2、运算符重载相关规定

1）运算符重载使用operator关键字；
2）不能改变运算符的优先级；（比如：乘除的优先级高于加减）
3）不能改变原运算符的结合性；（左结合或者右结合）
4）默认参数不能和运算符重载一起使用；
5）不能改变原有运算符的操作数的个数；（单目运算，双目运算或者三目运算）
6）不能改变运算符的性质；（比如：在重载时，不能将对“+”运算符重载为“-”）
7）可以用于用户定义的类对象或者用户定义的类对象与内置成员函数的组合；
8）不能发生重载的运算符。（如下表所示：）

不能发生重载的运算符如下：

成员访问.
域运算符::
计算所占内存sizeof
三目运算符: ?
预处理#
取值运算符*

 只能重载为类内成员函数的运算符如下：（原因：运算符重载为类内成员函数一个至关重要的特点：【类的this指针会被绑定到运算符左侧的运算对象】，也就是说以下运算符的左操作数必须是该类类型的参数）

赋值=
下标[ ]
调用（ ）
成员访问->

3、运算符重载实现

运算符重载通过【函数】实现。

运算符重载函数主要的三种形式：1）重载为类的成员函数；2）重载为类的友元函数【为了解决普通函数权限不够的问题】；3）普通函数。

4、双目运算符重载（以“+”、“>”、“=”、“<<”（提取）、“>>”(输入)等为例）

双目运算符重载【在类里面实现只能具有一个参数】，隐含的第一个参数是【this指针】；【类外进行重载可以有两个参数】。

1）算数运算符：“+”的重载

（1）重载为类的成员函数

#include <iostream>

using namespace std;

class MyOperator {
public:
	//构造函数（用来初始化成员属性）
	MyOperator(int data) :Data(data)
	{

	}
	//类型运算符"+"重载【类内重载：默认第一个参数是this】
	MyOperator operator+(MyOperator myoperator)
	{
		MyOperator temp(0);          //创建一个临时对象，在进行函数返回值时候使用
		temp.Data = this->Data + myoperator.Data;
		return temp;
		/*
		注意：该函数中代码不能使用下面的代码代替
		this->Data += myoperator.Data;
		return *this;
		【原因是：运算符在类内重载，默认第一个参数是this指针【指向的是对象本身】，如果使用上述代码会将第一个对象中的值进行修改，不满足加法的本质】
		*/
	}
    
public:
	int Data;
};

int main()
{
	MyOperator a(10);
	MyOperator b(20);
	MyOperator c = a + b;   //调用运算符重载函数来实现两个对象相加【原来"+"号是无法实现两个对象相加的】
	cout << "a.Data的值：" << a.Data << endl;
	cout << "b.Data的值：" << b.Data << endl;
	cout << "c.Data的值：" << c.Data << endl;
	return 0;
}

运行结果：

a.Data的值：10
b.Data的值：20
c.Data的值：30

（2）重载为类的友元函数

#include <iostream>

using namespace std;

class MyOperator {
	friend MyOperator operator+ (MyOperator myopt1, MyOperator myopt2);        //声明成友元函数
public:
	//构造函数（用来初始化成员属性）
	MyOperator(int data) :Data(data)
	{

	}
	//普通成员函数【目的：获取私有成员属性的值】
	int getData()
	{
		return Data;
	}

private:
	int Data;
};
//类外重载"+"函数的定义
MyOperator operator+ (MyOperator myopt1, MyOperator myopt2)     //【注意：这里传递的是值，而不是对象本身，所以不必担心会将原来对象中的值改变】
{
	MyOperator temp(0);
	temp.Data = myopt1.Data + myopt2.Data;
	return temp;
	/*
	注意：该函数中代码可以使用以下代码代替
	myopt1.Data += myopt2.Data;
	return myopt1;
	【原因：传递过来的是值，而不是对象本身】
	*/
}

int main()
{
	MyOperator a(10);
	MyOperator b(20);
	MyOperator c = a + b;   //调用运算符重载函数来实现两个对象相加【原来"+"号是无法实现两个对象相加的】
	cout << "a.Data的值：" << a.getData() << endl;
	cout << "b.Data的值：" << b.getData() << endl;
	cout << "c.Data的值：" << c.getData() << endl;
	return 0;

}

 运行结果：

a.Data的值：10
b.Data的值：20
c.Data的值：30

（3）重载为普通函数

#include <iostream>

using namespace std;

class MyOperator {
public:
	//构造函数（用来初始化成员属性）
	MyOperator(int data) :Data(data)
	{

	}
	//普通成员函数【目的：获取私有成员属性的值】
	int getData()
	{
		return Data;
	}

public:
	int Data;
};
//类外重载"+"函数的定义
MyOperator operator+ (MyOperator myopt1, MyOperator myopt2)     //【注意：这里传递的是值，而不是对象本身，所以不必担心会将原来对象中的值改变】
{
	MyOperator temp(0);
	temp.Data = myopt1.Data + myopt2.Data;
	return temp;
	/*
	注意：该函数中代码可以使用以下代码代替
	myopt1.Data += myopt2.Data;
	return myopt1;
	【原因：传递过来的是值，而不是对象本身】
	*/
}

int main()
{
	MyOperator a(10);
	MyOperator b(20);
	MyOperator c = a + b;   //调用运算符重载函数来实现两个对象相加【原来"+"号是无法实现两个对象相加的】
	cout << "a.Data的值：" << a.getData() << endl;
	cout << "b.Data的值：" << b.getData() << endl;
	cout << "c.Data的值：" << c.getData() << endl;
	return 0;

}

 运行结果：

a.Data的值：10
b.Data的值：20
c.Data的值：30

2）关系运算符：“>”的重载

（1）重载为类成员函数

#include <iostream>

using namespace std;
class MyOperator {
public:
	//构造函数（用于初始化成员属性）
	MyOperator(int data) :Data(data)
	{

	}
	//运算符">"重载为类内函数
	bool operator>(MyOperator a)          //返回值为布尔类型
	{
		if (this->Data > a.Data)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
public:
	int Data;
};

int main()
{
	MyOperator a(10);
	MyOperator b(20);
	if (a > b)              //调用重载运算符，来比较两个对象的大小
	{
		cout << "a > b" << endl;
	}
	else
	{
		cout << "a < b" << endl;
	}
	return 0;
}

运行结果：

a < b

（2）重载为类的友元函数

#include <iostream>

using namespace std;
class MyOperator {
	friend bool operator>(MyOperator a, MyOperator b);          //友元函数的声明   
public:
	//构造函数（用于初始化成员属性）
	MyOperator(int data) :Data(data)
	{

	}
private:
	int Data;
};
// 运算符">"重载为友元函数
bool operator>(MyOperator a, MyOperator b)          //返回值为布尔类型
{
	if (a.Data > b.Data)
	{
		return true;
	}
	else
	{
		return false;
	}
}
int main()
{
	MyOperator a(10);
	MyOperator b(20);
	if (a > b)              //调用重载运算符，来比较两个对象的大小
	{
		cout << "a > b" << endl;
	}
	else
	{
		cout << "a < b" << endl;
	}
	return 0;
}

 运行结果：

a < b

（3）重载为普通函数

#include <iostream>

using namespace std;
class MyOperator {
public:
	//构造函数（用于初始化成员属性）
	MyOperator(int data) :Data(data)
	{

	}
public:
	int Data;
};
// 运算符">"重载为友元函数
bool operator>(MyOperator a, MyOperator b)          //返回值为布尔类型
{
	if (a.Data > b.Data)
	{
		return true;
	}
	else
	{
		return false;
	}
}
int main()
{
	MyOperator a(10);
	MyOperator b(20);
	if (a > b)              //调用重载运算符，来比较两个对象的大小
	{
		cout << "a > b" << endl;
	}
	else
	{
		cout << "a < b" << endl;
	}
	return 0;
}

 运行结果：

a < b

3）赋值运算符：“=”的重载

赋值运算符operator=，对属性进行【值拷贝】；编译器会默认提供一个赋值运算符的重载函数。

【重点】赋值运算符”=“【只能重载为类的成员函数，不能重载为友元函数或者普通函数】。

#include <iostream>

using namespace std;
class MyOperator {
public:
	//构造函数（用于初始化成员属性）
	MyOperator(int data) :Data(data)
	{

	}
	//运算符"="重载为类内函数
	MyOperator operator=(MyOperator a)
	{
		this->Data = a.Data;
		return *this;       //this指针指向的是对象的地址，*this就是这个对象本身
	}
	//普通成员函数（目的：用于获取私有成员属性的值）
	int getData(void)
	{
		return Data;
	}
private:
	int Data;
};
int main()
{
	MyOperator a(10);
	cout << "a.Data当前的值：" << a.getData() << endl;
	cout << "--------------------------------" << endl;
	a = 20;
	cout << "a.Data修改后的值：" << a.getData() << endl;
	return 0;
}

 运行结果：

a.Data当前的值：10
--------------------------------
a.Data修改后的值：20

3）提取运算符：“<<”的重载

（1）为什么要对于“<<”进行重载

在C++中，标准库本身已经对“<<”和“>>”操作符分别进行了重载，使其能够输入输出不同的数据。这些数据均是来自于C++内置的数据（如int、bool、double等）和标准库所包含的类型（如string、complex等）。如果用户自己定义了一种新的数据类型，需要使用输入输出运算符去处理时，就需要进行重载。

（2）如何实现

  • 首先，需要明确一个问题，cout其实是ostream中的类对象，也就是需要将cout看做一个对象。因此，在对“<<”进行重载时，只能重载为普通函数或者友元函数【因为重载为类内函数默认第一个参数是this指针】。

  • 其次，直接上程序。程序中有详细注释，可以帮助理解。【代码是重载为普通函数的代码，重载为友元函数只需要稍微改动一下即可】

#include <iostream>

using namespace std;

class MyOperator {
public:
	//构造函数
	MyOperator(int data) :Data(data)
	{

	}
public:
	int Data;
};
//重载为普通函数
ostream& operator<<(ostream& output_c, MyOperator a)//注意这里的第一个参数传入的是引用，将cout的引用传递给output_c
													//这样output_c才能作为标准输出
{
	output_c << a.Data;
	return output_c;                                //注意这里的返回值，返回值类型为ostream&,而不是单纯的ostream
													//如果这里只是单纯ostream的话，返回的是值，会导致后面再次输出a的时候出现错误【简单来说，就是无法实现连续输出，只能一个一个输出】
}

int main()
{
	MyOperator a(10);
	cout << a << endl;;
	return 0;
}

运行结果：

10

结果解释：【程序中的注释结合图像来理解这部分代码】

 4）输入运算符：“>>”的重载

基本内容与提取运算符“<<”的一致，只是存在一点不同。“>>”输入运算符会【改变对象的值】，因此在进行重载时，【需要传入的是对象的引用】。

重载为普通成员函数：

#include <iostream>

using namespace std;

class MyOperator {
public:
	//构造函数
	MyOperator(int data) :Data(data)
	{

	}
public:
	int Data;
};
//"<<"重载为普通函数
ostream& operator<<(ostream& output_c, MyOperator a)//注意这里的第一个参数传入的是引用，将cout的引用传递给output_c
													//这样output_c才能作为标准输出
{
	output_c << a.Data;
	return output_c;                                //注意这里的返回值，返回值类型为ostream&,而不是单纯的ostream
													//如果这里只是单纯ostream的话，返回的是值，会导致后面再次输出a的时候出现错误
													//【简单来说，就是无法实现连续输出，只能一个一个输出】
}
//">>"重载为普通函数
istream& operator >>(istream& input_c, MyOperator& a)      //注意这里的第二个参数，传递的是对象的引用而不是对象中的值
{
	input_c >> a.Data;
	return input_c;
}

int main()
{
	MyOperator a(10);   //初始a对象中的Data属性的值为10
	cout << "a中初始Data的值为：" << a << endl;
	cin >> a;
	cout << "a中修改后Data的值为：" <<a << endl;
	return 0;
}

运行结果：

a中初始Data的值为：10
20
a中修改后Data的值为：20

5、单目运算符重载（以“++”为例）

1）递增运算符++

前置++和后置++的区别：

返回类型不同前置++的返回类型是&（引用类型）；而后置++返回类型是const（常量类型）。这就表明，前置++返回的是左值，可以被修改；而后置++返回的是右值，不可以被修改
形参不同前置++与后置++的操作符重载函数的函数原型不同。在进行重载时，后置++增加了一个int形参
代码不同前置++代码实现较为简单；而后置++实现较为复杂，因为需要提前拷贝出来一份原来的值
执行顺序不同前置++首先增加变量的值，然后返回新值；后置++首先返回变量当前的值，然后增加变量的值

 2）程序

（1）重载为类成员函数

#include <iostream>

using namespace std;

class MyOperator {
public:
	MyOperator(int data):Data(data)
	{

	}
	//前置++重载为类内函数
	MyOperator &operator++(void)
	{
		this->Data += 1;
		return *this;               //返回的是引用，也就是对象本身，不是值
	}
	//后置++重载为类内函数
	MyOperator operator++(int)      //参数填写一个int是为了满足标准语法要求
	{
		MyOperator temp(0);         //临时对象，做拷贝使用
		temp.Data = this->Data;     //先进行拷贝
		this->Data += 1;            //再实现自增
		return temp;                //最后返回副本的值
	}
public:
	int Data;
};

int main()
{
	MyOperator a(100);
	cout << "前置++后a.Data的值为：" << ++a.Data << endl;
	cout << "后置++后a.Data的值为：" << a++.Data << endl;
	return 0;
}

 运行结果：

前置++后a.Data的值为：101
后置++后a.Data的值为：101

（2）重载为普通函数

#include <iostream>

using namespace std;

class MyOperator {
public:
	MyOperator(int data):Data(data)
	{

	}
public:
	int Data;
};
//前置++重载为普通函数
MyOperator& operator++(MyOperator &a)
{
	a.Data += 1;
	return a;                   //返回的是引用，也就是对象本身，不是值
}
//后置++重载为普通函数
MyOperator operator++(MyOperator &a,int)      //参数填写int是为了满足标准语法要求
{
	MyOperator temp(0);         //临时对象，做拷贝使用
	temp.Data = a.Data;         //先进行拷贝
	a.Data += 1;                //再实现自增
	return temp;                //最后返回副本的值
}
int main()
{
	MyOperator a(100);
	cout << "前置++后a.Data的值为：" << ++a.Data << endl;
	cout << "后置++后a.Data的值为：" << a++.Data << endl;
	return 0;
}

运行结果：

前置++后a.Data的值为：101
后置++后a.Data的值为：101
不爱敲代码~
关注
c++之运算符重载
luoyeliufeng的博客
06-21 356
什么是运算符重载 运算符重载类似函数重载是为已有的运算符定义新的运算功能，体现了多态性。 举个例子 “+”的基本功能是实现整数相加和实数相加 通过运算符重载我们可以对他的功能进行扩充，我们之前用的string类中就是如此 string a=“123’,b=“456”,c; 则 c=a+b; c就为"123456” 这里"+"被重载为两个字符串拼接 实现运算符重载功能的函数称为于是暖夫重载函数，格式为 返回类型 operator 运算符符号(参数说明); 运算符重载的两种形式 用成员函数实现运算符重载 举例子
【C++】运算符重载详解
qq_64818885的博客
02-04 3678
运算符重载函数的参数取决于要重载的运算符的操作数个数和类型。
C++中operator关键字（重载操作符）
最新发布
木牛的博客
07-31 550
operator是C++的关键字，它和运算符一起使用，表示一个运算符函数，理解时应将operator=整体上视为一个函数名。这是C+ +扩展运算符功能的方法，虽然样子古怪，但也可以理解：一方面要使运算符的使用方法与其原来一致，另一方面扩展其功能只能通过函数的方式（c++中，“功能”都是由函数实现的)。
C++运算符重载（操作符重载）
qq_41885018的博客
05-11 1269
有时候我们需要让对象之间进行运算， C++ 提供的“运算符重载”机制，赋予运算符新的功能，就能解决用+将两个复数对象相加这样的问题。，因为左移运算符左边是cout，而想要调用类里的成员函数首先要是对象才行，而cout显然不是对象，括号运算符()也可以重载，对象名可以当成函数来使用（函数对象、仿函数）。除了 “ + ”，还有其他的运算符重载，如 “ - ”（减法运算）接着刚才的问题，我们利用运算符重载为运算符增加一些新的功能，，既可以接受const对象，也可以接受非const对象。
c++ 运算符重载
m0_64071735的博客
05-25 2035
一、为什么要运算符重载 #include<iostream> #include<string> using namespace std; class ABC { int a, b, c; public: ABC(int x , int y ,int z): a(x),b(y),c(z){} friend ostream &operator << (ostream & out,ABC& f); }; ostream &am
C++运算符重载(超全）
LancasterLiu的博客
06-27 3万+
C++运算符重载 1) 运算符重载的本质为函数重载，但有一定的规则需要遵循。[1] (1)重载运算符时,运算符的运算顺序和优先级不变,操作数个数不变。 (2)不能创造新的运算符,只能重载C++中已有的运算符,并且规定有6个运算符不能重载,如表所示。 不能重载的运算符 含义 . 类属关系运算符 .* 成员指针运算符 :: 作用域运算符 ?: 条件运算符 # 编译预处理符号 sizeof() 取数据类型的长度 (3)运算符重载是针对新类型的实际需求,对原有的运算符进行适当
C++中运算符重载的规则语法实例
08-26
C++中运算符重载的规则语法实例 C++中运算符重载是指对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来说，重载的...
c++中运算符重载精讲
04-25
C++中运算符重载精讲 C++中的运算符重载是一种强大的技术，它允许开发者重新定义C++语言中固有的运算符的行为，使得编程更加灵活和方便。在本节中，我们将深入探讨C++中的运算符重载机制、方法和应用。 一、运算符...
c++中运算符重载的例子
06-28
运算符重载是C++中的一项特性，它允许程序员自定义特定运算符在特定类型上的行为。通过重载，我们可以为已有的基本运算符赋予新的意义，使其适用于我们的自定义类。下面是一个简单的例子，演示如何重载加法运算符 `+...
C++中运算符 &和&&、|和|| 的详解及区别
01-21
C++中运算符 &和&&、|和|| 的详解及区别 简介： &&是逻辑与运算符，||是逻辑或运算符，都是逻辑运算符，两边只能是bool类型 &与| 既可以进行逻辑运算，又可以进行位运算，两边既可以是bool类型，又可以是数值类型 ...
C++运算符重载详解
热门推荐
lishuzhai的专栏
03-02 15万+
为什么要对运算符进行重载： C++预定义中的运算符的操作对象只局限于基本的内置数据类型，但是对于我们自定义的类型（类）是没有办法操作的。但是大多时候我们需要对我们定义的类型进行类似的运算，这个时候就需要我们对这么运算符进行重新定义，赋予其新的功能，以满足自身的需求。 C++运算符重载的实质： 运算符重载的实质就是函数重载或函数多态。运算符重载是一种形式的C++多态。目的在于让人能够用同名的函
操作符重载
nodeathphoenix的专栏
09-08 4932
在C++语言中，可以用关键字operator加上运算符来表示函数，叫做运算符重载。例如两个复数相加函数： Complex Add(const Complex &a, const Complex &b); 可以用运算符重载来表示： Complex operator +(const Complex &a, const Complex &b); 运算符与普通函数在调用时的不同之处
C++——运算符的重载
weixin_59179454的博客
05-30 1万+
运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。让类类型的对象像基本数据类型一样去操作 例如：可以实现对象+,-* / % ==!运算符的重载实际是一种特殊的函数重载，必须定义一个函数，并告诉C++编译器，当遇到该重载的运算符时调用此函数。这个函数叫做运算符重载函数，通常为类的成员函数。定义运算符重载函数的一般格式：返回值类型 类名::operator重载的运算符(参数表) {……}operator是关键字，它与重载的运算符一起构成函数名。
C++中的 运算符重载
qq_24472227的博客
04-09 3668
C++的 各种运算符重载：加号、左移、递增、赋值、关系、函数调用
c++中运算符的重载
mxway的专栏
08-01 1089
程序1.cpp #include int main() { int a=3,b=2; cout<<a+b<<endl; return 0; }上面的程序中定义了两个整形变量a和b。并输出两个整形变量之和。 程序2.cpp #include using namespace std; class A { public: int getData() { return data;
c++学习心得第二期 友元+运算符重载
qq_37448336的博客
10-04 392
c++学习心得第二期 友元+运算符重载一、友元1 、全局函数做友元2. 类做友元3. 成员函数做友元二、运算符重载1.加号运算符重载2.左移运算符重载3.递增运算符重载4.赋值运算符重载5. 关系运算符重载6. 函数调用运算符重载 在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术 友元的目的就是让一个函数或者类 访问另一个类中私有成员 友元的关键字为 friend 友元的三种实现 全局函数做友元 类做友元 成员函数做友元 一、友元 1 、全局函数做友元 #incl
【C++入门】运算符重载详解
weixin_42031299的博客
10-31 2813
(1)运算符：运算符分为算术运算符(+、-、*、/)、关系运算符(=、!=、==)、逻辑运算符(&&、!)等；(2)运算符重载：给运算符赋予新的含义，可以根据运算符操作的对象进行恰当的操作；(3)不是所有的运算符都支持运算符重载，有的运算符的含义在任何情况下都是确定的，所以不需要重载；
C++运算符重载
qq_53795212的博客
04-08 326
运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值