c++运算符重载及其返回值引用

运算符重载为成员函数

重载为类成员的运算符函数定义形式

  1.     函数类型  operator 运算符（形参）
  2.     {
  3.            ......
  4.     }
  5.     参数个数=原操作数个数-1   （后置++、--除外）

双目运算符重载规则

  • 如果要重载 B 为类成员函数，使之能够实现表达式 oprd1 B oprd2，其中 oprd1 为A 类对象，则 B 应被重载为 A 类的成员函数，形参类型应该是 oprd2 所属的类型。
  • 经重载后，表达式 oprd1 B oprd2 相当于 oprd1.operator B(oprd2)

例：复数类加减法运算重载为成员函数

  • 要求:
    • 将+、-运算重载为复数类的成员函数。
  • 规则:
    • 实部和虚部分别相加减。
  • 操作数:
    • 两个操作数都是复数类的对象。

  • 源代码：

  1. #include <iostream>
  2. using namespace std;
  3. class Complex {
  4. public:
  5.     Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) { }
  6.     //运算符+重载成员函数
  7.   Complex operator + (const Complex &c2) const;
  8.     //运算符-重载成员函数
  9.   Complex operator - (const Complex &c2) const;
  10.     void display() const;   //输出复数
  11. private:
  12.     double real;    //复数实部
  13.     double imag;    //复数虚部
  14. };
  15. 例 复数类加减法运算重载为成员函数
  16. Complex Complex::operator+(const Complex &c2) const{
  17.   //创建一个临时无名对象作为返回值 
  18.   return Complex(real+c2.real, imag+c2.imag); 
  19. }
  20.  
  21. Complex Complex::operator-(const Complex &c2) const{
  22.  //创建一个临时无名对象作为返回值
  23.     return Complex(real-c2.real, imag-c2.imag); 
  24. }
  25.  
  26. void Complex::display() const {
  27.     cout<<"("<<real<<", "<<imag<<")"<<endl;
  28. }
  29. 例：复数类加减法运算重载为成员函数
  30. int main() {
  31.     Complex c1(5, 4), c2(2, 10), c3;
  32.     cout << "c1 = "; c1.display();
  33.     cout << "c2 = "; c2.display();
  34.     c3 = c1 - c2;   //使用重载运算符完成复数减法
  35.     cout << "c3 = c1 - c2 = "; c3.display();
  36.     c3 = c1 + c2;   //使用重载运算符完成复数加法
  37.     cout << "c3 = c1 + c2 = "; c3.display();
  38.     return 0;
  39. }

运算符重载为非成员函数

有些运算符不能重载为成员函数，例如二元运算符的左操作数不是对象，或者是不能由我们重载运算符的对象

运算符重载为非成员函数的规则

  • 函数的形参代表依自左至右次序排列的各操作数。
  • 重载为非成员函数时
  • 参数个数=原操作数个数（后置++、--除外）
  • 至少应该有一个自定义类型的参数。
  • 后置单目运算符 ++和--的重载函数，形参列表中要增加一个int，但不必写形参名。
  • 如果在运算符的重载函数中需要操作某类对象的私有成员，可以将此函数声明为该类的友元。

运算符重载为非成员函数的规则

  • 双目运算符 B重载后，

表达式oprd1 B oprd2

等同于operator B(oprd1,oprd2 )

  • 前置单目运算符 B重载后，

表达式 B oprd

等同于operator B(oprd )

  • 后置单目运算符 ++和--重载后，

表达式 oprd B

等同于operator B(oprd,0 )

例 重载Complex的加减法和“<<”运算符为非成员函数

• 将+、-（双目）重载为非成员函数，并将其声明为复数类的友元，两个操作数都是复数类的常引用。 • 将<<（双目）重载为非成员函数，并将其声明为复数类的友元，它的左操作数是std::ostream引用，右操作数为复数类的常引用，返回std::ostream引用，用以支持下面形式的输出：

cout << a << b;

该输出调用的是：

operator << (operator << (cout, a), b);

