题 什么是三法则?


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

1844
2017-11-13 13:27


起源


请 读 整个线程 和 该 c++-faq 标签维基 在你投票结束之前。 - sbi
@Binary:至少花点时间阅读评论讨论 之前 你投了一票。以前的文本要简单得多,但弗雷德被要求扩展它。此外,虽然这是四个问题 语法,这只是一个问题,有几个方面。 (如果您不同意,那么通过单独回答每个问题来证明您的POV,让我们对结果进行投票。) - sbi
Fred,这是关于C ++ 1x的答案的一个有趣的补充: stackoverflow.com/questions/4782757/...。我们如何处理这个问题? - sbi
有关: 大二法则 - Nemanja Trifunovic
请记住,从C ++ 11开始,我认为这已经升级到五级规则,或类似的东西。 - paxdiablo


答案:


介绍

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) 部分, 这叫做a 成员初始化列表。)

特别会员功能

复制一个是什么意思 person 目的? 该 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.pdf12.4§6]

管理资源

那么我们何时应该明确声明这些特殊成员函数? 当我们上课 管理资源, 那是, 当一个对象是 主管 对于那个资源。 这通常意味着资源 后天 在构造函数中 (或传递给构造函数)和 发布 在析构函数中。

让我们回到预标准C ++。 没有这样的事情 std::string和程序员爱上了指针。 该 person class可能看起来像这样:

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 会删除包含的数组 资源 串, 因为你写的时候 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 ++ 0x):

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

三个规则

有时您需要实现一个管理资源的类。 (永远不要在一个班级管理多个资源, 这只会导致痛苦。) 在那种情况下,请记住 三个规则

如果需要显式声明析构函数,   自己复制构造函数或复制赋值运算符,   你可能需要明确声明它们中的所有三个。

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

忠告

大多数情况下,您不需要自己管理资源, 因为现有的类如 std::string 已经为你做了。 只需使用a比较简单代码 std::string 会员 使用a进行复杂且容易出错的替代方案 char* 你应该相信。 只要你远离原始指针成员,三个规则就不太可能涉及你自己的代码。


1517
2017-11-13 13:27



弗雷德,如果(A)你不会在可复制代码中拼写错误实现的作业,并添加一个说明错误并在精美图纸中寻找其他地方的说明,我会对我的投票感觉更好。要么在代码中使用c&s,要么只是跳过实现所有这些成员(B)你会缩短上半部分,这与RoT没什么关系; (C)您将讨论移动语义的介绍以及这对RoT意味着什么。 - sbi
但是我觉得这个帖子应该是C / W。我喜欢你保持条款大致准确(即你说“复制 赋值运算符“,并且您没有使用分配不能暗示副本的公共陷阱”。 - Johannes Schaub - litb
@Prasoon:我不认为裁掉一半的答案会被视为非CW答案的“公平编辑”。 - sbi
此外,我可能已经覆盖了它,但您没有提到复制分配操作员应该在执行任何操作之前检查身份。 - Björn Pollex
如果你更新你的C ++ 11的帖子(即移动构造函数/赋值)会很棒 - Alexander Malakhov


三规则 对C ++来说是一个经验法则,基本上是说

如果你的班级需要任何一个

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

明确地定义,然后它可能需要 他们三个

原因是它们中的所有三个通常用于管理资源,如果您的类管理资源,它通常需要管理复制和释放。

如果复制您的类所管理的资源没有良好的语义,那么请考虑通过声明来禁止复制(不是 确定)复制构造函数和赋值运算符为 private

(请注意,即将推出的新版本的C ++标准(即C ++ 11)将移动语义添加到C ++中,这可能会改变规则三。但是,我对编写C ++ 11部分知之甚少关于三规则。)


451
2017-11-13 14:22



防止复制的另一个解决方案是从一个无法复制的类(私有)继承(私有) boost::noncopyable)。它也可以更清晰。我认为C ++ 0x和“删除”函数的可能性在这里有所帮助,但忘记了语法:/ - Matthieu M.
@Matthieu:是的,这也有效。但除非 noncopyable 是std lib的一部分,我不认为它有很大改进。 (哦,如果你忘了删除语法,你就忘了我曾经认识的mor ethan。 :)) - sbi
有关Rule of Three和C ++ 1x的任何更新? - Daan Timmer
@Daan:看 这个答案。但是,我建议坚持 Martinho的 零规则。对我而言,这是过去十年中C ++最重要的经验法则之一。 - sbi
Martinho的Zero of Zero现已定位 这里 - Diego


三巨头的法则如上所述。

一个简单的例子,用简单的英语,它解决了一个问题:

非默认析构函数

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

你可能认为这是完成的工作。

问题是,如果复制了对象,则复制将指向与原始对象相同的内存。

