6

考虑这段代码：

#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）的析构函数被调用了 3 次而不是 2 次（我们是否有超过两个对象 b 的副本）？

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

  • 每当我尝试复制类型的对象时，我都希望得到一个编译时错误Child。我以为孩子的默认复制构造函数会尝试调用 Uncopyable 类的私有复制构造函数并导致编译错误。为什么它不给出编译错误？

以这种方式设计代码的原因是因为Child类很大。

Child所需的行为是每当客户端尝试复制对象时丢弃子数据（调用析构函数Child而不调用析构函数Base）。

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

4

3 回答 3

9

这是您的代码中发生的情况：

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 行：向量 v 构造

  2. 第 2 行：Base b 构造（调用 Base 的构造函数）

  3. 第 3 行：Child 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 超出范围。
    子 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”））。

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

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

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

于 2012-05-19T02:10:45.470 回答
3

每当我尝试复制 Child 类型的对象时，我都希望得到一个编译时错误。

您不是在复制Child对象。当你放入Child cavector<Base>时，只有Base被复制的。它与执行基本相同b = c;。如果你复制/分配Child你会得到一个错误。

Child d = c;  // compile error

默认复制构造函数将调用任何基类和成员对象的复制构造函数，并对基元和指针进行按位复制。

于 2012-05-19T01:21:29.870 回答
0

编辑：答案是错误的..目前正在编辑以做出更好的回应。

为什么 Base（类型 b）的析构函数被调用了三次而不是两次（我们是否有两个以上的对象 b 副本）？

很可能是 Vector 正在制作b. 向量经常这样做。

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

不会。C 的复制构造函数会调用基类的复制构造函数。因此，如果基类复制构造函数是私有的，它将无法编译。

每当我尝试复制 Child 类型的对象时，我都需要得到一个编译时错误，同时允许复制基类对象。最好的方法是什么？

像这样为 Child 声明一个私有复制构造函数：

private:
    Child(const Child& a) {
        throw "cannot make a copy";
    }

每当客户端尝试复制 Child 对象（调用 Child 的析构函数而不调用 Base 的析构函数）时，所需的行为就是丢弃子数据。

不明白你的意思。复制构造函数意味着创建一个新对象。您不能对（旧）对象进行操作。

于 2012-05-19T00:51:50.333 回答