源代码：

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. class Complex {
  5. public:
  6. 	Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) { }
  7. 	friend Complex operator+(const Complex &c1, const Complex &c2);
  8. 	friend Complex operator-(const Complex &c1, const Complex &c2);
  9. 	friend ostream & operator<<(ostream &out, const Complex &c);
  10. private:
  11. 	double real;  //复数实部
  12. 	double imag;  //复数虚部
  13. };
  14.  
  15. Complex operator+(const Complex &c1, const Complex &c2){
  16. 	return Complex(c1.real + c2.real, c1.imag + c2.imag);
  17. }
  18. Complex operator-(const Complex &c1, const Complex &c2){
  19. 	return Complex(c1.real - c2.real, c1.imag - c2.imag);
  20. }
  21.  
  22. ostream & operator<<(ostream &out, const Complex &c){
  23. 	out << "(" << c.real << ", " << c.imag << ")";
  24. 	return out;
  25. }
  26.  
  27. int main() {
  28. 	Complex c1(5, 4), c2(2, 10), c3;
  29. 	cout << "c1 = " << c1 << endl;
  30. 	cout << "c2 = " << c2 << endl;
  31. 	c3 = c1 - c2;   //使用重载运算符完成复数减法
  32. 	cout << "c3 = c1 - c2 = " << c3 << endl;
  33. 	c3 = c1 + c2;   //使用重载运算符完成复数加法
  34. 	cout << "c3 = c1 + c2 = " << c3 << endl;
  35. 	return 0;
  36. }

前置单目运算符重载规则

  • 如果要重载 U 为类成员函数，使之能够实现表达式 U oprd，其中 oprd 为A类对象，则 U 应被重载为 A 类的成员函数，无形参。
  • 经重载后，表达式 U oprd 相当于 oprd.operator U()

后置单目运算符 ++和--重载规则

  • 如果要重载 ++或--为类成员函数，使之能够实现表达式 oprd++ 或 oprd-- ，其中 oprd 为A类对象，则 ++或-- 应被重载为 A 类的成员函数，且具有一个 int 类型形参。
  • 经重载后，表达式 oprd++ 相当于 oprd.operator ++(0)

重载前置++和后置++为时钟类成员函数

  • 前置单目运算符，重载函数没有形参
  • 后置++运算符，重载函数需要有一个int形参
  • 操作数是时钟类的对象。

  • 实现时间增加1秒钟。

  1. #include <iostream>
  2. using namespace std;
  3. class Clock {//时钟类定义
  4. public: 
  5.     Clock(int hour = 0, int minute = 0, int second = 0);
  6.     void showTime() const;
  7.   //前置单目运算符重载
  8.     Clock& operator ++ ();
  9.   //后置单目运算符重载
  10.     Clock operator ++ (int);    
  11. private:
  12.     int hour, minute, second;
  13. };
  14.  
  15. Clock::Clock(int hour, int minute, int second) {    
  16.     if (0 <= hour && hour < 24 && 0 <= minute && minute < 60
  17.         && 0 <= second && second < 60) {
  18.         this->hour = hour;
  19.         this->minute = minute;
  20.         this->second = second;
  21.     } else
  22.         cout << "Time error!" << endl;
  23. }
  24. void Clock::showTime() const {  //显示时间
  25.     cout << hour << ":" << minute << ":" << second << endl;
  26. }
  27.  
  28. //依次重载前置++和后置++为时钟类成员函数定义
  29. Clock & Clock::operator ++ () { 
  30.     second++;
  31.     if (second >= 60) {
  32.         second -= 60;  minute++;
  33.         if (minute >= 60) {
  34.           minute -= 60; hour = (hour + 1) % 24;
  35.         }
  36.     }
  37.     return *this;
  38. }
  39.  
  40. Clock Clock::operator ++ (int) {
  41.     //注意形参表中的整型参数
  42.     Clock old = *this;
  43.     ++(*this);  //调用前置“++”运算符
  44.     return old;
  45. }
  46. int main() {
  47.     Clock myClock(23, 59, 59);
  48.     cout << "First time output: ";
  49.     myClock.showTime();
  50.     cout << "Show myClock++:    ";
  51.     (myClock++).showTime();
  52.     cout << "Show ++myClock:    ";
  53.     (++myClock).showTime();
  54.     return 0;
  55. }

Clock Clock::operator ++ (int)这个函数表示后置++，函数内部定义了一个局部变量old，在其生存期结束时会被释放掉，故不能使用返回引用的定义，否则会指向被释放掉的内存空间中的不确定的值。无论重复使用多少次后置++运算，也只会改变一次原有myclock对象的值（例如myclock++++++因为只有第一次++时*this表示myclock对象，后面都是old对象，就算使用引用也是一样的，更何况没使用引用无法连续赋值）。

Clock &Clock::operator ++ (int)这个函数表示前置++，返回的是当前对象的引用，故多次调用前置++运算符时，会一直对对象myclock进行赋值。如果取消引用符号，(++++++myclock).show还是会显示三次自增后的结果，究其原因是保存的一个临时变量副本，但myclock依然是只有一次自增的结果，这种情况充分说明了引用&能使返回对象为左值。

