复制赋值运算符说明

Question

我正在为我创建的一个类编写一个复制赋值运算符，并使用以前的帖子作为指导： What is The Rule of Three?

我对这个人的解释的一个方面有点困惑。

这是他们的班级：

class person
{
    char* name;
    int age;
};

这是我用作参考的复制赋值运算符定义（至少提供了 2 个）：

// 2. copy assignment operator
person& operator=(const person& that)
{
    char* local_name = new char[strlen(that.name) + 1];
    // If the above statement throws,
    // the object is still in the same state as before.
    // None of the following statements will throw an exception :)
    strcpy(local_name, that.name);
    delete[] name;
    name = local_name;
    age = that.age;
    return *this;
}

我感到困惑的是，为什么它们包括delete[] name; 行？

这是他们提供的另一个例子：

person& operator=(const person& that)
{
    if (this != &that)
    {
        delete[] name;
        // This is a dangerous point in the flow of execution!
        // We have temporarily invalidated the class invariants,
        // and the next statement might throw an exception,
        // leaving the object in an invalid state :(
        name = new char[strlen(that.name) + 1];
        strcpy(name, that.name);
        age = that.age;
    }
    return *this;
}

我立即回避了这个，因为我不明白为什么该函数会检查 if(this != &that) 然后在似乎尚未生成的数组上运行 delete (delete[] name;)。调用赋值运算符时，是否在调用复制赋值运算符函数之前立即调用常规构造函数？因此意味着我们必须删除类构造函数生成的数组，因为它只能充满垃圾数据？

为什么我不能写： name = that.name 或

name = new char[that.name.size()];
for (int i = 0; i < that.name.size(); i++)`
{
  name[i] = that.name[i]
}

这可能是非常基本的，我应该只实现帖子的建议，但我的实际用例涉及一个包含多个成员的 structs 数组，所以我只是有点难以理解我到底需要什么去做。

我知道这里有大约 2.5 个问题。任何见解将不胜感激。

这是我第一次实现自定义复制构造函数和复制赋值运算符，我相信在我完成几次之后会看起来很容易。

提前致谢。

Answer 1

我感到困惑的是，为什么它们包括行 delete[] name;？

当使用new 和new[] 管理内存时，经验法则是它们应该有一个匹配的delete 或delete[]。据推测，name 之前是用new[] 分配的（在构造函数中或通过先前的赋值），所以在用name = local_name; 在下一行重新分配它之前，我们需要delete[] 它。

我不明白为什么函数会检查 if(this != &that)

此检查是一个健全性检查。如果您将对象分配给自身，则无需执行任何操作。实际上，它可能会导致问题，因为如果您在this 指向与that 引用相同的对象时delete[] name;，那么您将无法再复制that.name，因为它的内存已被释放。

为什么我不能只写：name = that.name 或

这将使name 在两个不同的实例中指向同一个内存。在某些情况下，这样的共享内存不仅有用而且是理想的。但是，您必须小心，因为如果其中一个实例对其名称执行 delete[]，那么另一个实例中的 name 将不再有效。

Answer 2

所有这些都是确保正确管理内存所必需的。

如果我理解正确，您需要一个operator= 实际调用时间的答案？
嗯，operator= 总是被调用当两个有效对象存在时。其中一个是分配给的，第二个是数据源。在此操作之后，两个对象必须仍然有效。

这意味着在operator= 内部，this 对象的内存分配给了一个字符串（在其中一个 contrusctors 中分配）和that 对象，内存也分配给了另一个字符串。

我感到困惑的是，为什么它们包含delete[] name; 行？

我们必须首先清理当前驻留在this 对象中的内存，否则我们会在分配新的妈妈后丢失这个指针。

调用赋值运算符时，是否在调用复制赋值运算符函数之前立即调用常规构造函数？

没有。该对象已经存在，这就是调用 operator= 的原因（而不是复制构造函数）。

因此意味着我们必须删除类构造函数生成的数组，因为它只能充满垃圾数据？

它充满了有效数据。您的对象已构建，其中包含一些数据，然后您将其他内容分配给该对象。

---

附录：何时调用复制构造函数，何时调用operator=？（有关更多详细信息，请参阅this question）：

class A{};

int main()
{
    A a1; //default constructor 
    A a2 = a1; //copy-constructor, not assignment operator! New object is needed

    A a3; 
    a3 = a1; //we have valid and existing object on the left side, assignment operator is used
}

Answer 3

让我们从关于这段代码sn-p的问题开始。

name = new char[that.name.size()];
for (int i = 0; i < that.name.size(); i++)`
{
  name[i] = that.name[i]
}

数据成员名称的类型为 char *。那就是它是一个指针。指针和指针指向的字符都没有像size 这样的成员函数。

所以这段代码sn-p是无效的，不会编译。

你可以使用这样的方法

name = that.name;

如果数据成员的类型为std::string。

为什么我不能直接写：name = that.name

在这种情况下，该类的两个对象将包含指向相同内存范围的指针。因此，如果一个对象将被删除，那么另一个对象的指针将是无效的，并且使用它来删除分配的内存会导致未定义的行为。

当调用赋值运算符时，是正则构造函数 在复制赋值运算符函数之前立即调用 叫什么？

复制赋值运算符只能应用于已经构造的对象。也就是说，该类的对象必须已经存在，并且使用的构造函数应通过nullptr 或分配的内存地址初始化其数据成员名称。

我立即回避了这个，因为我无法理解 为什么函数会检查 if(this != &that)

此检查可以避免对象的自分配。也就是说，当一个对象被分配给自己时，分配和删除内存的代码将是多余的。

我感到困惑的是，为什么它们包括该行 删除[] 名称；？

因为对象已经被构造，并且它的数据成员名称可以指向包含名称字符串的分配内存。

考虑到所有内容，复制赋值运算符可能看起来像

person& operator =( const person &that )
{
    if ( this != &that )
    {
        char *local_name = new char[strlen(that.name) + 1];
        // If the above statement throws,
        // the object is still in the same state as before.
        // None of the following statements will throw an exception :)
        strcpy(local_name, that.name);
        delete[] name;
        name = local_name;
        age = that.age;
    }

    return *this;
}