• 【C++修行之道】类和对象（四）运算符重载

    目录

    一、 运算符重载

    函数重载和运算符重载有什么关系？

    二、.*运算符的作用

    三、运算符重载的正常使用

    四、重载成成员函数

    五、赋值运算符重载

    1.赋值运算符重载格式

    传值返回和引用返回

    有没有办法不生成拷贝？

    2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

    3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

    六、前置++和后置++重载 

    一、 运算符重载

    C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
    函数名字为：关键字operator后面接需要重载的运算符符号。
    函数原型：返回值类型 operator操作符(参数列表)。

    注意：

    • 不能通过连接其他符号来创建新的操作符：比如operator@ 
    • 重载操作符必须有一个类类型参数 
    • 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义 
    • 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
    • .* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

    函数重载和运算符重载有什么关系？

    他们之间各论各的，没有关系

    运算符重载：让自定义类型可以使用运算符，并且控制运算符的行为，增强可读性

    函数重载：可以让函数名相同，参数不同的函数存在。

    多个同一运算符的重载可以构成函数重载

     

    二、.*运算符的作用

    1. class OB
    2. {
    3. public:
    4. 	void func()
    5. 	{
    6. 		cout << "void func()" << endl;
    7. 	}
    8. };
    9.  
    10. typedef void(OB::* Ptrfunc)();// 成员函数指针类型
    11.  
    12. int main()
    13. {
    14. 	// 函数指针
    15. 	void (*ptr)();
    16.  
    17. 	Ptrfunc fp = &OB::func;// 定义成员函数指针p指向函数func
    18. 	// 成员函数规定要加&才能取到函数指针
    19. 	OB temp;// 定义ob类对象temp
    20.  
    21.  
    22. 	(temp.*fp)();// 调用成员函数
    23.  
    24. 	return 0;
    25. }

    typedef void(OB::* Ptrfunc)(); // 成员函数指针类型
    • 使用 typedef 定义了一个名为 Ptrfunc 的类型，这个类型是指向OB类中无参数、无返回值的成员函数的指针类型。
    • OB::*的含义，它表示这是一个指向OB类成员函数的指针 Ptrfunc。
    Ptrfunc fp = &OB::func; // 定义成员函数指针fp指向函数func
    • 在C++中，成员函数与普通函数在内存中的表示和存储方式有所不同。成员函数不仅包含函数的代码，还隐含地包含了一个指向类对象的this指针，这使得成员函数能够访问和修改对象的状态。
    • 在语法上，&类名::成员函数名是用来获取成员函数地址的标准方式
    • 如果不使用&运算符，编译器可能会将OB::func解析为对成员函数的调用
    • 运算符在这里的作用是明确告诉编译器：“我要的是这个成员函数的地址，而不是执行这个函数”。这样，编译器就能正确地生成获取成员函数地址的代码，而不是尝试调用该函数。
    (temp.*fp)(); // 调用成员函数
    • .*：这是一个特殊的成员访问运算符，用于通过对象实例和成员函数指针来调用成员函数。当你有一个指向成员函数的指针，并且想要在某个特定的对象上调用这个函数时，就需要使用这个运算符。 
    • 在temp对象上，通过成员函数指针fp来调用它所指向的成员函数

    三、运算符重载的正常使用

    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 1900, int month = 1, int day = 1)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10. //private:
    11. 	int _year;
    12. 	int _month;
    13. 	int _day;
    14.  
    15. };
    16.  
    17. // 重载成全局, 无法访问私有成员, 怎么解决?
    18. // 1.提供这些成员get和set
    19. // 2.友元
    20. // 3.重载成成员函数(一般重载成这种)
    21. //
    22.  
    23. // 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证?
    24. // 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数 
    25. bool operator==(const Date& d1, const Date& d2)
    26. {
    27. 	return d1._year == d2._year
    28. 		&& d1._month == d2._month
    29. 		&& d1._day == d2._day;
    30. }
    31.  
    32. // d1 - d2
    33. // d1 + d2 无意义
    34. // d1 * d2 无意义
    35. // 一个类要重载哪些运算符是看需求, 看重载有没有价值和意义 
    36.  
    37. int main()
    38. {
    39. 	Date d3(2024, 4, 14);
    40. 	Date d4(2024, 4, 15);
    41.  
    42. 	// 显示调用(可以正常使用)
    43. 	operator==(d3, d4);
    44.  
    45. 	// 直接写,转换调用,编译器会转换成operator==(d3, d4)
    46. 	d3 == d4;
    47.  
    48. 	return 0;
    49. }
    '
    运行

    四、重载成成员函数

    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 1900, int month = 1, int day = 1)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10.  
    11. 	 d3.Func(d4);
    12. 	//bool Func(const Date& d)
    13. 	//{
    14. 	//	return this->_year == d._year
    15. 	//		&& this->_month == d._month
    16. 	//		&& this->_day == d._day;
    17. 	//}
    18.  
    19. 	// d3.operator==(d4);
    20. 	bool operator==(const Date& d)
    21. 	{
    22. 		cout << "类中";
    23. 		return _year == d._year
    24. 			&& _month == d._month
    25. 			&& _day == d._day;
    26. 		// 隐藏了this指针
    27. 		/*return this->_year == d._year
    28. 			&& this->_month == d._month
    29. 			&& this->_day == d._day;*/
    30. 	}
    31.  
    32. //private:
    33. 	int _year;
    34. 	int _month;
    35. 	int _day;
    36. };
    37.  
    38. // 如果全局和类中都有运算符重载函数，编译器会选择调用类里的
    39. bool operator==(const Date& d1, const Date& d2)
    40. {
    41. 	cout << "全局";
    42. 	return d1._year == d2._year
    43. 		&& d1._month == d2._month
    44. 		&& d1._day == d2._day;
    45. }
    46. int main()
    47. {
    48. 	Date d3(2024, 4, 14);
    49. 	Date d4(2024, 4, 15);
    50.  
    51. 	// 显式调用
    52. 	d3.operator==(d4);
    53.  
    54. 	// 转换调用 等价于d3.operator==(d4);
    55. 	d3 == d4;
    56.  
    57. 	return 0;
    58. }
    • 通过d3.operator==(d4)显式调用了类内的operator==函数。因为这里是直接通过对象d3来调用的，所以肯定是类内的版本被调用。
    • d3 == d4这种简洁的写法在C++中会被自动转换为对operator==的调用。当有多个版本的operator==可用时（如本例中的类内和全局版本），C++会根据一定的规则（如作用域和参数匹配）来选择调用哪一个。在这个例子中，由于类内的版本是成员函数，且其参数与全局版本相同，所以编译器会优先选择类内的版本。 

    五、赋值运算符重载

    1.赋值运算符重载格式

    • 参数类型：const T&，传递引用可以提高传参效率
    • 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
    • 检测是否自己给自己赋值
    • 返回*this ：要复合连续赋值的含义

    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 1900, int month = 1, int day = 1)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10.  
    11. 	Date(const Date& d)
    12. 	{
    13. 		_year = d._year;
    14. 		_month = d._month;
    15. 		_day = d._day;
    16. 	}
    17.  
    18. 	Date& operator=(const Date& d)
    19. 	{
    20.         // 自己给自己赋值
    21. 		if (this != &d)
    22. 		{
    23. 			_year = d._year;
    24. 			_month = d._month;
    25. 			_day = d._day;
    26. 		}
    27. 		// 需要返回值的原因:支持连续赋值
    28. 		return *this;
    29. 	}
    30. private:
    31. 	int _year;
    32. 	int _month;
    33. 	int _day;
    34. };
    35.  
    36. int main()
    37. {
    38. 	Date d1(2024, 4, 14);
    39.  
    40. 	// 拷贝构造
    41. 	// 一个已经存在的对象，拷贝给另一个要创建初始化的对象
    42. 	Date d2(d1);
    43. 	Date d3 = d1;
    44.  
    45. 	Date d4(2024, 5, 1);
    46.  
    47. 	// 赋值拷贝/赋值重载
    48. 	// 一个已经存在的对象，拷贝赋值给另一个已经存在的对象
    49. 	d1 = d4;
    50.  
    51. 	d1 = d2 = d4;
    52.  
    53. 	return 0;
    54. }
    '
    运行
    •  Date& operator=(const Date& d)：这个函数重载了赋值运算符（=），允许我们使用=来将一个Date对象的值赋给另一个已经存在的Date对象。函数中首先检查自赋值的情况（即确保赋值操作的左右两边不是同一个对象），然后复制右边的对象的年、月和日到左边的对象，并返回左边对象的引用，以支持连续赋值操作。
    • *this是对象本身，对象在main的作用域里创建，因此出main作用域才析构销毁。而出函数作用域不会销毁，所以此处才能return *this 

    传值返回和引用返回

    传值返回，返回的是对象的拷贝

    引用返回，返回的是对象的别名

    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 1900, int month = 1, int day = 1)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10.  
    11. 	Date(const Date& d)
    12. 	{
    13. 		cout << "Date(const Date& d)" << endl;
    14.  
    15. 		_year = d._year;
    16. 		_month = d._month;
    17. 		_day = d._day;
    18. 	}
    19.  
    20. 	void Print()
    21. 	{
    22. 		cout << _year << "-" << _month << "-" << _day << endl;
    23. 	}
    24.  
    25. 	~Date()
    26. 	{
    27. 		cout << "~Date()" << endl;
    28. 		_year = -1;
    29. 		_month = -1;
    30. 		_day = -1;
    31. 	}
    32.  
    33. private:
    34. 	int _year;
    35. 	int _month;
    36. 	int _day;
    37. };

    • Date(const Date& d)：这是一个拷贝构造函数，它接受一个Date对象的引用，并创建一个新的Date对象，其内容与传入的对象相同。

    有没有办法不生成拷贝？

    使用引用返回

    1. Date func()
    2. {
    3. 	Date d(2024, 4, 14);
    4. 	return d;
    5. }
    6.  
    7. int main()
    8. {
    9. 	const Date& ref = func();
    10. 	ref.Print();
    11.  
    12. 	return 0;
    13. }

     在main函数中，首先通过调用func函数获取了一个对Date对象的常量引用ref。由于func返回的是一个临时对象，这个对象在表达式结束后就会被销毁。但是，由于ref是对这个临时对象的引用，所以这个临时对象的生命周期会被延长，直到ref的生命周期结束。这是C++11引入的引用折叠和生命周期延长规则的结果。

    1. Date& func()
    2. {
    3. 	Date d(2024, 4, 14);
    4. 	//cout << &d << endl;
    5. 	return d;
    6. }
    7.  
    8. int fx()
    9. {
    10. 	int a = 1;
    11. 	int b = 2;
    12. 	int c = 3;
    13.  
    14. 	return a + b + c;
    15. }
    16.  
    17. int main()
    18. {
    19. 	//Date& ref = func();
    20. 	const Date& ref = func();
    21. 	cout << &ref << endl;
    22. 	fx();
    23.  
    24. 	return 0;
    25. }

    在main函数中，通过const Date& ref = func();获取了func函数返回的引用，并将其存储在常量引用ref中。由于func返回的是对局部变量的引用，这里的ref实际上引用了一个已经不存在的对象，因此这是不安全的 

    1. Date& func()
    2. {
    3. 	static Date d(2024, 4, 14);
    4. 	return d;
    5. }
    6. // 出了作用域，返回对象还在没有析构，那就可以用引用返回，减少拷贝
    7. // a、返回对象生命周期到了，会析构，传值返回
    8. // b、返回对象生命周期没到，不会析构，传引用返回
    9.  
    10. int main()
    11. {
    12. 	const Date& ref = func();
    13. 	//ref.Print();
    14.  
    15. 	return 0;
    16. }

    • func函数返回一个对静态局部变量d的引用，该变量在函数第一次被调用时被初始化，并在程序的整个生命周期内持续存在。由于d是静态的，它不会在func函数返回后被销毁，因此可以安全地返回它的引用。 

    • 在main函数中，调用了func函数并将返回的引用赋值给const Date& ref。由于返回的是引用，因此没有发生任何拷贝操作，这是效率更高的做法。

    2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 1900, int month = 1, int day = 1)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10. 	int _year;
    11. 	int _month;
    12. 	int _day;
    13. };
    14. // 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
    15. Date& operator=(Date& left, const Date& right)
    16. {
    17. 	if (&left != &right)
    18. 	{
    19. 		left._year = right._year;
    20. 		left._month = right._month;
    21. 		left._day = right._day;
    22. 	}
    23. 	return left;
    24. }
    25. // 编译失败：
    26. // error C2801: “operator =”必须是非静态成员

    原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

    3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

    注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

    1. class Time
    2. {
    3. public:
    4. 	Time()
    5. 	{
    6. 		_hour = 1;
    7. 		_minute = 1;
    8. 		_second = 1;
    9. 	}
    10. 	Time& operator=(const Time& t)
    11. 	{
    12. 		if (this != &t)
    13. 		{
    14. 			_hour = t._hour;
    15. 			_minute = t._minute;
    16. 			_second = t._second;
    17. 		}
    18. 		return *this;
    19. 	}
    20. private:
    21. 	int _hour;
    22. 	int _minute;
    23. 	int _second;
    24. };
    25. class Date
    26. {
    27. private:
    28. 	// 基本类型(内置类型)
    29. 	int _year = 1970;
    30. 	int _month = 1;
    31. 	int _day = 1;
    32. 	// 自定义类型
    33. 	Time _t;
    34. };
    35. int main()
    36. {
    37. 	Date d1;
    38. 	Date d2;
    39. 	d1 = d2;
    40. 	return 0;
    41. }
    '
    运行

    既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，还需要自己实
    现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

    1. // 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
    2. typedef int DataType;
    3. class Stack
    4. {
    5. public:
    6. 	Stack(size_t capacity = 10)
    7. 	{
    8. 		_array = (DataType*)malloc(capacity * sizeof(DataType));
    9. 		if (nullptr == _array)
    10. 		{
    11. 			perror("malloc申请空间失败");
    12. 			return;
    13. 		}
    14. 		_size = 0;
    15. 		_capacity = capacity;
    16. 	}
    17. 	void Push(const DataType& data)
    18. 	{
    19. 		// CheckCapacity();
    20. 		_array[_size] = data;
    21. 		_size++;
    22. 	}
    23. 	~Stack()
    24. 	{
    25. 		if (_array)
    26. 		{
    27. 			free(_array);
    28. 			_array = nullptr;
    29. 			_capacity = 0;
    30. 			_size = 0;
    31. 		}
    32. 	}
    33. private:
    34. 	DataType* _array;
    35. 	size_t _size;
    36. 	size_t _capacity;
    37. };
    38. int main()
    39. {
    40. 	Stack s1;
    41. 	s1.Push(1);
    42. 	s1.Push(2);
    43. 	s1.Push(3);
    44. 	s1.Push(4);
    45. 	Stack s2;
    46. 	s2 = s1;
    47. 	return 0;
    48. }

    注意：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

    六、前置++和后置++重载 

    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 1900, int month = 1, int day = 1)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10. 	// 前置++：返回+1之后的结果
    11. 	// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
    12. 	Date& operator++()
    13. 	{
    14. 		_day += 1;
    15. 		return *this;
    16. 	}
    17. 	// 后置++：
    18. 	// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
    19. 	// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
    20. 	// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this + 1
    21. 	//       而temp是临时对象，因此只能以值的方式返回，不能返回引用
    22. 		Date operator++(int)
    23. 	{
    24. 		Date temp(*this);
    25. 		_day += 1;
    26. 		return temp;
    27. 	}
    28. private:
    29. 	int _year;
    30. 	int _month;
    31. 	int _day;
    32. };
    33.  
    34.  
    35. void test02()
    36. {
    37. 	Date d1(2024, 4, 14);
    38. 	Date d2 = ++d1;
    39. 	d1.Print();
    40. 	d2.Print();
    41.  
    42. 	Date d3 = d1++;
    43. 	d1.Print();
    44. 	d3.Print();
    45.  
    46. 	/*d1.operator++(1);
    47. 	d1.operator++(100);
    48. 	d1.operator++(0);
    49. 	d1.Print();*/
    50. }
    51.  
    52. int main()
    53. {
    54.  
    55. 	test02();
    56.  
    57. 	return 0;
    58. }

    今天就先到这了！！！

    看到这里了还不给博主扣个：
    ⛳️ 点赞☀️收藏 ⭐️ 关注！

    你们的点赞就是博主更新最大的动力！
    有问题可以评论或者私信呢秒回哦。

  • 相关阅读:
    工作遇到的问题以及解决处理方法-主要是基于vue的antd
    Yolov5(v5.0) + pyqt5界面设计
    运放供电设计
    C语言水平测试题 过关斩将（3）辗转相除法，前n项求和，整数的正序分解，求最大公约数
    2023-09-27 mysql-表名-前缀层级-记录
    [AI Google] Google I/O 2024: 为新一代设计的 I/O
    Java-Exception-异常处理
    Linux中 vim 编辑器的使用
    逍遥自在学C语言 | 多级指针探秘
    西农大 C plus
  • 原文地址：https://blog.csdn.net/2301_79558858/article/details/139331237