上述程序运行结果


改动下main函数：

  1. int main() {
  2. 	Clock myClock(23, 59, 59);
  3. 	cout << "First time output: ";
  4. 	myClock.showTime();
  5. 	cout << "Show myClock++:    ";
  6. 	(myClock++++++).showTime();
  7. 	myClock.showTime();
  8. 	cout << "Show ++myClock:    ";
  9. 	(++++++myClock).showTime();
  10. 	myClock.showTime();
  11.  
  12. 	system("pause");
  13. 	return 0;
  14. }

结果如下：


*this表示当前对象，Clock & Clock::operator ++ ()中的引用表示返回的是一个本类对象的引用，即返回的是一个左值。

为了更好地理解左值的概念，我们下面举一个简单的例子：

  1. #include<iostream>  
  2. using namespace std;
  3.  
  4. class Test{
  5.  
  6. public:
  7. 	//构造函数  
  8. 	Test(int i = 0, double j = 0.0) : m_i(i), m_j(j){
  9.  
  10. 	}
  11.  
  12. 	//赋值构造函数  
  13. 	Test operator=(Test &rhs){      //返回引用
  14. 		this->m_i = rhs.m_i;
  15. 		this->m_j = rhs.m_j;
  16. 		return *this;
  17. 	}
  18. 	//Test operator=(Test &rhs){    //返回值
  19. 	//this->m_i = rhs.m_i;
  20. 	//this->m_j = rhs.m_j;
  21. 	//return *this;}
  22.  
  23. 	int m_i;
  24. 	double m_j;
  25. };
  26.  
  27.  
  28. int main(){
  29.  
  30. 	//1、赋初值，输出 1  2.3  
  31. 	Test obj1(1, 2.3);
  32. 	cout << obj1.m_i << endl << obj1.m_j << endl;
  33. 	cout << endl << "-------------------" << endl;
  34.  
  35. 	//2、未赋初值，输出0 0  
  36. 	Test obj2;
  37. 	cout << obj2.m_i << endl << obj2.m_j << endl;
  38. 	cout << endl << "-------------------" << endl;
  39.  
  40. 	//3、未赋初值，但是通过赋值构造函数进行了赋初值，但是注意是重复调用赋值构造函数赋初值。  
  41. 	Test obj3;
  42. 	(obj3 = obj2 )= obj1;//这里，先进行obj3 = obj2 的操作, (赋值成功后通过return *this，返回obj2对象), 然后进行 obj3 = obj1 的操作。  
  43. 	cout << obj3.m_i << endl << obj3.m_j << endl;
  44. 	cout << endl << "-------------------" << endl;
  45.  
  46. 	system("pause");
  47. 	return 0;
  48. }

函数返回引用的运行结果如下：


函数返回值的运行结果如下：


从运行结果可以看出当返回值时，函数返回值时会产生一个临时变量作为函数返回值的副本，并调用复制构造函数将*this传给这个临时变量，并且赋值得到的是一个右值，右值是不能继续赋值的，而返回引用时，引用就是obj对象本身，赋值得到一个左值，是可以继续赋值的，其原因是这是为了支持连续的=号操作，如：A a,b,c  .调用(a=b)=c,这种情况下就要要求重载操作符=号必须返回一个*this的引用，这样a=b才能得到一个更新后的a,再用c对其赋值才能作用到更新 的a身上，如果不返回*this的引用，将无法完成第二次用c的那个赋值。调用成员函数时*this指向该对象本身。

下面分类讲述返回“值”和返回“引用”的不同点：

函数返回值时会产生一个临时变量作为函数返回值的副本，而返回引用时不会产生值的副本。

T f(); 返回一般的类类型，返回的类类型不能作为左值，但返回的类类型可以直接调用成员函数来修改，如function().set_Value(); 返回类类型调用复制构造函数。
const T f(); 此种类型与上述第一种相同，唯一不同的是返回的类类型不能调用成员函数来修改，因为有const限定符。
T& f(); 返回类的引用可以作为左值，并且返回的类类型引用可以直接调用成员函数来修改，返回的类类型不会调用复制构造函数。
const T& f(); 不能作为左值，不能调用成员函数修改，不会调用复制构造函数。


转载于:https://blog.csdn.net/zhuzhaoming1994/article/details/80371779

posted @ 2020-05-09 21:36  焕不涣  阅读(3389)  评论(0)  编辑  收藏  举报