什么是三法则？

Question

• 复制对象是什么意思？
• 什么是复制构造函数和复制赋值运算符？
• 我什么时候需要自己申报？
• 如何防止我的对象被复制？

Answer 1

简介

C++ 使用值语义来处理用户定义类型的变量。
这意味着对象在各种上下文中隐式复制，
我们应该理解“复制对象”的实际含义。

让我们考虑一个简单的例子：（

class person
{
    std::string name;
    int age;

public:

    person(const std::string& name, int age) : name(name), age(age)
    {
    }
};

int main()
{
    person a("Bjarne Stroustrup", 60);
    person b(a);   // What happens here?
    b = a;         // And here?
}

如果您对 name(name),age(age) 部分感到困惑，
这称为成员初始值设定项列表。）

特殊成员函数

复制人意味着什么目的？
main 函数显示了两种不同的复制场景。
初始化 person b(a); 由复制构造函数执行。
它的工作是根据现有对象的状态构造一个新的对象。
赋值b = a由复制赋值运算符执行。
它的工作通常有点复杂
因为目标对象已经处于需要处理的某种有效状态。

由于我们自己既没有声明复制构造函数也没有声明赋值运算符（也没有声明析构函数），
这些是为我们隐式定义的。引用自标准：

[...] 复制构造函数和复制赋值运算符、[...] 和析构函数是特殊的成员函数。
[ 注意：实现将隐式声明这些成员函数
对于某些类类型，当程序未显式声明它们时。
如果使用它们，实现将隐式定义它们。 [...]尾注]
[n3126.pdf 第 12 节 §1]

默认情况下，复制对象意味着复制其成员：

非联合类 X 的隐式定义复制构造函数执行其子对象的成员复制。
[n3126.pdf 第 12.8 §16 节]

非联合类 X 的隐式定义复制赋值运算符执行成员复制赋值
它的子对象。
[n3126.pdf 第 12.8 §30 节]

隐式定义

person 的隐式定义的特殊成员函数如下所示：

// 1. copy constructor
person(const person& that) : name(that.name), age(that.age)
{
}

// 2. copy assignment operator
person& operator=(const person& that)
{
    name = that.name;
    age = that.age;
    return *this;
}

// 3. destructor
~person()
{
}

成员复制正是我们在这种情况下想要的：
name 和 age 被复制，因此我们得到一个独立的、独立的 person 对象。
隐式定义的析构函数始终为空。
在这种情况下这也很好，因为我们没有在构造函数中获取任何资源。
在 person 析构函数完成后，隐式调用成员的析构函数：

执行析构函数主体并销毁主体内分配的所有自动对象后，
类 X 的析构函数调用 X 直接成员的析构函数
[n3126.pdf 12.4 §6]

管理资源

那么我们什么时候应该显式声明这些特殊成员函数呢？
当我们的类管理资源时，即
当该类的对象负责该资源时。
这通常意味着资源是在构造函数中获取的
（或传递到构造函数中）并在析构函数中释放。

让我们回到 C++ 标准之前的时代。
根本不存在 std::string 这样的东西，而且程序员们都非常喜欢指针。
person 类可能看起来像这样：

class person
{
    char* name;
    int age;

public:

    // the constructor acquires a resource:
    // in this case, dynamic memory obtained via new[]
    person(const char* the_name, int the_age)
    {
        name = new char[strlen(the_name) + 1];
        strcpy(name, the_name);
        age = the_age;
    }

    // the destructor must release this resource via delete[]
    ~person()
    {
        delete[] name;
    }
};

即使在今天，人们仍然以这种风格编写类并遇到麻烦：
“我将一个人推入向量，现在我出现了疯狂的记忆错误！”
请记住，默认情况下，复制对象意味着复制其成员，
但是复制name成员只是复制一个指针，而不是它指向的字符数组！
这会产生一些令人不快的影响：

1. 通过 a 进行的更改可以通过 b 观察到。
2. 一旦b被销毁，a.name就是一个悬空指针。
3. 如果a被销毁，删除悬空指针会产生未定义的行为。
4. 由于赋值没有考虑赋值之前 name 指向的内容，
   迟早你会到处出现内存泄漏。

显式定义

由于成员复制没有达到预期的效果，因此我们必须显式定义复制构造函数和复制赋值运算符来对字符数组进行深层复制：

