c++ - 多重继承类的复制构造函数

Question

考虑这段代码:

#include <vector>
#include <iostream>
using namespace std;

class Base
{
    char _type;
public:
    Base(char type):
        _type(type)
    {}

    ~Base() {
        cout << "Base destructor: " << _type << endl;
    }
};

class uncopyable
{
    protected:
        uncopyable() {}
        ~uncopyable() {}
    private:
        uncopyable( const uncopyable& );
        const uncopyable& operator=( const uncopyable& );
};

class Child : public Base, private uncopyable
{
    int j;
public:
    Child():
        Base('c')
    {}
    ~Child() {
        cout << "Child destructor" << endl;
    }
};


int main()
{
    vector<Base> v;
    Base b('b');
    Child c;

    v.push_back(b);
    v.push_back(c);
    return 0;
}

我系统的输出是:

Base destructor: b
Child destructor
Base destructor: c
Base destructor: b
Base destructor: b
Base destructor: c

我的问题是:

• 为什么 Base(b 类型)的析构函数被调用了三次而不是两次(我们是否有两个以上的对象 b 拷贝)？

• 当我们复制类型为 Child 的对象时会发生什么，考虑到其父对象之一的复制构造函数是私有(private)的。是未定义的行为吗？

• 每当我尝试复制类型为 Child 的对象时，我都以为会遇到编译时错误。我认为 child 的默认复制构造函数会尝试调用 Uncopyable 类的私有(private)复制构造函数并导致编译错误。为什么不报编译错误？

之所以这样设计代码是因为 Child 类很大。

期望的行为是在客户端试图复制 Child 对象时丢弃子数据(调用 Child 的析构函数而不调用 Base 的析构函数)。

这段代码实现了这一点，但我猜它会导致未定义的行为并且有内存泄漏(永远不会为复制的实例调用 Child 的析构函数)。

Answer 1

这是您的代码中发生的事情:

int main() 
{ 
    vector<Base> v;    // 1
    Base b('b');       // 2
    Child c;           // 3

    v.push_back(b);    // 4
    v.push_back(c);    // 5
    return 0; 
}                      // 6

1. 第 1 行:构造 vector v

2. 第 2 行:构造 Base b(调用 Base 的构造函数)

3. 第3行:构造子c(调用Child的构造函数和Base的构造函数)

4. 第 4 行:v 当前处于最大容量，需要调整大小。
   v 为 Base 的 1 个元素分配内存。
   将 Base b 复制到 v[0](调用 Base 的复制构造函数)。

5. 第 5 行:v 再次达到最大容量，需要调整大小。
   内存由 v 分配给 Base 的 2 个元素。
   旧的 v[0] 被复制到新的 v[0] 中(调用 Base 的复制构造函数)。
   旧的 v[0] 被删除(调用 Base 的析构函数(“Base destructor: b”))。
   子 c 被复制到 v[1](调用 Base 的复制构造函数)。

6. 第 6 行:c、b 和 v 超出范围。
   Child c 被删除(调用 Child 的析构函数(“Child destructor”)然后 Base 的析构函数(“Base destructor: c”)。
   Base b 被删除(调用 Base 的析构函数(“Base destructor: b”))。
   Base v[0], v[1]被删除(两次调用Base的析构函数("Base destructor: b", "Base destructor: c"))。

没有内存泄漏 - 对于上述序列中的每个构造函数，都会调用相应的析构函数。

此外，您似乎对复制构造函数很困惑。子 c 作为 Base& 传递给 push_back - 然后按预期调用 Base 的复制构造函数。由于 Base 的隐式复制构造函数不是虚拟的或重写的，因此让 Child 从 uncopyable 派生不会改变这一点。

请注意 vector<Base>永远不能存储 Child 类型的对象；它只知道为 Base 分配足够的内存。将 Child 的实例分配给 Base 时发生的事情称为切片，虽然经常是无意的和误解的，但看起来它可能实际上是您所描述的场景中想要的。