有一次,其中一个删除了它的析构函数中的内存,另一个将有一个指向无效内存的指针(这称为悬空指针)当它试图使用它时会发生毛茸茸的事情。

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

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

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

这意味着新对象和旧对象将指向同一块内存,因此当您在一个对象中更改它时,它也将被更改为另一个对象。如果一个对象删除了这个内存,另一个对象将继续尝试使用它 - eek。

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


134
2018-05-14 14:22



因此,如果我们使用复制构造函数,那么副本就完全在不同的内存位置,如果我们不使用复制构造函数,则复制,但它指向相同的内存位置。你想说的是什么?因此,没有复制构造函数的副本意味着新指针将存在但指向相同的内存位置,但是如果我们有用户显式定义的复制构造函数,那么我们将有一个指向不同内存位置但具有数据的单独指针。 - Unbreakable
对不起,我回答这个很久以前,但我的回复似乎仍然不在这里:-(基本上,是的 - 你得到它:-) - Stefan
该原则如何扩展到复制赋值运算符?如果提到三级规则中的第三个,这个答案会更有用。 - DBedrenko
@DBedrenko,“你编写了一个复制构造函数,以便它为自己的内存分配新对象......”这与扩展到复制赋值运算符的原理相同。你不觉得我说得那么清楚吗? - Stefan
@Stefan是的,非常感谢! - DBedrenko


基本上,如果你有一个析构函数(不是默认的析构函数),这意味着你定义的类有一些内存分配。假设该类在某些客户端代码之外或由您使用。

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

如果MyClass只有一些原始类型成员,则默认赋值运算符可以工作,但如果它有一些指针成员和没有赋值运算符的对象,则结果将是不可预测的。因此我们可以说如果在类的析构函数中有删除的东西,我们可能需要一个深层复制操作符,这意味着我们应该提供一个复制构造函数和赋值操作符。


37
2017-12-31 19:29





复制对象意味着什么? 有几种方法可以复制对象 - 让我们来谈谈你最有可能提到的两种 - 深拷贝和浅拷贝。

因为我们是面向对象的语言(或者至少是假设的),所以假设你分配了一块内存。由于它是一种OO语言,我们可以很容易地引用我们分配的内存块,因为它们通常是原始变量(整数,字符,字节)或我们定义的由我们自己的类型和基元组成的类。所以我们假设我们有一类汽车如下:

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 未在同一声明中声明。您为这些操作编写的两个代码块可能非常相似。事实上,典型的设计模式还有另一个函数,一旦你满意初始复制/赋值是合法的,你可以调用它来设置所有东西 - 如果你看一下我写的长手代码,函数几乎是相同的。

我什么时候需要自己申报? 如果您不是以某种方式编写要共享或生产的代码,则实际上只需要在需要时声明它们。如果你选择“偶然”使用它并且没有制作程序语言,你需要知道你的程序语言会做什么 - 即。你得到编译器默认值。我很少使用复制构造函数,但赋值运算符覆盖非常常见。你知道吗你可以覆盖加法,减法等意思吗?

如何防止复制对象? 覆盖允许使用私有函数为对象分配内存的所有方法都是一个合理的开端。如果你真的不希望有人复制它们,你可以将它公开,并通过抛出异常并且不复制对象来提醒程序员。


27
2017-10-17 16:37



这个问题被标记为C ++。这个伪代码阐述几乎没有澄清关于明确定义的“三个规则”的任何内容,并且只是在最坏的情况下散布混乱。 - sehe


我什么时候需要自己申报?

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

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

19
2018-01-12 09:54





许多现有的答案已经触及了复制构造函数,赋值运算符和析构函数。 但是,在后C ++ 11中,移动语义的引入可能会扩展到3以上。

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


9
2018-01-07 05:38





C ++中的三条规则是设计和开发三个要求的基本原则,如果在下面的一个成员函数中有明确的定义,那么程序员应该将另外两个成员函数一起定义。即以下三个成员函数是必不可少的:析构函数,复制构造函数,复制赋值运算符。

C ++中的复制构造函数是一个特殊的构造函数。它用于构建新对象,该对象是与现有对象的副本等效的新对象。

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

有一些简单的例子:

// default constructor
My_Class a;

// copy constructor
My_Class b(a);

// copy constructor
My_Class c = a;

// copy assignment operator
b = a;

5
2017-08-12 04:27



嗨,你的答案没有添加任何新内容。其他人更深入地涵盖了主题,更准确地说 - 你的答案是近似的,实际上在某些地方是错误的(即这里没有“必须”;它“很可能应该”)。在对已经彻底回答的问题发布此类答案时,真的不值得。除非你有新的东西要添加。 - Mat
还有 四 快速的例子,是 不知何故 相关 二 的 三 三法则正在谈论。混乱太多了。 - anatolyg