032-C++之运算符重载1

moc

1、简介
C++可以重载大部分内置的运算符来实现对象之间的操作。
重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。
1. 不能重载的运算符
        .：成员访问运算符
        .*, ->*：成员指针访问运算符
        ::：域运算符
        sizeof：长度运算符
        ?:：条件运算符
        #： 预处理符号
2.运算符重载的限制
重载运算符函数可以对运算符作出新的解释，但原有基本语义不变：
        ①不改变运算符的优先级
        ②不改变运算符的结合性
        ③不改变运算符需要的操作数
        ④不能创建新的运算符
3.运算符重载两种方式
成员函数重载：
        ObjectL.operator op (ObjectR)
其左操作数通过this指针传递，右操作数需要有参数传递，一元操作符时，缺省。
友元函数重载：
        operator op (ObjectL, ObjectR)
友元函数重载时其左右操作数都需参数提供。
注意： =   ()    []     ->  操作符不能用友元函数重载
          cout<< 重载是只能用友元函数
2、+ 的成员函数重载、- 的友元函数重载

1. class Complex       // 复数类
   
2. {
   
3. public:               // 重载操作符需要写到public里
   
4.         friend Complex operator-(Complex &c1, Complex &c2);        // 友元重载的友元声明
   
5.         Complex operator+(Complex &c2)     //c1隐藏于this指针     // 成员函数重载
   
6.         {
   
7.                 Complex tmp;
   
8.                 tmp.a = this->a + c2.a;
   
9.                 tmp.b = this->b + c2.b;
   
10.                 return tmp;                  //返回时调用拷贝构造函数
    
11.         }
    
12. 
    
13.         Complex(int a = 0, int b = 0)
    
14.         {
    
15.                 this->a = a;
    
16.                 this->b = b;
    
17.         }
    
18. 
    
19.         void print()
    
20.         {
    
21.                 cout << a << "i+" << b << endl;
    
22.         }
    
23. protected:
    
24. private:
    
25.         int a;
    
26.         int b;
    
27. };
    
28. Complex operator-(Complex &c1, Complex &c2)    //友元重载的定义
    
29. {
    
30.         Complex c3;
    
31.         c3.a = c1.a - c2.a;
    
32.         c3.b = c1.b - c2.b;
    
33.         return c3;
    
34. }
    
35. 
    
36. int main()
    
37. {
    
38.         Complex c1(1, 2), c2(3, 4), c3, c4;
    
39.         c3 = c1+ c2;
    
40.         c4 = c1 - c2;
    
41.         c3.print();
    
42.         c4.print();
    
43.         system("pause");
    
44.         return 0;
    
45. }

复制代码

3、前缀--的成员函数重载、前缀++的友元函数重载

1. class Complex       // 复数类
   
2. {
   
3. public:            
   
4.         friend Complex & operator++(Complex &c2);   // 友元重载前缀++声明
   
5.         Complex operator--()   // 成员重载实现前缀--
   
6.         {
   
7.                 --this->a;
   
8.                 --this->b;
   
9.                 return *this;
   
10.         }
    
11. 
    
12.         Complex(int a = 0, int b = 0)
    
13.         {
    
14.                 this->a = a;
    
15.                 this->b = b;
    
16.         }
    
17. 
    
18.         void print()
    
19.         {
    
20.                 cout << a << "i+" << b << endl;
    
21.         }
    
22. protected:
    
23. private:
    
24.         int a;
    
25.         int b;
    
26. };
    
27. 
    
28. Complex & operator++(Complex &c2)   // 重载前缀++实现
    
29. {
    
30.         c2.a++;
    
31.         c2.b++;
    
32.         return c2;
    
33. }
    
34. 
    
35. int main()
    
36. {
    
37.         Complex c1(1, 2), c2(3, 4), c3, c4;
    
38.         c3 = ++c1;
    
39.         c4 = --c2;
    
40.         c1.print();
    
41.         c2.print();
    
42.         c3.print();
    
43.         c4.print();
    
44.         system("pause");
    
45.         return 0;
    
46. }

复制代码

4、后缀--的成员函数重载、后缀++的友元函数重载
C++为了区分前缀和后缀，规定后缀时需要加上int这个占位参数。

1. class Complex       // 复数类
   
2. {
   
3. public:               // 重载操作符需要写到public里
   
4.         friend Complex operator++(Complex &c2, int);   // 友元重载后缀++声明
   
5.         Complex operator--(int)             // 成员重载实现后缀--
   
6.         {
   
7.                 Complex tmp = *this;
   
8.                 this->a--;
   
9.                 this->b--;
   
10.                 return tmp;
    
11. 
    
12.         }
    
13. 
    
14.         Complex(int a = 0, int b = 0)
    
15.         {
    
16.                 this->a = a;
    
17.                 this->b = b;
    
18.         }
    
19. 
    
20.         void print()
    
21.         {
    
22.                 cout << a << "i+" << b << endl;
    
23.         }
    
24. protected:
    
25. private:
    
26.         int a;
    
27.         int b;
    
28. };
    
29. 
    
30. Complex operator++(Complex &c2, int)   // 重载后缀++实现
    
31. {
    
32.         // 先使用c2的属性，再让属性++， 即返回++之前c2的值
    
33.         Complex tmp;
    
34.         tmp = c2;
    
35.         c2.a++;
    
36.         c2.b++;
    
37.         return tmp;
    
38. }
    
39. 
    
40. int main()
    
41. {
    
42.         Complex c1(1, 2), c2(3, 4), c3, c4;
    
43.         c3 = c1++;
    
44.         c4 = c2--;
    
45.         c1.print();
    
46.         c2.print();
    
47.         c3.print();
    
48.         c4.print();
    
49.         system("pause");
    
50.         return 0;
    
51. }

复制代码

5、cout<< 的友元重载及它的链式编程
cout.operator<<(Complex &c1), cout不会转化为this指针，及它不能重载为成员函数，只能采用友元重载的方法。
为了使“cout<<a<<b<<endl;”得到实现，必须让重载的返回只能够做左值，让返回值做左值，需要返回引用。

1. class Complex       // 复数类
   
2. {
   
3. public:     
   
4.         friend ostream& operator<<(ostream &out, Complex &c1);   // cou<<的友元重载声明
   
5.         Complex(int a = 0, int b = 0)
   
6.         {
   
7.                 this->a = a;
   
8.                 this->b = b;
   
9.         }
   
10. 
    
11.         void print()
    
12.         {
    
13.                 cout << a << "i+" << b << endl;
    
14.         }
    
15. protected:
    
16. private:
    
17.         int a;
    
18.         int b;
    
19. };
    
20. // 返回引用，可以做左值
    
21. ostream& operator<<(ostream &out, Complex &c1) // cou<<的友元重载实现  
    
22. {
    
23.         cout << c1.a << "i+" << c1.b << endl;
    
24.         return out;
    
25. }
    
26. 
    
27. int main()
    
28. {
    
29.         Complex c1(1, 2);
    
30.         cout << c1 << "链式编程测试" << endl;
    
31.         system("pause");
    
32.         return 0;
    
33. }

复制代码