类赋值运算符

Question

我做了以下运算符重载测试：

#include <iostream>
#include <string>

using namespace std;

class TestClass
{
    string ClassName;

    public:

    TestClass(string Name)
    {
        ClassName = Name;
        cout << ClassName << " constructed." << endl;
    }

    ~TestClass()
    {
        cout << ClassName << " destructed." << endl;
    }

    void operator=(TestClass Other)
    {
        cout << ClassName << " in operator=" << endl;
        cout << "The address of the other class is " << &Other << "." << endl;
    }
};

int main()
{
    TestClass FirstInstance("FirstInstance");
    TestClass SecondInstance("SecondInstance");

    FirstInstance = SecondInstance;
    SecondInstance = FirstInstance;

    return 0;
}

赋值运算符的行为与预期一样，输出另一个实例的地址。

现在，我将如何真正分配来自另一个实例的东西？例如，像这样：

void operator=(TestClass Other)
{
    ClassName = Other.ClassName;
}

Answer 1

您展示的代码可以做到这一点。不过，没有人会认为这是一个特别好的实现。

这符合赋值运算符的预期：

TestClass& operator=(TestClass other)
{
    using std::swap;
    swap(ClassName, other.ClassName);
    // repeat for other member variables;
    return *this;
}

顺便说一句，您说的是“其他类”，但您只有一个类，并且该类有多个实例。

Answer 2

赋值运算符的传统规范形式如下所示：

TestClass& operator=(const TestClass& Other);

（您也不想调用复制构造函数进行赋值）它返回对*this 的引用。

一个简单的实现会单独分配每个数据成员：

TestClass& operator=(const TestClass& Other)
{
  ClassName = Other.ClassName;
  return *this;
}

（请注意，这正是编译器生成的赋值运算符会做的事情，所以重载它是毫无用处的。不过我认为这是为了锻炼。）

更好的方法是使用 Copy-And-Swap idiom。 （如果你觉得 GMan 的回答太过分了，试试mine，它不那么详尽。:)）请注意，C&S 使用复制构造函数和析构函数来进行赋值，因此需要每个副本传递对象，就像你在你的问题：

TestClass& operator=(TestClass Other)

Answer 3

差不多都说了，有几点说明：

• 检查自分配，即if (&other != this) // assign
• 在这里查看operator overloading 的优秀指南

Answer 4

传统上，赋值运算符和复制构造函数是通过 const 引用定义的，而不是通过值复制机制。

class TestClass 
{
public:
    //... 
    TestClass& operator=(const TestClass& Other)
    {
        m_ClassName= Other.m_ClassName;
        return *this;
    }
private:
    std::string m_ClassName;
 }

编辑：我更正了，因为我放置了没有返回 TestClass& 的代码（c.f. @sbi 的答案）

Answer 5

关于如何从其他类复制内容是正确的。只需使用operator= 即可分配简单的对象。

但是，请注意TestClass 包含指针成员的情况——如果您只是使用operator= 分配指针，那么两个对象都会有指向同一内存的指针，这可能不是您想要的。相反，您可能需要确保分配一些新内存并将指向的数据复制到其中，以便两个对象都有自己的数据副本。请记住，在为复制的数据分配新块之前，您还需要正确地解除分配对象已经指向的内存。

顺便说一句，你应该像这样声明你的operator=：

TestClass & operator=(const TestClass & Other)
{
    ClassName = Other.ClassName;
    return *this;
}

这是重载operator= 时使用的一般约定。 return 语句允许链接赋值（如a = b = c）并通过const 引用传递参数，避免将Other 复制到函数调用中。