第五层：C++中的运算符重载

最新推荐文章于 2024-10-08 12:54:42 发布
最新推荐文章于 2024-10-08 12:54:42 发布
阅读量1k 收藏 16
点赞数 25
分类专栏： C++爬塔日记 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72867798/article/details/128740876
版权

文章目录

🎉welcome🎉
✒️博主介绍：一名大一的智能制造专业学生，在学习C/C++的路上会越走越远，后面不定期更新有关C/C++语法，数据结构，算法，Linux，ue5使用，制作游戏的心得，和大家一起共同成长。
✈️C++专栏：C++爬塔日记
😘博客制作不易，👍点赞+⭐收藏+➕关注

前情回顾

第四层中，我遇到了一个很新奇的力量，叫做友元，可以把一些人变成好朋友的神奇力量，除此之外，还学习到了，类内声明函数，类外进行定义的操作，同时，也踏入了第五层…

运算符重载

黑黝黝的洞口，一个人影在缓缓出现，“我就知道你肯定可以掌握友元的，这次需要你掌握另一种重载的力量——运算符重载，祝你好运…”。“新的重载吗…”。

概念

  • 对已有的运算符进行重新定义，赋予其另一种功能，以适应各种不同的运算类型

为什么会出现运算符重载

  • 对于内置的数据类型，编译器知道如何运算，但是对于自定义类型，是不知道如何去运算的，这个时候就需要运算符重载，本质上，是写一个函数来告诉编译器。

运算符重载中函数名格式

  • 对于运算符重载中，上面提到，本质上是写一个函数，不同的人对于函数的命名方式是不一样的，这样编译器也不好识辨，这个函数是不是在实现运算符重载，所以编译器提供了一个固定的格式：
  • operator+（这里这个加号可以替换成别的符号，当你要对什么符号进行运算符重载时就用什么符号）

加减运算符重载

作用

  • 实现两个自定义数据类型的相加减运算

实现

上面提到对于内置数据类型编译器可以知道如何去运算，而自定义类型是不知道的，那现在有一个类，它有三个对象，其中一个对象等于其他两个对象加起来，要怎么实现，可以先验证直接用+能不能进行：

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{

	}
	A(int a, int b)
	{
		_a = a;
		_b = b;
	}
	int _a;
	int _b;
};

void test1()
{
	A a1(10, 10);
	A a2(10, 10);
	A a3;
	a3 = a1 + a2;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
报错了，没有与这些操作数匹配的“+”运算符，这个错误说明了编译器是不知道对象内部怎么进行加减的，那设计一个函数，函数名字用上面提到的operate+：

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{

	}
	A(int a, int b)
	{
		_a = a;
		_b = b;
	}
	A operator+(A &a1)
	{
		A tmp;
		tmp._a = this->_a + a1._a;
		tmp._b = this->_b + a1._b;
		return tmp;
	}
	int _a;
	int _b;
};

void test1()
{
	A a1(10, 10);
	A a2(10, 10);
	A a3;
	a3 = a1 + a2;
	cout << a3._a<<"   "<< a3._b;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
其实这中写法的本质还是调用函数，即：

  • a3=a1+a2 == a3=a1.operator+(a2)

同时也可以把这个改成类外的全局函数，这个时候传参就需要传两个，内部改一下：

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{

	}
	A(int a, int b)
	{
		_a = a;
		_b = b;
	}
	//A operator+(A &a1)
	//{
	//	A tmp;
	//	tmp._a = this->_a + a1._a;
	//	tmp._b = this->_b + a1._b;
	//	return tmp;
	//}
	int _a;
	int _b;
};
A operator+(A& a1, A& a2)
{
	A tmp;
	tmp._a = a1._a + a2._a;
	tmp._b = a1._b + a2._b;
	return tmp;
}

