• 黑马程序员C++类和对象【5】 —— 运算符重载（蓝桥杯必备知识）万字超详解

    目录

    🤡加号运算符重载

    🤡左移运算符重载

    🤡递增运算符重载

    🤡递减运算符重载

    🤡赋值运算符重载

    🤡关系运算符重载

    🤡函数调用运算符重载（仿函数）

    🤡加号运算符重载

    如果现在我们希望对对象的属性进行求和，我们可能会想到用+直接进行相加，那么就让我们先来试试吧，下面是我实例化两个对象的两个属性相加，结果编译器会报错，说我的操作数和运算符不匹配，那么这时候就需要自己手动重载运算符了。

    作用：实现两个自定义数据类型相加的运算

    使用运算符重载（注意：重载函数名必须是编译器提供的operator+）

    成员函数重载

    1. //运算符重载
    2. class Person {
    3. public:
    4.  
    5. 	//1、成员函数重载+号
    6. 	Person operator+(Person& p)
    7. 	{
    8. 		Person temp;
    9.         //this指针指向的是调用该成员函数的对象（p1），这里面的p是指传进来的p2的引用
    10. 		temp.m_A = this->m_A + p.m_A;
    11. 		temp.m_B = this->m_B + p.m_B;
    12. 		return temp;
    13. 	}
    14.  
    15.  
    16. 	int m_A;
    17. 	int m_B;
    18.  
    19. };
    20. void test01()
    21. {
    22. 	Person p1;
    23. 	p1.m_A = 10;
    24. 	p1.m_B = 10;
    25. 	Person p2;
    26. 	p2.m_A = 10;
    27. 	p2.m_B = 10;
    28.  
    29. 	Person p3 = p1 + p2;    //等价于 p1.operator+(p2)
    30. 	cout << p3.m_A << " " << p3.m_B << endl;
    31. }
    32.  
    33. int main() {
    34. 	test01();    //调用
    35.  
    36. 	system("pause");
    37. 	return 0;
    38. }

    全局函数重载

    1. //运算符重载
    2. class Person {
    3. public:
    4.  
    5. 	//1、成员函数重载+号
    6. 	//Person operator+(Person& p)
    7. 	//{
    8. 	//	Person temp;
    9. 	//	temp.m_A = this->m_A + p.m_A;
    10. 	//	temp.m_B = this->m_B + p.m_B;
    11. 	//	return temp;
    12. 	//}
    13.  
    14. 	int m_A;
    15. 	int m_B;
    16.  
    17. };
    18.  
    19. //2、全局函数重载  + 号
    20. Person operator+(Person &p1,Person &p2)
    21. {
    22. 	Person temp;
    23. 	temp.m_A = p1.m_A + p2.m_B;
    24. 	temp.m_B = p1.m_B + p2.m_B;
    25. 	return temp;
    26. }
    27.  
    28. void test01()
    29. {
    30. 	Person p1;
    31. 	p1.m_A = 10;
    32. 	p1.m_B = 10;
    33. 	Person p2;
    34. 	p2.m_A = 10;
    35. 	p2.m_B = 10;
    36.  
    37. 	//Person p3 = p1 + p2;		//成员函数重载本质调用等价于 p1.operator+(p2)
    38. 	Person p3 = p1 + p2;			//全局函数重载本质调用等价于 operator+(p1,p2)
    39. 	cout << p3.m_A << " " << p3.m_B << endl;
    40. }
    41.  
    42. int main() {
    43. 	test01();
    44.  
    45. 	system("pause");
    46. 	return 0;
    47. }

    运算符重载也可以发生函数重载

    1. class Person {
    2. public:
    3. 	Person() {};
    4. 	Person(int a, int b)
    5. 	{
    6. 		this->m_A = a;
    7. 		this->m_B = b;
    8. 	}
    9. 	//成员函数实现 + 号运算符重载
    10. 	Person operator+(const Person& p) {
    11. 		Person temp;
    12. 		temp.m_A = this->m_A + p.m_A;
    13. 		temp.m_B = this->m_B + p.m_B;
    14. 		return temp;
    15. 	}
    16.  
    17.  
    18. public:
    19. 	int m_A;
    20. 	int m_B;
    21. };
    22.  
    23. //全局函数实现 + 号运算符重载
    24. //Person operator+(const Person& p1, const Person& p2) {
    25. //	Person temp(0, 0);
    26. //	temp.m_A = p1.m_A + p2.m_A;
    27. //	temp.m_B = p1.m_B + p2.m_B;
    28. //	return temp;
    29. //}
    30.  
    31. //运算符重载 可以发生函数重载 
    32. Person operator+(const Person& p2, int val)
    33. {
    34. 	Person temp;
    35. 	temp.m_A = p2.m_A + val;
    36. 	temp.m_B = p2.m_B + val;
    37. 	return temp;
    38. }
    39.  
    40. void test() {
    41.  
    42. 	Person p1(10, 10);
    43. 	Person p2(20, 20);
    44.  
    45. 	//成员函数方式
    46. 	Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
    47. 	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;
    48.  
    49.  
    50. 	Person p4 = p3 + 10; //相当于 operator+(p3,10)
    51. 	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;
    52.  
    53. }
    54.  
    55. int main() {
    56.  
    57. 	test();
    58.  
    59. 	system("pause");
    60.  
    61. 	return 0;
    62. }

     总结1：对于内置的数据类型的表达式的的运算符是不可能改变的；

    总结2：不要滥用运算符重载

    🤡左移运算符重载

    比如这个例子，显然下面这个不能输出的。

    左移运算符重载的作用：可以输出自定义数据类型

    可以转到定义查看cout是ostream类型的 

    1. //左移运算符重载
    2.  
    3. class Person {
    4. 	friend ostream& operator<<(ostream& out, Person& p);
    5.  
    6. public:
    7.  
    8. 	Person(int a, int b)
    9. 	{
    10. 		this->m_A = a;
    11. 		this->m_B = b;
    12. 	}
    13.  
    14. 	//成员函数 实现不了（  p << cout 不是我们想要的效果 )
    15. 	//void operator<<(Person& p){
    16. 	//}
    17. 	 
    18. private:
    19. 	int m_A;
    20. 	int m_B;
    21. };
    22.  
    23. //全局函数实现左移重载
    24. //ostream对象只能有一个
    25. ostream& operator<<(ostream& out, Person& p) {
    26.     //内部就是一个简单的对象属性的输出
    27. 	out << "a:" << p.m_A << " b:" << p.m_B << endl;;
    28. 	return out;
    29. }
    30.  
    31. void test() {
    32.  
    33. 	Person p1(10, 20);
    34.  
    35. 	//如果返回的是void型，后面就不能追加输出了
    36. 	cout << p1 << "hello world" << endl; //链式编程
    37. }
    38.  
    39. int main() {
    40.  
    41. 	test();
    42.  
    43. 	system("pause");
    44.  
    45. 	return 0;
    46. }

     总结：重载左移运算符配合友元可以实现输出自定义数据类型

    🤡递增运算符重载

    作用： 通过重载递增运算符，实现自己的整型数据

    1.  
    2. class MyInteger {
    3.  
    4. 	friend ostream& operator<<(ostream& out, MyInteger myint);
    5.  
    6. public:
    7. 	MyInteger() {
    8. 		m_Num = 0;
    9. 	}
    10. 	//前置++
    11. 	MyInteger& operator++() {
    12. 		//先++
    13. 		m_Num++;
    14. 		//再返回
    15. 		return *this;
    16. 	}
    17.  
    18. 	//后置++
    19. 	MyInteger operator++(int) {
    20. 		//先返回
    21. 		MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
    22. 		m_Num++;
    23. 		return temp;
    24. 	}
    25.  
    26. private:
    27. 	int m_Num;
    28. };
    29.  
    30.  
    31. ostream& operator<<(ostream& out, MyInteger myint) {
    32. 	out << myint.m_Num;
    33. 	return out;
    34. }
    35.  
    36.  
    37. //前置++ 先++ 再返回
    38. void test01() {
    39. 	MyInteger myInt;
    40. 	cout << ++myInt << endl;
    41. 	cout << myInt << endl;
    42. }
    43.  
    44. //后置++ 先返回 再++
    45. void test02() {
    46.  
    47. 	MyInteger myInt;
    48. 	cout << myInt++ << endl;
    49. 	cout << myInt << endl;
    50. }
    51.  
    52. int main() {
    53.  
    54. 	test01();
    55. 	//test02();
    56.  
    57. 	system("pause");
    58.  
    59. 	return 0;
    60. }

     总结： 前置递增返回引用，后置递增返回值

    🤡递减运算符重载

    1. class MyInteger {
    2. 	//友元函数，是函数可以调用类里面的私有属性
    3. 	friend ostream& operator<<(ostream& out, MyInteger myint);
    4. public:
    5. 		MyInteger() {
    6. 			//给m_Num赋初值。
    7. 			m_Num = 2;
    8. 		}
    9. 		
    10. 		//前置--
    11. 		MyInteger& operator--() {
    12. 			//先 -- 
    13. 			--m_Num;
    14. 			//再返回
    15. 			return *this;
    16. 		}
    17. 		
    18. 		//后置--
    19. 		MyInteger operator--(int) {
    20. 			//先返回
    21. 			MyInteger temp = *this; //记录当前本身的值，然后让本身的减1，但是返回的是以前的值，达到先返回后--；
    22. 			m_Num--;
    23. 			return temp;
    24. 		}
    25. private:
    26. 	int m_Num;
    27. };
    28.  
    29. //全局函数重载左移运算符用于输出
    30. ostream& operator<<(ostream& out, MyInteger myint) {
    31. 	out << myint.m_Num;
    32. 	return out;
    33. }
    34.  
    35. //前置-- 先-- 再返回
    36. void test01() {
    37. 	MyInteger myInt;
    38. 	cout <<--myInt << endl;
    39. 	cout << myInt << endl;
    40. }
    41.  
    42. //后置-- 先返回 再--
    43. void test02() {
    44.  
    45. 	MyInteger myInt;
    46. 	cout << myInt-- << endl;
    47. 	cout << myInt << endl;
    48. }
    49.  
    50. int main() {
    51. 	test01();
    52. 	test02();
    53. 	
    54. 	system("pause");
    55. 	return 0;  
    56. }

     递减和递增一样，前置返回引用，后置返回值。

    🤡赋值运算符重载

    C++编译器至少给一个类添加4个函数

    1. 默认构造函数(无参，函数体为空)

    2. 默认析构函数(无参，函数体为空)

    3. 默认拷贝构造函数，对属性进行值拷贝

    4. 赋值运算符 operator=, 对属性进行值拷贝

    1. class Person
    2. {
    3. public:
    4. 	Person(int age) {
    5. 		m_Age = new int(age);
    6. 	}
    7.  
    8. 	~Person() {
    9. 		if (m_Age != NULL) {
    10. 			delete m_Age;
    11. 			m_Age = NULL;
    12. 		}
    13. 	}
    14. 	int *m_Age;
    15. };
    16.  
    17. void test01()
    18. {
    19. 	Person p1(18);
    20. 	cout << "p1的年龄为：" << *p1.m_Age << endl;
    21.  
    22. 	Person p2(28);
    23. 	p2 = p1;
    24. 	cout << "p1的年龄为：" << *p2.m_Age << endl;
    25. }
    26.  
    27. int main() {
    28. 	test01();
    29.  
    30. 	system("pause");
    31. 	return 0;
    32. }

    写了个析构函数，释放了自己手动在堆上面申请的内存 ，结果出现崩溃了。。。

     这里实际上是浅拷贝的问题。

     p1和p2公用一块堆内存18，并没有再重新开辟和p1的属性值一样的空间给p2，他们都指向这一块内存。

     在函数执行完之后，p2被释放了，再判断p2空间是否为空，不为空释放一次，p1进行同样操作。

    堆区内存重复释放，重新崩溃！

    解决方案：利用深拷贝，解决浅拷贝带来的问题。

    1. 	//重载赋值运算符
    2. 	void operator=(Person& p)
    3. 	{
    4. 		//编译器是提供浅拷贝
    5. 		//m_Age = p.m_Age;
    6.  
    7. 		//应该先判断编译器是否有属性在堆区，如果有先释放干净，然后再深拷贝
    8. 		if (m_Age != NULL) {
    9. 			delete m_Age;
    10. 			m_Age = NULL;
    11. 		}
    12.  
    13. 		//深拷贝
    14. 		m_Age = new int(*p.m_Age);

     直接在类里面添加上面代码就可以实现了

    但是，你以为这就完了吗

    如果这时候要求连续赋值操作，p3 = p2 = p1；则会报错，为啥呢？

    仔细看，你前面返回的是void类型，这里需要返回对象本体Person&。

    重载部分代码：

    1. 	//重载赋值运算符
    2. 	Person& operator=(Person& p)
    3. 	{
    4. 		//编译器是提供浅拷贝
    5. 		//m_Age = p.m_Age;
    6.  
    7. 		//应该先判断编译器是否有属性在堆区，如果有先释放干净，然后再深拷贝
    8. 		if (m_Age != NULL) {
    9. 			delete m_Age;
    10. 			m_Age = NULL;
    11. 		}
    12.  
    13. 		//深拷贝
    14. 		m_Age = new int(*p.m_Age);
    15.  
    16. 		//返回对象本身
    17. 		return *this;
    18. 	}

     总结：

            先在堆区开辟内存

    重载流程：

    1.         判断是否有内存，进行清空操作。
    2.         进行深拷贝
    3.         返回自身

    🤡关系运算符重载

    作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

    1. class Person
    2. {
    3. public:
    4. 	Person(string name, int age)
    5. 	{
    6. 		this->m_Name = name;
    7. 		this->m_Age = age;
    8. 	};
    9.  
    10.     //==的重载
    11. 	bool operator==(Person & p)
    12. 	{
    13. 		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
    14. 		{
    15. 			return true;
    16. 		}
    17. 		else
    18. 		{
    19. 			return false;
    20. 		}
    21. 	}
    22.  
    23.     //!=的重载
    24. 	bool operator!=(Person & p)
    25. 	{
    26. 		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
    27. 		{
    28. 			return false;
    29. 		}
    30. 		else
    31. 		{
    32. 			return true;
    33. 		}
    34. 	}
    35.  
    36.  
    37. 	string m_Name;
    38. 	int m_Age;
    39. };
    40.  
    41. void test01()
    42. {
    43. 	//int a = 0;
    44. 	//int b = 0;
    45.  
    46. 	Person a("孙悟空", 18);
    47. 	Person b("孙悟空", 18);
    48.  
    49. 	if (a == b)
    50. 	{
    51. 		cout << "a和b相等" << endl;
    52. 	}
    53. 	else
    54. 	{
    55. 		cout << "a和b不相等" << endl;
    56. 	}
    57.  
    58. 	if (a != b)
    59. 	{
    60. 		cout << "a和b不相等" << endl;
    61. 	}
    62. 	else
    63. 	{
    64. 		cout << "a和b相等" << endl;
    65. 	}
    66. }
    67.  
    68.  
    69. int main() {
    70.  
    71. 	test01();
    72.  
    73. 	system("pause");
    74.  
    75. 	return 0;
    76. }

    🤡函数调用运算符重载（仿函数）

    • 函数调用运算符 () 也可以重载

    • 由于重载后使用的方式非常像函数的调用，因此称为仿函数

    • 仿函数没有固定写法，非常灵活

    1. class MyPrint
    2. {
    3. public:
    4. 	void operator()(string text)
    5. 	{
    6. 		cout << text << endl;
    7. 	}
    8.  
    9. };
    10. void test01()
    11. {
    12. 	//重载的（）操作符 因为调用的时候和函数调用很像，所以也称为仿函数
    13. 	MyPrint myFunc;
    14. 	myFunc("hello world");
    15. }
    16.  
    17.  
    18. class MyAdd
    19. {
    20. public:
    21. 	int operator()(int v1, int v2)
    22. 	{
    23. 		return v1 + v2;
    24. 	}
    25. };
    26.  
    27. void test02()
    28. {
    29. 	MyAdd add;
    30. 	int ret = add(10, 10);
    31. 	cout << "ret = " << ret << endl;
    32.  
    33. 	//匿名函数对象调用  
    34. 	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
    35. }
    36.  
    37. int main() {
    38.  
    39. 	test01();
    40. 	test02();
    41.  
    42. 	system("pause");
    43.  
    44. 	return 0;
    45. }

    记住：仿函数非常灵活，没有固定的写法。

  • 相关阅读:
    PMP（Project Management Professional）证在哪个行业比较有用？
    嫌学校软件太烂，父母做了开源APP，却被官方报警
    职素丨专业的职素训练 让学员转变为职业人
    01 【Vue简介 初识Vue 模板语法和数据绑定】
    dhrystone和coremark测试比较
    sql server服务无法启动怎么办？如何正常启动？
    Learn-1
    前后端分离计算机毕设项目之基于SpringBoot的旅游网站的设计与实现《内含源码+文档+部署教程》
    C++语言的由来与发展历程
    在不同的系统下解决apache2和nginx伪静态问题（非宝塔页面）wordpress通用
  • 原文地址：https://blog.csdn.net/m0_62853489/article/details/127632455