1.**运算符重载通过定义函数实现，实质上是函数重载。**

    • 运算符重载通过定义函数实现，实质上是函数重载。
    • 一般格式：

    函数类型 operator 运算符名称 (形参表列)
    {
    对运算符的重载处理
    }

    • 例：

      1. //重载运算符“+”，使之能用于两个复数相加。
      2. #include <iostream>
      3. using namespace std;
      4. class Complex
      5. {public:
      6. Complex( ){real=0;imag=0;}
      7. Complex(double r,double i){real=r;imag=i;}
      8. Complex operator+(Complex &c2); //声明重载运算符的函数
      9. void display( );
      10. private:
      11. double real;
      12. double imag;
      13. };
      14. Complex Complex∷ operator+(Complex &c2)
      15. { Complex c;
      16. c.real=real+c2.real;
      17. c.imag=imag+c2.imag;
      18. return c;}
      19. void Complex∷ display( )
      20. { cout<<″(″<<real<<″,″<<imag<<″i)″<<endl;}
      21. int main( )
      22. { Complex c1(3,4),c2(5,-10),c3;
      23. c3=c1+c2; //运算符+用于复数运算
      24. cout<<″c1=″;c1.display( );
      25. cout<<″c2=″;c2.display( );
      26. cout<<″c1+c2=″;c3.display( );
      27. return 0;
      28. }
      • C++编译系统将c1+c2解释为c1.operator+(c2)，即以c2为实参调用c1的运算符重载函数operator+(Complex &c2)，进行求值，得到两个复数之和。
      • 运算符重载函数更简练的写法：
        1. Complex Complex∷ operator + (Complex &c2)
        2. {return Complex(real+c2.real, imag+c2.imag);}

    2.重载运算符的规则

    (1) C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载。

    (2) C++中绝大部分的运算符允许重载。

    • 不能重载的运算符只有5个：
      • . (成员访问运算符)
      • .* (成员指针访问运算符)
      • ∷ (域运算符)
      • sizeof (长度运算符)
      • ?: (条件运算符)

    (3)重载不能改变运算符运算对象(即操作数)的个数。

    (4) 重载不能改变运算符的优先级别。

    (5) 重载不能改变运算符的结合性。

    (6)重载运算符的函数不能有默认的参数。

    (7)重载的运算符必须和用户定义的自定义类型的对象一起使用，其参数至少应有一个是类对象(或类对象的引用)。

    (8) 用于类对象的运算符一般必须重载，但有两个例外，运算符“=”和“&”不必用户重载。

    (9) 应当使重载运算符的功能类似于该运算符作用于标准类型数据时所实现的功能。

    (10) 运算符重载函数可以是类的成员函数，也可以是类的友元函数，还可以是既非类的成员函数也不是友元函数的普通函数。

    3.运算符重载函数作为类成员函数和友元函数

    • 运算符重载函数除了可以作为类的成员函数外，还可以是友元函数

      1. //将运算符“+”重载为适用于复数加法，重载函数不作为成员函数，
      2. //而放在类外，作为Complex类的友元函数
      3. #include <iostream>
      4. using namespace std;
      5. class Complex
      6. {public:
      7. Complex( ){real=0;imag=0;}
      8. Complex(double r,double i){real=r;imag=i;}
      9. friend Complex operator + (Complex &c1,Complex &c2);
      10. void display( );
      11. private:
      12. double real;
      13. double imag;
      14. };
      15. Complex operator + (Complex &c1,Complex &c2)
      16. {return Complex(c1.real+c2.real, c1.imag+c2.imag);}
      17. void Complex∷ display( )
      18. {cout<<″(″<<real<<″,″<<imag<<″i)″<<endl;}
      19. int main( )
      20. {
      21. Complex c1(3,4),c2(5,-10),c3;
      22. c3=c1+c2;
      23. cout<<″c1=″; c1.display( );
      24. cout<<″c2=″; c2.display( );
      25. cout<<″c1+c2 =″; c3.display( );
      26. }
      • 将运算符“+”重载为非成员函数后，编译系统将c1+c2解释为:operator+(c1,c2)

    • 如将运算符重载函数作为成员函数，可以通过this指针，少写一个函数的参数：

      Complex Complex∷ operator+(int &i)
{return Complex(real+i,imag);}

    • 如果将双目运算符重载函数作为友元函数，则必须有两个参数

    注：数学上的交换律在此不适用

    Complex operator+(Complex &c, int &i)
{return Complex(i+c.real,c.imag);}
    • 有的运算符(如赋值运算符、下标运算符、函数调用运算符)必须定义为类的成员函数，有的运算符则不能定义为类的成员函数(如流插入“<<”和流提取运算符“>>”、类型转换运算符)。
      • 一般将单目运算符重载为成员函数，将双目运算符重载为友元函数。