60

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

class Foo {
  Bar bar;
};

class Bar {
  int i;
  Baz baz;
};

class Baz {
  int j;
};

现在，如果我这样做：

Foo f1;
Foo f2(f1);

默认的复制构造函数会做什么？编译器生成的复制构造函数 in 会Foo调用编译器生成的构造函数 inBar进行复制bar，然后将调用编译器生成的复制构造函数 inBaz吗？

4

5 回答 5

83 
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 个版本）
  • 构造函数（副本）
  • 析构函数（默认）
  • 赋值运算符

构造函数：默认值：

实际上有两个默认构造函数。
一个用于，zero-initialization另一个用于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
  • 如果声明了任何构造函数（包括副本），则编译器不会实现默认构造函数。
  • 如果声明了复制构造函数，那么编译器将不会生成一个。
  • 如果声明了赋值运算符，那么编译器将不会生成一个。
  • 如果声明了析构函数，编译器将不会生成析构函数。

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

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)
{}
于 2009-11-27T19:26:20.707 回答
13

除非您自己声明（注意：不定义） ，否则编译器会提供一个复制构造函数。编译器生成的复制构造函数只是调用类（和每个基类）每个成员的复制构造函数。

赋值运算符和析构函数 BTW 也是如此。但是，默认构造函数有所不同：仅当您自己未声明任何其他构造函数时，编译器才会提供默认构造函数。

于 2009-11-27T18:45:08.417 回答
2

是的，编译器生成的复制构造函数按成员在包含类中声明的顺序执行逐个复制。如果任何成员类型本身不提供复制构造函数，则无法生成包含类的可能的复制构造函数。如果您可以决定采用某种适当的方法来初始化无法复制构造的成员的值——也许通过使用它的其他构造函数之一，则仍然可以手动编写一个。

于 2009-11-27T18:47:04.387 回答
1

C++默认拷贝构造函数创建一个浅拷贝。浅拷贝不会创建原始对象可能引用的对象的新副本；旧对象和新对象将只包含指向同一内存位置的不同指针。

于 2009-11-27T18:58:32.790 回答
0

编译器将为您生成所需的构造函数。

但是，一旦您自己定义了复制构造函数，编译器就会放弃为该类生成任何内容，并且如果您没有定义适当的构造函数，则会给出错误。

使用您的示例：

class Baz {
    Baz(const Baz& b) {}
    int j;
};
class Bar {
    int i;
    Baz baz;
};
class Foo {
    Bar bar;
};

尝试默认实例化或复制构造 Foo 将引发错误，因为 Baz 不可复制构造并且编译器无法为 Foo 生成默认和复制构造函数。

于 2009-11-27T18:47:24.077 回答