C++ - 赋值运算符重载

• 赋值运算符两边的类型可以不匹配
  • 把一个 int 类型变量赋值给一个 Complex对象
  • 把一个 char* 类型的字符串赋值给一个字符串对象
• 需要重载赋值运算符 ‘=’
• 赋值运算符“=”只能重载为成员函数
• 编写一个长度可变的字符串类 String
  • 包含一个 char*类型的成员变量
    ->指向动态分配的存储空间
  • 该存储空间用于存放‘\0’结尾的字符串

class String{
      private:
          char *str;
    public:
          String():str(NULL){}//构造函数
          const char * c_str() {return str; }//返回值，因为不希望外界能够修改所返回指针所指向的内容，所以这里返回 const 指针
          char * operator = (const char * s);
          ~String();
}
//重载'='->obj = "hello"能够成立
char *String :: operator = (const char * s){
    if(str)delete[]str;//如果指针之前有指向的内容，则删除
    if(s){
        str = new char[strlen(s)+1];//因为要添加末尾的'\0'，所以要+1
        strcpy(str,s);
    }
    else
        str = NULL;
    return str;
}
String::~String(){
    if(str) delete []str;
};
int main(){
      String s;
      s = "Good Luck,"; //-->s.operator = ("")
      cout<

• 重载赋值运算符的意义 - 浅复制 和 深复制

MyString S1,S2;
S1 = "this";
S2 = "that";
S1 = S2;

- 浅拷贝：那么 S1中指向 “this” 的指针会改变为指向 "that"的内存空间的指针，也就是对 S2 中指向 "that" 内存空间的指针进行了拷贝。这样会到来两个问题：
    * 之前 “this” 内容变为垃圾内存
    * 当 S1 和 S2 要释放的时候，会对 “that” 空间连续释放两次，造成程序崩溃。
- 深拷贝：将 “that” 内容拷贝给 “this” 内容的空间，这样就不会出现浅拷贝所出现的问题。

• 在 class MyString 里添加成员函数：

//实现深复制
String & operator = (const String & s){
    if(str == s.str)return * this;//如果传递进来的指针和我的指针是一样的话，那么就返回当前的指针。例如：s = s
    if(str) delete [] str;
    str = new char[strlen(s.str)+1];
    strcpy(str,s.str);
    return * this;
}

• 对 operatpr = 返回值类型的讨论
  • void：
    • 如果使用 a = b = c 的话会造成第二个式子参数为0.
  • String好不好？为什么是 String&
    运算符重载的时候，尽量保留运算符原本的特性，
    考虑：

(a=b)=c;//会修改 a 的值
等价于:  
  (a.operator =(b)).operator=(c);

• 为String 类编写复制构造函数时
• 会面临和 ‘=’ 同样的问题，用同样的方法处理

//如果使用默认的复制构造函数的时，那么会出现上面一样的重复释放的问题
String::String(String & s)
{
    if(s.str){
          str = new char[strlen(s.str)+1];
          strcpy(str,s.str);
     }else{
          str = NULL;
      }
}