c++ – 什么是三法则?

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

介绍

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)部分感到困惑,则将其称为成员初始化列表。)

特别会员功能

复制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()
{
}

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

在执行析构函数的主体并销毁在主体内分配的任何自动对象之后,类X的析构函数调用X的直接成员的析构函数[n3126.pdf12.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将删除包含数组字符串,因为当你写的x = x,都this->namethat.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已经为您完成了。只需将使用std::string成员的简单代码与使用a 的错综复杂且容易出错的替代方法进行比较char*,您应该确信。只要你远离原始指针成员,三个规则就不太可能涉及你自己的代码。

添加评论

友情链接:蝴蝶教程