在复制构造函数中复制任何指针成员变量

Question

我有一个 B 类，它的成员是指向 A 类对象的指针。在 A 类型的对象上使用复制构造函数时，它会被复制，但成员变量不会。 有没有办法复制 A 对象并自动复制其 B 成员？ 以下代码显示了我试图解释的问题：

class A
{
public:
    A(char t_name)
    {
        name = t_name;
    }
    ~A()
    {
    }
    char name;
};

class B
{
public:
    A* attribute;

    B()
    {
        attribute = new A('1');
    }
    ~B()
    {}
};


int main()
{
    B* b_variable = new B;
    B* b_copy = new B(*b_variable);
    return 0;
}

Answer 1

在 A 类型的对象上使用复制构造函数时，它会被复制，但成员变量不会。

您的代码从不调用 A 类中的任何复制构造函数。

您的代码在 B 类中调用了一个复制构造函数，它完全按照应有的方式进行操作，即将 attribute 的值复制到 A 类对象的 指针。

换句话说 - 执行代码后，您有两个 B 类实例和一个 A 类实例。在两个 B 类实例中，attribute 指向同一个 A 类实例。

这（很可能）不是你想要的。

正如许多人已经指出的那样（例如，参见@lostbard 的答案），您需要 B 类中的复制构造函数来进行深度复制。需要深拷贝，因为 B 类有一个指针成员。

您还应该在 B 类析构函数和 main 中进行一些清理。

#include <iostream>
using namespace std;

class A
{
public:
    A(char t_name)
    {
        name = t_name;
    }

    ~A()
    {
    }
    char name;
};

class B
{
public:
    A* attribute;

    B()
    {
        attribute = new A('1');
    }

    /** Copy constructor */
    B(const B &copy)
    {
        // Make a new instance of class A
        attribute = new A(*copy.attribute);
    }

    /** Assignment operator */
    B& operator= (const B& other)
    {
        // Delete the existing class A instance
        delete attribute;
        // and create a new as a copy of other.attribute
        attribute = new A(*other.attribute);
    }

    ~B()
    {
        // Delete the class A instance
        delete attribute;
    }
};


int main()
{
    B* b_variable = new B;
    B* b_copy = new B(*b_variable);

    // Delete the two class B instances
    delete b_variable;
    delete b_copy;

    return 0;
}

类 A 中不需要复制构造函数。默认生成的将作为类 A 没有指针成员。

编辑

正如@Slava 所指出的，当你创建一个复制构造函数（三规则）时，你应该始终实现一个赋值运算符，所以我将它添加到上面的代码中。

有些人喜欢三规则是五规则，所以它也包括移动。在这里阅读更多：https://en.wikipedia.org/wiki/Rule_of_three_(C%2B%2B_programming)

Answer 2

虽然有很多解决方案，但我敢打赌，您迟早会实现通常的虚拟a.clone();。当您拥有 A 的派生类时，这将完美无缺（这或多或少是您将 A 作为指向堆分配对象的指针而不是作为值成员的唯一合理原因:)）。

请注意，当您在层次结构中实现 clone() 时，C++ 支持协变指针返回类型。因此，如果 base 有一个返回的 virtual ，例如Clonable*，那么A的同样方法可以返回A*，A的后代ADerived可以返回ADerived*。对于clone() 的情况，请随意将“可以”理解为“应​​该”。

Answer 3

为 A 和 B 创建一个复制构造函数：

class A
{
public:
    A(char t_name)
    {   
    name = t_name;
    }
    A(const A& copy)
    {   
        name = copy.name;
    }
    ~A()
    {
    }
    char name;
};

class B
{
public:
    A* attribute;

    B()
    {
        attribute = new A('1');
    }
    B(const B &copy)
    {
      attribute = new A(*copy.attribute);
    }
    ~B()
    {}
};