运算符重载为成员函数

转自：https://www.runoob.com/cplusplus/increment-decrement-operators-overloading.html

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

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

双目运算符重载规则

• 如果要重载 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(); 不能作为左值，不能调用成员函数修改，不会调用复制构造函数。