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=(const TestClass& Other);

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

一个天真的实现将分别为每个数据成员分配：

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

（请注意，这正是编译器生成的赋值运算符所做的，因此重载它是没有用的。不过我认为这是用于练习。）

更好的方法是使用 Copy-And-Swap idiom 。（如果你发现GMan的答案过于庞大，请尝试mine，这不是那么详尽。:)）请注意，C＆amp; S使用复制构造函数和析构函数来进行赋值，因此需要传递对象像你在问题中那样复制：

TestClass& operator=(TestClass Other)

Answer 2

您展示的代码会执行此操作。但是，没有人会认为它是一个特别好的实现。

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

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

顺便说一下，你谈的是“其他类”，但你只有一个类，以及该类的多个实例。

Answer 3

几乎所有人都说了几句话：

检查自我分配，即if (&other != this) // assign
在这里查看operator overloading

Answer 4

Traditionnaly赋值运算符和复制构造函数定义为传递const引用，而不是按值复制机制。

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

编辑：我纠正了因为我把代码没有返回TestClass＆amp; （参见@sbi的回答）

Answer 5

您对如何从其他类复制内容是正确的。可以使用operator=分配简单对象。

但是，要警惕TestClass包含指针成员的情况 - 如果你只是使用operator=分配指针，那么两个对象都会有指向同一内存的指针，这可能不是什么你要。您可能需要确保分配一些新内存并将指向的数据复制到其中，以便两个对象都拥有自己的数据副本。请记住，在为复制的数据分配新块之前，还需要正确释放已分配给对象已指向的内存。

顺便说一下，你应该像这样宣布你的operator=：

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

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

类分配运算符

5 个答案: