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

一、运算符的重载

　　1、运算符的重载

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

　　2、实现运算符重载的方式------既然是操作符重载，就必然会访问类的私有成员变量，根据类的封装性要求，除了友元函数外，其他任何外部操作都是违规的，所以不能用普通函数来重载操作符

• 类的成员函数
• 友元函数（即类外的普通函数）
• 普通函数---在极少数的情况下才会使用普通函数，因为普通函数不能直接访问类的私有成员。解决方法是在类中定义公用的设置数据的set函数和读取数据的get函数，在重载函数中调用这些函数去访问类的私有成员。显然这样不好。

　　3、运算符重载的原则：

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

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

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

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

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

---

---

---

二、使用函数、类成员函数、友元函数分别实现复数+运算符的重载

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

• class Complex
  {
      public:
          Complex() 
          {
              real = 0;
              imag = 0;
          }
          
          Complex Complex_Add(Complex &);
          
      private:    
          double real;
          double imag;
  };
   
  Complex Complex :: Complex_Add(Complex &c2)
  {
      Complex temp;
      temp.real = this->real + c2.real;
      temp.imag = this->imag + c2.imag;
      
      return temp;
  }
   
  int main()
  {
      Complex c1(3,4),c2(1.2,-4),c3;
      c3 = c1.Complex_Add(c2);
      return 0;
  }

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

---

　　2、使用类成员函数重载运算符+实现复数运算。具体代码如下：

• class Complex
  {
      public:
          Complex() //无参构造函数
          {
              real = 0;
              imag = 0;
          }
          Complex(double r, double i) //有参构造函数
          {
              real  = r;
              imag = i;
          }
          Complex operator + (Complex &c2); //声明重载运算符
      private:
          double real;
          double imag;
  };
   
  Complex Complex::operator +(Complex &c2)
  {
      Complex C;//定义一个C对象是为了能够连续使用+操作符
      C.real = real + c2.real;
      C.imag = imag + c2.imag;
      return C;
  } 
  int main()
  {
      Complex c1(3,4), c2(5,-10), c3;
      c3 = c1 + c2; //运算符+ 用于复数运算
      return 0;
  }

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

• 相当于c1.operaor+(c2);

---

　　3、使用友元函数重载运算符+实现复数的相加。具体代码如下：

• class Complex
  {
      public:
          Complex()
          {
              real = 0;
              imag = 0;
          }
          Complex(double r, double i)
          {
              real  = r;
              imag = i;
          }
          friend Complex operator + (Complex &c1, Complex &c2); //声明重载运算符
      private:
          double real;
          double imag;
  };
   
  Complex operator +(Complex &c1,Complex &c2)
  {    return Complex(c1.real + c2.real, c1.imag + c2.imag);//直接调用复制构造函数
  } 
  int main()
  {
      Complex c1(3,4), c2(5,-10), c3;
      c3 = c1 + c2; //运算符+ 用于复数运算 
      return 0;
  }

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

---

---

---

三、成员函数重载与友元函数重载的区别：

　　1、成员函数与友元函数的区别

• 成员函数：可以通过this指针访问本类的成员，可以少写一个参数，但是表达式左边的的第一个参数必须是类对象，通过该类对象来调用成员函数。即表达式左侧的左侧运算量就是对象本身。
• 友元函数：左边一般不是对象。比如输入输出运算符<<  >>一般都要申明为友元重载函数。

　　2、成员函数与友元函数对单目运算符双目运算符的比较

• 对于双目运算符：成员函数重载运算符参数列表需要含有一个参数，而友元函数重载运算符的参数列表需要有两个参数，
• 对于单目运算符：成员函数重载运算符的参数列表中没有参数，而友元函数重载运算符的参数列表中含有一个参数。

---

• 双目运算符可以被重载为友元函数运算符和成员函数运算符。对于复数类+号运算符的重载：当一个整数与一个复数相加时必须使用友元函数。因为使用成员函数表达式左侧必须是对象本身。因此双目运算符一般使用友元函数重载，单目运算符一般使用成员函数重载。

---

• 下边列举分别使用成员函数与友元函数重载的++，--，自加加，自减减的例子
  • 使用成员函数以前缀和后缀方式重载运算符--；代码如下：

    • class three
      {
          public:
              three(int a=0,int b=0,int c=0);
              void print();
              three operator--();//声明自减运算符--重载成员函数（前缀方式） 
              three operator--(int);//声明自减运算符--重载成员函数（后缀方式）
              private:
              int x,y,z; 
      };
      
      three::three(int a,int b,int c)
      {
          x=a;
          y=b;
          z=c;
      }
      three three::operator--()
      {
          --x;
          --y;
          --z;
          return *this;//返回自减后的当前对象 
       } 
      three three::operator--(int)
      {
          three temp(*this); 
          x--;
          y--;
          z--;
          return temp;
      }

  • 使用友元函数以前缀方式后缀方式重载运算符++。具体代码如下：

    • class three
      {
          public:
              three(int a=0,int b=0,int c=0);
              void print();
              friend three operator++(three &op);//声明自加运算符++重载友元函数（前缀方式） 
              friend three operator++(three &op,int);//声明自加运算符++重载友元函数（后缀方式） 
              private:
                  int x,y,z;
       };
      
       three::three(int a,int b,int c)
       {
          x=a;
          y=b;
          z=c;
       }
      
      three operator++(three &op)
      {
          ++op.x;
          ++op.y;
          ++op.z;
          return op;
      }
      
      three operator++(three &op,int)
      {
          op.x++;
          op.y++;
          op.z++;
          return op;
      }

---

---

---

四、运算符重载过程中引用于const引用的使用详见后续博客。