char* 赋值 const char* 释放_错误更正（拷贝赋值函数的正确使用姿势）-CSDN博客

本文链接：https://blog.csdn.net/weixin_36277530/article/details/113051467

这篇博客纠正了关于C++中The Rule of Three的错误，强调了在拷贝赋值函数中释放内存、返回值及自赋值检查的重要性。文章通过实例分析了未正确实现拷贝赋值函数导致的内存泄露问题，并提供了修复方案，以避免自赋值导致的编译错误。

摘要由CSDN通过智能技术生成

这是一篇对什么是C++的The Rule of Three的错误更正和详细说明。

阅读时间7分钟。难度⭐⭐⭐

虽然上一篇文章的阅读量只有凄惨的两位数，但是怀着对小伙伴负责的目的，必须保证代码的正确性。这是大厨做技术自媒体的态度。

前文最后一段代码是这样的：

class Dog {
 private:
   char* name;
   int age;
 public:
   '...省略构造和拷贝构造函数...'
    //拷贝赋值函数
   Dog& operator=(const Dog& that) {
     name = new char[strlen(that.name)+1];
     strcpy(name, that.name);
     age = that.age;
   }
   '...省略析构函数...'
};

先不谈异常安全，这段拷贝赋值函数的代码本身有什么问题？

有3个问题：

没有释放原对象指针成员指向的内容
没有返回值
没有自赋值检查

下面我们一个一个分析。

1 没有释放原对象指针

这个问题很严重，因为一定会造成内存泄露。

原因是指针所指的内存未被释放，而指针又指向了别处。

例子如下，我们写了一个main函数，长这样：

int main(int argc, char* argv[]) {
    Dog D1("Bobby", 2);
    Dog D2("Teddy", 3);
    Dog D2 = D1;
}

D1和D2分别是是Dog的对象。根据构造函数的定义，D2中的name指针指向了字符数组“Teddy”。而当进行D2 = D1操作时，name = new char[strlen(that.name)+1]这一步会在D2中重新创建一个名字为name且指向“Bobby”的指针。

这么做也许编译器不会报错，但是会有问题。

因为在new一个name指针之前，原本的name指针指向的内存并没有被释放。而新的name指针只对新创建的内存负责，老的内存已经变成无主之地。看来内存泄露是逃不掉了。

这个问题看着复杂，解决的办法倒是简单，只需要在拷贝赋值函数体第一行加上 delete[] name就可以了。

class Dog {
 private:
   char* name;
   int age;
 public:
   '...省略构造和拷贝构造函数...'
    //拷贝赋值函数
   Dog& operator=(const Dog& that) {
     delete[] name; //释放原对象指针成员指向的内容
     name = new char[strlen(that.name)+1];
     strcpy(name, that.name);
     age = that.age;
   }
   '...省略析构函数...'
};

2 没有返回值

第二个问题犯的错很低级，拷贝赋值函数的行为和普通函数一样需要一个返回值。而返回值的类型通常是类的对象的引用。

参照常用的写法，这里返回*this(this是C++类的隐藏成员，表示对象本身)。

class Dog {
 private:
   char* name;
   int age;
 public:
   '...省略构造和拷贝构造函数...'
    //拷贝赋值函数
   Dog& operator=(const Dog& that) {
     delete[] name; //释放原对象指针成员指向的内容
     name = new char[strlen(that.name)+1];
     strcpy(name, that.name);
     age = that.age;
     return *this; //返回对象引用
   }
   '...省略析构函数...'
};

另外大家可能有疑问为什么返回值是一个引用而不是一个值呢？

答案是只有引用才能进行连续赋值。

假设有3个Dog对象：D1、D2、D3，如果返回值不是引用，那么类似D1 = D2 = D3将不能通过编译。

3 没有自赋值检查

什么叫做自赋值？

就是两个相同对象之间用等号连接，比如：

int main(int argc, char* argv[]) {
    Dog D1("Bobby", 2);
    Dog D1 = D1; //同一个D1相互赋值
}

当然，一般不会有人写出这样的代码来。这里只是举个简单的例子，但是如果在大型项目中不同开发者对同一对象取了不同的别名，那么自赋值的情况是有可能发生的。

对于上面的Dog类而言，如果执行D1 = D1，那么会发生下面的事情：

首先，对象D1中的name指针被析构，name指向的内存被释放；

然后，下一行中的strlen(that.name)又用到了D1的name所指向的内存。

重点来了：这时你会惊讶地发现编译器提示你name已经不存在了！！！

因为在编译器看来，你在做对同一对象先释放了内存再使用的非法事情！

就好比你是拆迁大队的，你没有确认拆的是不是自己的房子就不管三七二十一直接拆了，然而你晚上还要回家住......

C++真的烧脑，仅仅是不小心把自己赋值给了自己就把自己的一部分给搞丢了，这在其他语言中似乎是天方夜谭。但是C++似乎很情愿把事情搞复杂。

幸好，自赋值问题也很容易修复，只需要在delete指针之前做一个自赋值的判断。

完整代码如下：

class Dog {
 private:
   char* name;
   int age;
 public:
   '...省略构造和拷贝构造函数...'
    //拷贝赋值函数
   Dog& operator=(const Dog& that) {
     if(this != &that) { //判断是否自赋值
         delete[] name; //释放原对象的指针指向的内容
         name = new char[strlen(that.name)+1];
         strcpy(name, that.name);
         age = that.age;
     }
     return *this;
   }
   '...省略析构函数...'
};