包含其他对象的类的 C++ 隐式复制构造函数

Question

我知道，如果您自己不实现，编译器有时会提供默认的复制构造函数。我对这个构造函数到底做了什么感到困惑。如果我有一个包含其他对象的类，这些对象都没有声明的复制构造函数，那么行为会是什么？比如这样一个类:

class Foo {
  Bar bar;
};

class Bar {
  int i;
  Baz baz;
};

class Baz {
  int j;
};

现在如果我这样做:

Foo f1;
Foo f2(f1);

默认的复制构造函数会做什么？ Foo 中的编译器生成的复制构造函数会调用 Bar 中的编译器生成的构造函数来复制 bar，然后它将调用编译器-在 Baz 中生成了复制构造函数？

Answer 1

Foo f1;
Foo f2(f1);

是的，这将达到您的预期:
调用了 f2 复制构造函数 Foo::Foo(Foo const&)。
此拷贝构造其基类，然后构造每个成员(递归)

如果你这样定义一个类:

class X: public Y
{
    private:
        int     m_a;
        char*   m_b;
        Z       m_c;
};

以下方法将由您的编译器定义。

• 构造函数(默认)(2 个版本)
• 构造函数(拷贝)
• 析构函数(默认)
• 赋值运算符

构造函数:默认值:

实际上有两个默认构造函数。
一个用于零初始化，另一个用于value-initialization。使用取决于你在初始化时是否使用()。

// Zero-Initialization compiler generated constructor
X::X()
    :Y()                // Calls the base constructor
                        //     If this is compiler generated use 
                        //     the `Zero-Initialization version'
    ,m_a(0)             // Default construction of basic PODS zeros them
    ,m_b(0)             // 
    m_c()               // Calls the default constructor of Z
                        //     If this is compiler generated use 
                        //     the `Zero-Initialization version'
{
}

// Value-Initialization compiler generated constructor
X::X()
    :Y()                // Calls the base constructor
                        //     If this is compiler generated use 
                        //     the `Value-Initialization version'
    //,m_a()            // Default construction of basic PODS does nothing
    //,m_b()            // The values are un-initialized.
    m_c()               // Calls the default constructor of Z
                        //     If this is compiler generated use 
                        //     the `Value-Initialization version'
{
}

注意:如果基类或任何成员没有有效的可见默认构造函数，则无法生成默认构造函数。这不是错误，除非您的代码尝试使用默认构造函数(然后只是编译时错误)。

构造函数(拷贝)

X::X(X const& copy)
    :Y(copy)            // Calls the base copy constructor
    ,m_a(copy.m_a)      // Calls each members copy constructor
    ,m_b(copy.m_b)
    ,m_c(copy.m_c)
{}

注意:如果基类或任何成员没有有效的可见复制构造函数，则无法生成复制构造函数。这不是错误，除非您的代码尝试使用复制构造函数(然后只是编译时错误)。

赋值运算符

X& operator=(X const& copy)
{
    Y::operator=(copy); // Calls the base assignment operator
    m_a = copy.m_a;     // Calls each members assignment operator
    m_b = copy.m_b;
    m_c = copy.m_c;

    return *this;
}

注意:如果基类或任何成员没有有效的可行赋值运算符，则无法生成赋值运算符。这不是错误，除非您的代码尝试使用赋值运算符(然后只是编译时错误)。

析构函数

X::~X()
{
                        // First runs the destructor code
}
    // This is psudo code.
    // But the equiv of this code happens in every destructor
    m_c.~Z();           // Calls the destructor for each member
    // m_b              // PODs and pointers destructors do nothing
    // m_a          
    ~Y();               // Call the base class destructor

• 如果声明了 any 构造函数(包括拷贝)，则编译器不会实现默认构造函数。
• 如果声明了复制构造函数，那么编译器将不会生成一个。
• 如果声明了赋值运算符，那么编译器将不会生成一个。
• 如果声明了析构函数，编译器将不会生成析构函数。

查看您的代码会生成以下复制构造函数:

Foo::Foo(Foo const& copy)
    :bar(copy.bar)
{}

Bar::Bar(Bar const& copy)
    :i(copy.i)
    ,baz(copy.baz)
{}

Baz::Baz(Baz const& copy)
    :j(copy.j)
{}