运算符的重载

Complex Add(const Complex& com) const  //使用类类型做参数，返回值也为类类型
{
   int r=this->real+com.real;
   int i=this->image+com.image;
   return Complex(r,i);
}
int main()
{
  Complex ca(1,2);
  Complex cb(3,4);
  Complex cc;
  ca.Print();
  cb.Print();
  cc.Print();
  cc=ca.Add(cb);
return 0;
}

       运算符的重载实际是一种特殊的函数重载，必须定义一个函数，并告诉C++编译器，当遇到该重载的运算符时调用此函数。这个函数叫做运算符重载函数，通常为类的成员函数。

        定义运算符重载函数的一般格式：

        返回值类型 类名：：operator重载的运算符（参数表）

{......}

Complex operator+(const Complex& com) const
{
    int r=this->real+com.real;
    int i=this->image+com.image;
    return Complex(r,i);
}

int main()
{
  Complex ca(1,2);
  Complex cb(3,4);
  Complex cc;
  ca.Print();
  cb.Print();
  cc.Print();
  cc=ca+cb;
  //相当于 cc=ca.operator+(cb);
  //再相当于 cc=operate+(&ca,cb);
  cc.Print();
  return 0;
}

扩展+=运算符：

void operate+=(const Complex &com)
{
   this->real=this->real+com.real;
   this->image+=com.image;
}
//ca+=cb;
//ca.operate+=(cb);
//operate(&ca,cb);

Complex& operator+=(const Complex& com)  //以引用类型返回
{
  this->real+=com.real;
  this->image+=com.image;
  return *this;
}
int main()    
{
  Complex ca(1,2),cb(3,4),cc;  //这样设计就可以尽量不产生临时对象
  cc=ca+=cb;
  return 0;

}

作业：前置++与后置++在运算符重载中的形式

#include
#include
#include
using namespace std;
class Int
{
   private:
     int  value;
 public:
     Int(int x=0):value(x){}
      ~int() {}  
   Int(const Int& it):value(it.value) {}
   Int operate+(Int& com)
{
   
    int val=value+com.value;
    return Int(val);
}
Int& operate+=(Int &com)
{
  value+=com.value;
   return *this;
 
}
Int operate++(int k) //为了区分前置++和后置++的函数重载，在函数定义时在 
                      //参数列表中，增加无意义的int类型来区分
{  
  int val=value++;
  return Int(val);
  
}
Int& operate++()  //前置++，返回引用
{
    ++value;
return (*this);
    
}
Int operate

};
int main()
{
  Int a(10),b(20),c(0);
  c=a+b;
c=a+=b;
 c=a++;    //等价于a.operate++(0);
c=++a;    //等价于a.operate++();
}