void test1()
{
	A a1(10, 10);
	A a2(10, 10);
	A a3;
	a3 = a1 + a2;
	cout << a3._a<<"   "<< a3._b;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
也是可以正常跑起来的。
减号同理，与加号实现原理一致，只需要把+换成-。

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{

	}
	A(int a, int b)
	{
		_a = a;
		_b = b;
	}
	//A operator+(A &a1)
	//{
	//	A tmp;
	//	tmp._a = this->_a + a1._a;
	//	tmp._b = this->_b + a1._b;
	//	return tmp;
	//}
	int _a;
	int _b;
};
A operator-(A& a1, A& a2)
{
	A tmp;
	tmp._a = a1._a - a2._a;
	tmp._b = a1._b - a2._b;
	return tmp;
}

void test1()
{
	A a1(10, 10);
	A a2(10, 10);
	A a3;
	a3 = a1 - a2;
	cout << a3._a<<"   "<< a3._b;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

左移运算符重载

作用

  • 可以输出自定义的数据类型

左移运算符是什么？

  • 左移运算为程序员调用cout的时候，会在后面加“<<”，这个就是左移运算符

实现

同样，可以直接用cout来进行只用类就把类内属性都打印出来吗：

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{

	}
	A(int a, int b)
	{
		_a = a;
		_b = b;
	}
	//A operator+(A &a1)
	//{
	//	A tmp;
	//	tmp._a = this->_a + a1._a;
	//	tmp._b = this->_b + a1._b;
	//	return tmp;
	//}
	int _a;
	int _b;
};
A operator-(A& a1, A& a2)
{
	A tmp;
	tmp._a = a1._a - a2._a;
	tmp._b = a1._b - a2._b;
	return tmp;
}

