• 对抽象数据类型也能够直接使用C++提供的运算符
          ? 程序更简洁
          ? 代码更容易理解
• 运算符重载
          ? 对已有的运算符赋予多重的含义
          ? 使同一运算符作用于不同类型的数据时—>不同类型的行为
• 目的
          ? 扩展C++中提供的运算符的适用范围，以用于类所表示的抽象数据类型
• 同一个运算符，对不同类型的操作数，所发生的行为不同
          ? (5,10i) + (4,8i) = (9,18i)
          ? 5 + 4 = 9
• 运算符重载的实质是函数重载
  返回值类型 operator 运算符（形参表）
  {
  ……
  }
  
• 在程序编译时:
          ? 把含 运算符的表达式  —> 对 运算符函数 的调用
          ? 把 运算符的操作数 —> 运算符函数的 参数
          ? 运算符被多次重载时, 根据 实参的类型 决定调用哪个运算符函数
          ? 运算符可以被重载成普通函数
          ? 也可以被重载成类的成员函数
  

class Complex {
  public:
    Complex( double r = 0.0, double i= 0.0 ){
      real = r;
      imaginary = i;
    }
  double real; // real part
  double imaginary; // imaginary part
};

Complex operator+ (const Complex & a, const Complex & b)
{
  return Complex( a.real+b.real, a.imaginary+b.imaginary);
} // “类名(参数表)” 就代表一个对象

Complex a(1,2), b(2,3), c;
c = a + b;// 相当于什么?  operator+(a,b)

5. 运算符重载为成员函数

class Complex {
  public:
    Complex( double r= 0.0, double m = 0.0 ):real(r), imaginary(m) { } // constructor
    Complex operator+ ( const Complex & ); // addition
    Complex operator- ( const Complex & ); // subtraction
  private:
    double real; // real part
    double imaginary; // imaginary part
};
// Overloaded addition operator
Complex Complex::operator+(const Complex & operand2) {
  return Complex( real + operand2.real,imaginary + operand2.imaginary );
}
// Overloaded subtraction operator
Complex Complex::operator- (const Complex & operand2){
  return Complex( real - operand2.real,imaginary - operand2.imaginary );
}
int main(){
 Complex x, y(4.3, 8.2), z(3.3, 1.1);
 x = y + z;// 相当于什么?  y.operator+(z)
 x = y - z;// 相当于什么?  y.operator-(z)
 return 0;
}

4.2 赋值运算符的重载

1. 赋值运算符 ‘=’ 重载

编写一个长度可变的字符串类String
? 包含一个char * 类型的成员变量
—> 指向动态分配的存储空间
? 该存储空间用于存放 ‘\0’ 结尾的字符串

class String {
  private:
    char * str;
  public:
    String () : str(NULL) { } //构造函数, 初始化str为NULL
    const char * c_str() { return str; } //返回值为const类型，保证str不会被修改。比如char* p=str.c_str();则编译器会报错，类型不匹配。
    char * operator = (const char * s);
    ~String( );//需要考虑String对象是否指向了动态分配的存储空间
}; 
//重载‘=’使得obj = “hello”能够成立
char * String::operator = (const char * s){
  if(str) delete [] str;
  if(s) { //s不为NULL才会执行拷贝
    str = new char[strlen(s)+1];
    strcpy(str, s);
  }
  else
    str = NULL;
  return str;
}
String::～String( ) {
  if(str) delete [] str;
};
int main(){
  String s;
  s = “Good Luck,” ;
  cout << s.c_str() << endl;
  // String s2 = “hello!”; //这条语句要是不注释掉就会出错
  s = "Shenzhou 8!";
  cout << s.c_str() << endl;
  return 0;
}

2. 重载赋值运算符的意义 – 浅复制和深复制

S1 = S2;

• 浅复制/浅拷贝
          执行逐个字节的复制工作

S1和S2指向了同一块动态分配内存区域，那么当S1和S2同时消亡的时候，这一块内存空间就会被先后释放两次。这样就会导致严重的内存错误，甚至可能引发程序意外的中止。

• 深复制/深拷贝
          将一个对象中指针变量指向的内容 —> 复制到另一个对象中指针成员对象指向的地方

• void 好不好?
          考虑: a = b = c;
          //等价于a.operator=(b.operator=(c));
• String 好不好?为什么是 String &
          运算符重载时, 好的风格 -- 尽量保留运算符原本的特性
          考虑: (a=b)=c; //会修改a的值
          分别等价于：(a.operator=(b)).operator=(c);

5. 上面的String类是否就没有问题了?

• 通常，将运算符重载为类的成员函数
• 重载为友元函数的情况:
          ? 成员函数不能满足使用要求
          ? 普通函数，又不能访问类的私有成员

class Complex{
    double real, imag;
  public:
    Complex(double r, double i):real(r), imag(i){ };
    Complex operator+(double r);
};
Complex Complex::operator+(double r){ //能解释 c+5
  return Complex(real + r, imag);
}

Complex operator+ (double r, const Complex & c) {
  //能解释 5+c
  return Complex( c.real + r, c.imag);
}

class Complex {
    double real, imag;
  public:
    Complex( double r, double i):real(r),imag(i){ };
    Complex operator+( double r );
    friend Complex operator + (double r, const Complex & c);
};