• “=”只能重载成成员函数

    • 返回值是一个引用
      1. class String {
      2. private:
      3. char * str;
      4. public:
      5. String():str(new char[1]) { str[0] = 0; }
      6. const char * c_str() { return str; }
      7. String & operator = (const char * s);
      8. String::~String() { delete []str; }
      9. };
      10. String & String::operator = (const char* s) {
      11. delete []str;
      12. str = new char[strlen(s)+1];
      13. strcpy(str, s);
      14. return *this;
      15. }
      16. main() {
      17. String s;
      18. s = "luck"; // 等价于 s.operator=("luck");
      19. cout << s.c_str() << endl;
      20. // String s2 = "hello"; // 出错！初始化语句，不是赋值语句
      21. }

      浅拷贝和深拷贝

      同样还是上面的String类，如果调用如下语句，则是浅拷贝，会产生隐患
      1. String s1, s2;
      2. S1 = "this";
      3. S2 = "that";
      4. S1 = S2;

  • 二者的指针指向同一片地址，同时S1的指针原本指向的内存也没有被释放。两个对象消亡后，会delete两次指针

  • 对S1再次赋值，S2的内容也被更改

如果是执行语句 S1 = S1 呢？
改进如下，进行重载

  1. String & String::operator = (const String & s) {
  2.     if(this == &s)
  3.         return *this;
  4.     delete []str;
  5.     str = new char[strlen(s)+1];
  6.     strcpy(str, s);
  7.     return *this;
  8. }

为什么返回引用？

  • 尽量保持运算符原本的特性，即连等：a = b = c 和 (a = b) = c

  • 分别等价于 a.operator=(b.operator=(c)), (a.operator=(b)).operator=(c)

    上面的String类还有问题！

  • 复制构造函数同理需要重载

    1. String (String & s) { // 不会出现相等的情况
    2.   str = new char[strlen(s.str)+1];
    3.   strcpy(str, s.str);
    4. }