复制 C++ 抽象类

Question

好的，这里有一些代码。

#include <iostream>
#include <deque>
using namespace std;
class A
{
public:
    virtual void Execute()
    {
        cout << "Hello from class A" << endl;
    }
};
class B: public A
{
public:
    void Execute()
    {
        cout << "Hello from class B" << endl;
    }
};
void Main()
{
    deque<A *> aclasses = deque<A*>(0);
    deque<A *> aclasses2 = deque<A*>(0);
    A a1 = A();
    B b1 = B();
    aclasses.push_back(&a1);
    aclasses.push_back(&b1);
    aclasses[0]->Execute();
    aclasses[1]->Execute();

    //Now say I want to copy a class from aclasses to aclasses2
    //while perserving it's identity and making it a seperate entity, without
    //knowing the exact type it is.

    aclasses2.push_back(new A(*aclasses[0]));
    aclasses2.push_back(new A(*aclasses[1]));
    //Now my problem show itself
    for each(A * a in aclasses2)
        a->Execute();
    //Execute is called from the original class A both times.

}

现在你可能会说，为什么不把第一个双端队列的指针放到第二个双端队列中呢？虽然我可以，但我需要数据是独立的。基本上我希望能够从第一个双端队列中克隆项目，同时保留那里的身份并给他们自己的数据。

现在是修改后的版本

#include <iostream>
#include <deque>
using namespace std;
class A
{
public:
    virtual void Execute()
    {
        cout << "Hello from class A" << endl;
    }
    virtual ~A() {}             // don't forget the virtual destructor
    virtual A* clone() const {
       return new A(*this);
    }
};
class B: public A
{
public:
    void Execute()
    {
        cout << "Hello from class B" << endl;
    }
    virtual B* clone() {     // return type is co-variant
       return new B( *this );
    }
};
void MainRUNNER()
{
    deque<A *> aclasses = deque<A*>(0);
    deque<A *> aclasses2 = deque<A*>(0);
    A a1 = A();
    B b1 = B();
    aclasses.push_back(&a1);
    aclasses.push_back(&b1);
    aclasses[0]->Execute();
    aclasses[1]->Execute();

    //Now say I want to copy a class from aclasses to aclasses2
    //while perserving it's identity and making it a seperate entity, without
    //knowing the exact type it is.

    aclasses2.push_back(aclasses[0]->clone());
    aclasses2.push_back(aclasses[1]->clone());
    //Now my problem show itself
    for each(A * a in aclasses2)
        a->Execute();
    //Execute is called from the original class A both times.
}

Answer 1

处理的常见模式是通过基类中的虚拟clone() 方法来创建适当类型的新对象：

struct base {
    virtual ~base() {}             // don't forget the virtual destructor
    virtual base* clone() const { 
       return new base(*this); 
    }
};
struct derived : base {
    virtual derived* clone() const {     // return type is co-variant
       return new derived( *this );
    }
};
int main() {
   std::auto_ptr<base> b1( new derived );
   std::auto_ptr<base> b2( b1->clone() ); // will create a derived object
}

Answer 2

您需要提供一个虚拟复制构造函数——通常这是一个名为clone的方法——它在每个类中被重写以返回正确的类型：

class A {
    virtual A* clone() {
        return new A();
    }
};

class B : public A {
    void A* clone() {
        return new B();
    }
};

为了复制整个状态，这些方法当然可以任意复杂。

当然，这会泄漏相当多的内存。使用适当的智能指针而不是原始指针（例如，std::shared_ptr 如果您的编译器支持，boost::shared_ptr 否则）。

Answer 3

你在下面有new A(...)。调用的是A 的复制构造函数（由编译器隐式创建。

你想要的是一个clone 方法。见here。它概括了优秀的C++ Coding Standards 书中的适当项目。下面是最终解决方案的无耻副本，它还显示了很好地使用NVI idiom 来避免slicing 问题。

class A {// …
public:
  A* Clone() const {                        // nonvirtual
    A* p = DoClone();
    assert( typeid(*p) == typeid(*this) && "DoClone incorrectly overridden" );
    return p;                                // check DoClone's returned type
  }

protected:
 A( const A& );
 virtual A* DoClone() const = 0;
};

class B : public A { // …
public:
  virtual B* Clone() const {return new B(*this); }

protected:
  B( const B& rhs ) : A( rhs ) {/* … */}
};

---

更新 一点解释。克隆的基本思想与这里的其他优秀答案相同。

现在，克隆有切割对象的危险。例如，如果派生自 A 的某个对象忘记实现自己的 clone 方法，则对 A* a = d->clone() 的调用将不会返回完整的 D 对象（假设 D 是 A 的后代)

NVI 习语说将公共接口与虚拟接口分开。因此，在此示例中，clone 是 public，但不是 virtual。它调用protected virtual 方法doClone，它执行实际的克隆，以及派生对象也实现。因为拆分，clone方法可以验证克隆对象的类型是否与原始对象的类型匹配。

Answer 4

我认为您将 classes 与 objects 混淆了，即这些类的实例。

您的容器aclasses 存储指针 到现有 对象。您可以将同一个指针在许多不同的容器中多次推送，这不称为克隆。