C++——运算符的重载---以成员函数方式重载---以友元函数方式重载

一、运算符的重载

　　1、运算符的重载

　　允许把标准运算符（如+ - * /等运算符）应用于自定义数据类型的对象，可以提高程序的可读性，运算符的重载本质上还是函数重载。运算符仅仅是语法上的方便，它是另一种函数调用的方式，只有在设计涉及的代码更容易写，尤其是更容易读的时候才有必要重载。

　　2、实现运算符重载的方式

• 类的成员函数
• 友元函数（即类外的普通函数）

　　3、运算符重载的原则：

• 不能重载的运算符有5个：  .  .*  ?: ::  sizeof
• 运算符重载不允许发明新的运算符
• 不能改变运算符操作对象的个数
• 运算符被重载后其优先级与结合性不会改变

　　4、友元函数与类成员函数的使用场合：

• 一般情况下，建议一元运算符使用类的成员函数，二元运算符使用友元函数
  • 运算符的操作需要修改类对象的状态，则使用成员函数。如需要做左值操作数的运算符（=，+=，*=，++，--）
  • 运算时，有数与对象的混合运算时，必须使用友元函数
  • 二元运算中，第一个操作数为非对象时，必须使用友元函数。如输入输出运算符<< >>
• 具体规则如下：
• 

　　5.友元函数与类成员函数的参数与返回值

• 参数：
  • 当参数不会被改变时，一般采用const引用，
• 返回值：
  • 如果返回值可能出现在=左边，则只能作为左值，返回非const引用
  • 如果返回值只能出现在=右边，则只能作为右值，返回const型值或const型引用
  • 如果返回值既可能出现在=号左边，也可能出现在=右边，则其返回值必须为左值，返回非const引用。

　　1、使用函数实现两个复数相加。示例代码如下：

•  1 class Complex
   2 {
   3     public:
   4         Complex()
   5         {
   6             real = 0;
   7             imag = 0;
   8         }
   9
  10         Complex Complex_Add(Complex &);
  11
  12     private:
  13         double real;
  14         double imag;
  15 };
  16
  17 Complex Complex :: Complex_Add(Complex &c2)
  18 {
  19     Complex temp;
  20     temp.real = this->real + c2.real;
  21     temp.imag = this->imag + c2.imag;
  22
  23     return temp;
  24 }
  25
  26 int main()
  27 {
  28     Complex c1(3,4),c2(1.2,-4),c3;
  29     c3 = c1.Complex_Add(c2);
  30     return 0;
  31 }

• 这种调用方式太繁琐而且不直观

•  1 class Complex
   2 {
   3     public:
   4         Complex() //无参构造函数
   5         {
   6             real = 0;
   7             imag = 0;
   8         }
   9         Complex(double r, double i) //有参构造函数
  10         {
  11             real  = r;
  12             imag = i;
  13         }
  14         Complex operator + (Complex &c2); //声明重载运算符
  15     private:
  16         double real;
  17         double imag;
  18 };
  19
  20 Complex Complex::operator +(Complex &c2)
  21 {
  22     Complex C;//定义一个C对象是为了能够连续使用+操作符
  23     C.real = real + c2.real;
  24     C.imag = imag + c2.imag;
  25     return C;
  26 }
  27 int main()
  28 {
  29     Complex c1(3,4), c2(5,-10), c3;
  30     c3 = c1 + c2; //运算符+ 用于复数运算
  31     return 0;
  32 }

• 主函数在执行c1+c2语句时，调用了运算符重载函数operator+()函数
• 相当于c1.operaor+(c2);

•  1 class Complex
   2 {
   3     public:
   4         Complex()
   5         {
   6             real = 0;
   7             imag = 0;
   8         }
   9         Complex(double r, double i)
  10         {
  11             real  = r;
  12             imag = i;
  13         }
  14         friend Complex operator + (Complex &c1, Complex &c2); //声明重载运算符
  15     private:
  16         double real;
  17         double imag;
  18 };
  19
  20 Complex operator +(Complex &c1,Complex &c2)
  21 {    return Complex(c1.real + c2.real, c1.imag + c2.imag);//直接调用复制构造函数
  22 }
  23 int main()
  24 {
  25     Complex c1(3,4), c2(5,-10), c3;
  26     c3 = c1 + c2; //运算符+ 用于复数运算
  27     return 0;
  28 }

  必须是complex的对象才可以相加。如果是实数与complex对象相加，则实数会被默认的构造函数强制转换为虚部为0的复数进行相加。

未完待续！！！！！！！！！！！！！

原文地址：https://www.cnblogs.com/southcyy/p/10260626.html