void test1()
{
	A a1(10, 10);
	A a2(10, 10);
	A a3(0, 0);
	a3 = a1 - a2;
	cout << a3 << endl ;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

明显是不可以的，那要怎么样进行改造呢？如果是成员函数呢？传参和返回类型是什么？返回类型暂定为void，那参数呢？cout吗？那传参cout简化就变成了：

  • 对象<<cout

放的顺序不一样，所以成员函数无法实现，那就用全局函数，用之前，需要探究一个事情，cout是什么类型？转到定义看一下：

在这里插入图片描述
cout的类型就是ostream，那类型解决了，还有什么注意事项吗？有，并且很重要：

  • 对于全局来说，只有一个cout，所以cout是需要进行引用的，对象也是需要进行引用才可以。
#include<iostream>
using namespace std;

class A
{
public:
	A()
	{

	}
	A(int a, int b)
	{
		_a = a;
		_b = b;
	}
	//A operator+(A &a1)
	//{
	//	A tmp;
	//	tmp._a = this->_a + a1._a;
	//	tmp._b = this->_b + a1._b;
	//	return tmp;
	//}
	int _a;
	int _b;
};
A operator-(A& a1, A& a2)
{
	A tmp;
	tmp._a = a1._a - a2._a;
	tmp._b = a1._b - a2._b;
	return tmp;
}
void operator<<(ostream& cout, A& a3)
{
	cout << a3._a << "   " << a3._b;
}
void test1()
{
	A a1(10, 10);
	A a2(10, 10);
	A a3(0, 0);
	a3 = a1 - a2;
	cout << a3 << endl;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
为什么这里还是有报错？对于cout这种能一直在后面追加编程，称作链式编程，在前面的this指针中，提到过一种用途，这里也要用到，因为返回的是void，所以对于endl来说，前面的就不是cout，所以就不能进行输出，那这里就需要返回一个cout，cout的类型，同时记得加引用：

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{

	}
	A(int a, int b)
	{
		_a = a;
		_b = b;
	}
	//A operator+(A &a1)
	//{
	//	A tmp;
	//	tmp._a = this->_a + a1._a;
	//	tmp._b = this->_b + a1._b;
	//	return tmp;
	//}
	int _a;
	int _b;
};
A operator-(A& a1, A& a2)
{
	A tmp;
	tmp._a = a1._a - a2._a;
	tmp._b = a1._b - a2._b;
	return tmp;
}
ostream& operator<<(ostream& cout, A& a3)
{
	cout << a3._a << "   " << a3._b;
	return cout;
}
void test1()
{
	A a1(10, 10);
	A a2(10, 10);
	A a3(0, 0);
	a3 = a1 - a2;
	cout << a3 << endl;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

递增递减运算符

作用

  • 通过重载递增递减预算符，实现自己类内的整型数据

实现

前置

前置的递增递减是前++（- -），在使用，所以可以先在实现的函数内部先进行++（- -），在返回引用，这里为什么要返回引用呢？如果不返回引用，那就是对局部这个变量进行了++（- -），多次使用++（- -），本身只会生成一次，因为不是引用，会产生拷贝，把数据拷贝到新的空间上：

  • 使用引用
#include<iostream>
using namespace std;

class A
{
public:
	A()
	{

	}
	A(int a, int b)
	{
		_a = a;
		_b = b;
	}
	A& operator++()
	{
		this->_a++;
		this->_b++;
		return *this;
	}
	//A operator+(A &a1)
	//{
	//	A tmp;
	//	tmp._a = this->_a + a1._a;
	//	tmp._b = this->_b + a1._b;
	//	return tmp;
	//}
	int _a;
	int _b;
};
A operator-(A& a1, A& a2)
{
	A tmp;
	tmp._a = a1._a - a2._a;
	tmp._b = a1._b - a2._b;
	return tmp;
}
ostream& operator<<(ostream& cout, A& a3)
{
	cout << a3._a << "   " << a3._b;
	return cout;
}
void test1()
{
	A a1(10, 10);
	A a2(10, 10);
	A a3(0, 0);
	a3 = a1 - a2;
	cout << ++(++a3) << endl;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

  • 不使用引用
#include<iostream>
using namespace std;

class A
{
public:
	A()
	{

	}
	A(int a, int b)
	{
		_a = a;
		_b = b;
	}
	A operator++()
	{
		this->_a++;
		this->_b++;
		return *this;
	}
	//A operator+(A &a1)
	//{
	//	A tmp;
	//	tmp._a = this->_a + a1._a;
	//	tmp._b = this->_b + a1._b;
	//	return tmp;
	//}
	int _a;
	int _b;
};
A operator-(A& a1, A& a2)
{
	A tmp;
	tmp._a = a1._a - a2._a;
	tmp._b = a1._b - a2._b;
	return tmp;
}
ostream& operator<<(ostream& cout, A& a3)
{
	cout << a3._a << "   " << a3._b;
	return cout;
}
void test1()
{
	A a1(10, 10);
	A a2(10, 10);
	A a3(0, 0);
	a3 = a1 - a2;
	cout << ++(++a3) << endl;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
直接是报错的。
前置递减实现也相同，将++换成–即可。

后置

当定义后置++的时候，发现，与前置++使用的是一样的名字，发现了重定义，那这个时候怎么办？可以在参数中写一个int，用于区分，这个int属于占位参数，用于区分前置递增和后置递增，编译器是只认int的，对于后置递增，应该记录初始结果，如果在递增，返回初始结果，这个时候应该返回值，而不是引用，因为返回的是一个局部变量，如果返回引用，就会非法访问：

  • 不是用引用
#include<iostream>
using namespace std;

class A
{
public:
	A(int a)
	{
		_a = a;
	}
	//后置++
	A operator++(int)
	{
		int a = this->_a++;
		return a;
	}
	int _a;
};
void test1()
{
	A a1(10);
	cout << a1._a++ << endl;
	cout << a1._a << endl;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

  • 是引用
#include<iostream>
using namespace std;

class A
{
public:
	A(int a)
	{
		_a = a;
	}
	//后置++
	A& operator++(int)
	{
		int a = this->_a++;
		return a;
	}
	int _a;
};
void test1()
{
	A a1(10);
	cout << a1._a++ << endl;
	cout << a1._a << endl;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

赋值运算符重载

  • 其实在C++中，编译器一般会给一个类默认提供四个函数
  1. 默认构造函数（无参，函数体为空）
  2. 默认析构函数（无参，函数体为空）
  3. 默认拷贝函数，对属性进行浅拷贝
  4. 赋值运算符，对属性进行浅拷贝

注意！：

  • 当这个时候属性内的值有属性指向堆区时，赋值操作符也会产生深拷贝和浅拷贝问题

编译器提供的是浅拷贝，这个时候在析构函数内进行delete释放内存时，会出现内存释放两次，所以这个时候operator=修改成深拷贝即可，注意，在赋值操作符之前，应该先判断赋值左侧值内堆区是否有数据，有数据要先释放干净，在进行深拷贝，记得返回值要返回自身：

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{
		p = new int;
	}
	~A()
	{
		delete p;
		p = NULL;
	}
	void operator=(A& a)
	{
		if (p != NULL)
		{
			p = NULL;
		}
		p = new int(*a.p);
	}
	int* p;
};

void test1()
{
	A a;
	*a.p = 10;
	A b;
	b = a;
	cout << *b.p << endl;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

关系运算符重载

作用

  • 可以人两个自定义类型进行比较操作

实现

只用对比每一组属性是否相等，相等返回真，不相等返回假：

#include<iostream>
using namespace std;

class A
{
public:
	A(int a, char c)
	{
		_a = a;
		_c = c;
	}
	bool operator==(A& a)
	{
		if (_a == a._a && _c == a._c)
		{
			return 1;
		}
		return 0;
	}
	int _a;
	char _c;
};
void test1()
{
	A a(10, 'c');
	A b(10, 'c');
	if (a == b)
	{
		cout << "a=b" << endl;
	}
	else
	{
		cout << "a!=b" << endl;
	}
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

函数调用运算符重载

  • 函数调用操作符()也可以重载
  • 由于重载后调用的方式和函数本身的调用相似，所以也被称为仿函数
  • 仿函数没有固定写法，函数体内可以写任何。

事例：

#include<iostream>
using namespace std;

class A
{
public:
	void operator()()
	{
		cout << "仿函数调用" << endl;
	}
};
void test1()
{
	A a;
	a();
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

第二种重载掌握！突破

面前的石碑碎去，露出后面黑黝黝的洞口…

本章知识点（图片形式）

在这里插入图片描述

😘预知后事如何，关注新专栏，和我一起征服C++这座巨塔
🚀专栏：C++爬塔日记
🙉都看到这里了，留下你们的👍点赞+⭐收藏+📋评论吧🙉

封心锁爱的前夫哥
关注
专栏目录
UE4 C++入门之路5-热重载Compile（编译项目的三种方式）
TurboQ珞珈
11-04 4544
UE4 C++入门之路5-热重载Compile（编译项目的三种方式） UE4 自动编译 Live Coding
C++——函数重载
qq_56101220的博客
01-17 267
定义：函数的一种特殊情况，允许在同一作用域中声明几个功能类似的同名函数，重载常用来处理实现功能类似数据类型不同的问题 分类： ①参数类型不同 //类型不同 int ADD(int a, int b) { return a + b; } double ADD(double a, double b) { return a + b; } ②参数数量不同 //参数数量不同 int ADD(int a, int b) { return a + b; } int ADD(int a, int b，int c.
C++ 运算符重载
热门推荐
qq_27278957的博客
12-26 7万+
前言 本文引用于“C语言中文网”，我整理出来放在博客，方便大家共同学习。所有知识点和代码均已亲测可用，如有疑问，可提出，一起讨论学习。 本章内容： 1. C++运算符重载的概念和原理 2. C++重载=（C++重载赋值运算符） 3. C++深拷贝和浅拷贝（C++深复制和浅复制） 4. C++运算符重载为友元函数 5. C++实现可变长度的动态数组 6. C++重载&lt;&lt;和&gt;...
C++:运算符重载与类的赋值运算符重载函数
小青菜的博客
01-24 2906
运算符重载
C++运算符重载详解
qq_52905520的博客
10-06 3万+
C++运算符重载详解
C++:运算符重载
weixin_45652283的博客
01-16 1365
C++规定，当不同类型的数据进行运算时，需先将数据转换成同一类型，然后才可以进行运算。数据的类型转换可以通过两种转换形式完成：一种是隐式类型转换；另一种是显式类型转换。隐式类型转换当执行赋值表达式V=E时，若V和E的类型不一致，则将E先转换为V的类型后再赋值。。当两个操作数类型不一致时，运算之前将级别低的自动转换为级别高的，然后再进行运算。显式类型转换显示类型转换有以下两种方式。1. 强制转换法：(类型名)表达式；2.函数法：类型名(表达式)。
C++运算符重载
2401_83305953的博客
09-09 3358
如果不写赋值运算符重载函数，系统会自动生成，但是浅拷贝，一个字节一个字节的拷贝，对于占用资源的还是要自己写才好。对于类类型的使用运算符编译器是不知道要干嘛的就需要自己写函数，自己实现功能。要跟拷贝构造区分，拷贝构造是一个已经存在，给另一个初始化时进行的拷贝操作。日期 - 日期，日期 + 天数，日期 - 天数，这些都是有意义的。总结如果显示写了析构，就要显示写赋值运算符重载。对两个已经存在的类的对象进行赋值拷贝操作。运算符的作用，用于定义类的成员函数指针。就比如日期类的大小比较。
【C++ | 重载运算符】一文弄懂C++运算符重载，怎样声明、定义运算符，重载为友元函数
wkd_007的博客
06-21 4025
👉本文主要介绍了为什么需要重载运算符，重载运算符有哪些限制，怎样声明、定义运算符函数，怎样将运算符重载为友元函数。
【C++】运算符重载
炸掉地球的博客
06-26 1053
但是我们如果重载成全局函数，就需要类成员变量是公有属性，因为类外无法访问类的私有成员。但是这样就会破坏封装性。 因此，为了保证封装性，我们一般将运算符重载为类的友元函数或类的成员函数。
C++实验报告实验七-运算符重载
03-14
### C++实验报告实验七-运算符重载 #### 实验目的 本次实验的主要目标是通过实际编程加深对C++中运算符重载的理解和应用。具体包括： 1. **编写程序熟悉运算符重载函数的定义和使用**：通过实践操作理解如何...
C++之操作符重载探究(五)：赋值运算符重载和拷贝赋值函数(深拷贝)
小勇博客
12-19 581
前文：C++之操作符重载探究(四)：下标运算符重载 赋值运算符重载 浅拷贝产生的问题：   尽管一个对象可以通过赋值语句赋值给另一个对象，正如我们前面所提到的，这个操作可能只创建一个逻辑拷贝（即成员和成员的浅拷贝）。在浅拷贝中，一个对象的成员，仅仅简单copy另一个对象的成员的值。   如果对象包含指针成员，拷贝的仅仅是指针变量本身的值（地址），即两个对象的指针成员指向同一块空间。对于指针成员的一对一拷贝可能产生两个问题： （1）两个指针成员指向同一块空间，改变其中一个，另一个也跟着改变，换句话说，这两个对
C++：拷贝构造函数和赋值运算符重载
2302_79988283的博客
04-25 2448
6. 虽然编译器会生成默认的拷贝构造函数，但仅仅会完成浅拷贝，如果拷贝的函数涉及空间申请（如stack），则会出现错误（两个函数会申请到同一块空间，销毁时会出现同一块空间释放2次，导致程序崩溃）。： 编译器自动生成的赋值运算符重载是浅拷贝，对于无空间申请的函数可以（如Date）,对于有空间申请的函数就不可以（如Stack），必须自己写。上图中，我故意将减法重载成加法，Sum执行的+是我重载的减法，但b执行的还是加法，说明内置类型的运算符不受重载运算符的影响。
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1712
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
数组综合应用（下标计数）C++
最新发布
hjxxlsx的博客
10-08 754
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
windows C++-创建数据流代理(三)
苏洛的博客
10-08 250
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
【C语言】数据类型和变量
2302_76713442的博客
10-06 1494
一、数据类型分类（内置数据类型：字符型、整型、浮点型和布尔类型）（自定义数据类型：数组、结构体、枚举和联合体）二~三、深入研究内置数据类型（内置数据类型的大小、使用内置数据类型创建变量、signed 和 unsigned）四、自定义数据类型的内容过于庞大，所以每种自定义数据类型都专门写了一篇博客来介绍，文中有相应链接。
C++：图的最短路径问题
han2205277149的博客
10-04 1085
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
评论 29
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

封心锁爱的前夫哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值