// 1. copy constructor
person(const person& that)
{
    name = new char[strlen(that.name) + 1];
    strcpy(name, that.name);
    age = that.age;
}

// 2. copy assignment operator
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;
}

注意初始化和赋值之间的区别：
我们必须在将旧状态分配给 name 之前将其拆除，以防止内存泄漏。
此外，我们还必须防止 x = x 形式的自分配。
如果没有该检查，delete[] name 将删除包含 source 字符串的数组，
因为当您编写 x = x 时，this->name 和 that.name 都包含相同的指针。

异常安全

不幸的是，如果 new char[...] 由于内存耗尽而引发异常，则此解决方案将失败。
一种可能的解决方案是引入局部变量并对语句重新排序：

// 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;
}

这也可以在没有显式检查的情况下处理自分配。
这个问题的一个更强大的解决方案是复制和交换惯用法，
但这里我不会详细讨论异常安全。
我只提到例外是为了表明以下观点： 编写管理资源的类很困难。

不可复制的资源

某些资源不能或不应该被复制，例如文件句柄或互斥体。
在这种情况下，只需将复制构造函数和复制赋值运算符声明为 private 而不给出定义：

private:

    person(const person& that);
    person& operator=(const person& that);

或者，您可以从 boost::noncopyable 继承或将它们声明为已删除 (在 C++11 及以上版本中）：

person(const person& that) = delete;
person& operator=(const person& that) = delete;

三法则

有时您需要实现一个管理资源的类。
（永远不要在一个类中管理多个资源，
这只会导致痛苦。）
在这种情况下，请记住三法则：

如果您需要显式声明析构函数，
自己复制构造函数或复制赋值运算符，
您可能需要显式声明所有三个。

（不幸的是，这个“规则”并不是由 C++ 标准或我所知道的任何编译器强制执行的。）

五规则

从 C++11 开始，对象有 2 个额外的特殊成员函数：移动构造函数和移动赋值。统治五州也履行这些职能。

签名示例：

class person
{
    std::string name;
    int age;

public:
    person(const std::string& name, int age);        // Ctor
    person(const person &) = default;                // 1/5: Copy Ctor
    person(person &&) noexcept = default;            // 4/5: Move Ctor
    person& operator=(const person &) = default;     // 2/5: Copy Assignment
    person& operator=(person &&) noexcept = default; // 5/5: Move Assignment
    ~person() noexcept = default;                    // 3/5: Dtor
};

零规则

3/5 规则也称为 0/3/5 规则。规则的零部分指出，在创建类时不允许您编写任何特殊成员函数。

建议

大多数时候，您不需要自己管理资源，
因为现有的类（例如 std::string）已经为您完成了这项工作。
只需使用 std::string 成员比较简单的代码
到使用 char* 的复杂且容易出错的替代方案，您应该相信。
只要您远离原始指针成员，三法则就不太可能涉及您自己的代码。

Answer 2

三法则基本上是 C++ 的经验法则说

如果您的班级需要以下任何一项

• 一个复制构造函数，
• 赋值运算符，
• 或析构函数，

明确定义，那么很可能需要全部三个。

原因是它们三个通常都用来管理资源，如果你的类管理资源，它通常需要管理复制和释放。

如果没有好的语义来复制类管理的资源，则考虑通过声明来禁止复制（而不是 定义）复制构造函数和赋值运算符为私有。

（请注意，即将推出的新版本 C++ 标准（即 C++11）向 C++ 添加了移动语义，这可能会改变三法则。但是，我对此知之甚少，无法编写 C++11 部分关于三法则。）

Answer 3

三巨头法则如上所述。

一个简单的例子，用简单的英语来说明它解决的问题：

非默认析构函数

您在构造函数中分配了内存，因此您需要编写一个析构函数来删除它。否则会导致内存泄漏。

您可能认为这已经完成了。

问题是，如果您的对象有一个副本，那么该副本将指向与原始对象相同的内存。

一旦其中一个在其析构函数中删除了内存，另一个将有一个指向无效内存的指针（这称为悬空指针），当它尝试使用它时，事情会变得很棘手。

因此，您编写一个复制构造函数，以便它为新对象分配自己的内存块以进行销毁。

赋值运算符和复制构造函数

您在构造函数中将内存分配给了类的成员指针。当您复制此类的对象时，默认赋值运算符和复制构造函数将将此成员指针的值复制到新对象。

这意味着新对象和旧对象将指向同一块内存，因此当您在一个对象中更改它时，另一个对象也会发生更改。如果一个对象删除了该内存，另一个对象将继续尝试使用它 - 哎呀。

要解决此问题，您可以编写自己版本的复制构造函数和赋值运算符。您的版本为新对象分配单独的内存，并复制第一个指针指向的值而不是其地址。

Answer 4

基本上，如果您有析构函数（不是默认析构函数），则意味着您定义的类具有一些内存分配。假设该类由某些客户端代码或您在外部使用。

    MyClass x(a, b);
    MyClass y(c, d);
    x = y; // This is a shallow copy if assignment operator is not provided

如果 MyClass 仅具有一些基本类型成员，则默认赋值运算符将起作用，但如果它具有一些没有赋值运算符的指针成员和对象，则结果将是不可预测的。因此我们可以说，如果类的析构函数中有需要删除的内容，我们可能需要一个深复制运算符，这意味着我们应该提供一个复制构造函数和赋值运算符。

Answer 5

复制对象是什么意思？
有几种方法可以复制对象 - 让我们谈谈您最有可能提到的两种 - 深复制和浅复制。

由于我们使用面向对象的语言（或者至少假设如此），因此假设您分配了一块内存。由于它是面向对象语言，我们可以轻松引用我们分配的内存块，因为它们通常是原始变量（整数、字符、字节）或我们定义的由我们自己的类型和原语组成的类。假设我们有一个 Car 类，如下所示：

class Car //A very simple class just to demonstrate what these definitions mean.
//It's pseudocode C++/Javaish, I assume strings do not need to be allocated.
{
private String sPrintColor;
private String sModel;
private String sMake;

public changePaint(String newColor)
{
   this.sPrintColor = newColor;
}

public Car(String model, String make, String color) //Constructor
{
   this.sPrintColor = color;
   this.sModel = model;
   this.sMake = make;
}

public ~Car() //Destructor
{
//Because we did not create any custom types, we aren't adding more code.
//Anytime your object goes out of scope / program collects garbage / etc. this guy gets called + all other related destructors.
//Since we did not use anything but strings, we have nothing additional to handle.
//The assumption is being made that the 3 strings will be handled by string's destructor and that it is being called automatically--if this were not the case you would need to do it here.
}

public Car(const Car &other) // Copy Constructor
{
   this.sPrintColor = other.sPrintColor;
   this.sModel = other.sModel;
   this.sMake = other.sMake;
}
public Car &operator =(const Car &other) // Assignment Operator
{
   if(this != &other)
   {
      this.sPrintColor = other.sPrintColor;
      this.sModel = other.sModel;
      this.sMake = other.sMake;
   }
   return *this;
}

}

深层复制是指如果我们声明一个对象，然后创建该对象的完全独立的副本……我们最终会在 2 个完整的内存集中得到 2 个对象。

Car car1 = new Car("mustang", "ford", "red");
Car car2 = car1; //Call the copy constructor
car2.changePaint("green");
//car2 is now green but car1 is still red.

现在让我们做一些奇怪的事情。假设 car2 要么编程错误，要么故意共享 car1 的实际内存。 （这样做通常是错误的，在课堂上通常是讨论它的毯子。）假装每当你询问 car2 时，你实际上正在解析指向 car1 内存空间的指针......这或多或少是浅拷贝是。

//Shallow copy example
//Assume we're in C++ because it's standard behavior is to shallow copy objects if you do not have a constructor written for an operation.
//Now let's assume I do not have any code for the assignment or copy operations like I do above...with those now gone, C++ will use the default.

 Car car1 = new Car("ford", "mustang", "red"); 
 Car car2 = car1; 
 car2.changePaint("green");//car1 is also now green 
 delete car2;/*I get rid of my car which is also really your car...I told C++ to resolve 
 the address of where car2 exists and delete the memory...which is also
 the memory associated with your car.*/
 car1.changePaint("red");/*program will likely crash because this area is
 no longer allocated to the program.*/

因此，无论您使用哪种语言编写，在复制对象时都要非常小心您的含义，因为大多数时候您需要深层复制。

什么是复制构造函数和复制赋值运算符？
我已经在上面使用过它们了。当您键入诸如 Car car2 = car1; 之类的代码时，就会调用复制构造函数。本质上，如果您声明一个变量并在一行中对其进行赋值，那么复制构造函数就会被调用。赋值运算符就是使用等号时发生的情况 - car2 = car1;。请注意 car2 未在同一语句中声明。您为这些操作编写的两段代码可能非常相似。事实上，典型的设计模式有另一个函数，一旦您满意初始副本/分配是合法的，您就可以调用它来设置所有内容 - 如果您查看我编写的普通代码，这些函数几乎是相同的。

我什么时候需要自己申报？
如果您编写的代码不是要共享或以某种方式用于生产，那么您实际上只需要在需要时声明它们。如果您“偶然”选择使用您的程序语言并且没有创建它，那么您确实需要了解您的程序语言的作用，即您获得了编译器默认值。例如，我很少使用复制构造函数，但赋值运算符覆盖非常常见。您知道您也可以覆盖加法、减法等的含义吗？

如何防止我的对象被复制？
重写允许使用私有函数为对象分配内存的所有方式是一个合理的开始。如果您确实不希望人们复制它们，您可以将其公开并通过抛出异常而不复制对象来警告程序员。

Answer 6

我什么时候需要自己声明它们？

三法则规定，如果您声明任何一个

1. 复制构造函数
2. 运算符析构函数
3. 复制赋值

，那么您应该声明所有三个。它源于这样一种观察：接管复制操作的含义的需要几乎总是源于执行某种资源管理的类，并且这几乎总是意味着

• 在一个复制操作中完成任何资源管理可能需要在另一个复制操作中完成，并且

• 类析构函数也将参与对资源的管理。资源（通常是释放它）。要管理的经典资源是内存，这就是为什么所有标准库类
  管理内存（例如，执行动态内存管理的STL容器）都声明“三巨头”：复制操作和析构函数。

三法则的结果是用户声明的析构函数的存在表明简单的成员明智复制不太可能适合类中的复制操作。反过来，这表明如果一个类声明了析构函数，则复制操作可能不应该自动生成，因为它们不会做正确的事情。在采用 C++98 时，这种推理的重要性还没有被充分认识到，因此在 C++98 中，用户声明的析构函数的存在对编译器生成复制操作的意愿没有影响。 C++11 中的情况仍然如此，但这只是因为限制生成复制操作的条件会破坏太多遗留代码。

如何防止我的对象被复制？

声明复制构造函数 &复制赋值运算符作为私有访问说明符。

class MemoryBlock
{
public:

//code here

private:
MemoryBlock(const MemoryBlock& other)
{
   cout<<"copy constructor"<<endl;
}

// Copy assignment operator.
MemoryBlock& operator=(const MemoryBlock& other)
{
 return *this;
}
};

int main()
{
   MemoryBlock a;
   MemoryBlock b(a);
}

在 C++11 中，您还可以声明复制构造函数 &赋值运算符已删除

class MemoryBlock
{
public:
MemoryBlock(const MemoryBlock& other) = delete

// Copy assignment operator.
MemoryBlock& operator=(const MemoryBlock& other) =delete
};


int main()
{
   MemoryBlock a;
   MemoryBlock b(a);
}

Answer 7

许多现有的答案已经涉及复制构造函数、赋值运算符和析构函数。
然而，在 C++11 之后，移动语义的引入可能会将其扩展到 3 之外。

最近 Michael Claisse 做了一个涉及这个主题的演讲：
http://channel9.msdn.com/events /CPP/C-PP-Con-2014/The-Canonical-Class

Answer 8

C++中的三法则是设计和开发的一个基本原则，规定了三个要求：如果下列成员函数之一有明确的定义，那么程序员应该将另外两个成员函数一起定义。即以下三个成员函数缺一不可：析构函数、复制构造函数、复制赋值运算符。

C++中的复制构造函数是一种特殊的构造函数。它用于构建一个新对象，该新对象相当于现有对象的副本。

复制赋值运算符是一种特殊的赋值运算符，通常用于将一个现有对象指定给其他相同类型的对象。

有一些简单的例子：

// default constructor
My_Class a;

// copy constructor
My_Class b(a);

// copy constructor
My_Class c = a;

// copy assignment operator
b = a;