C++：深拷贝一个基类指针

Question

我周围搜索和似乎为了执行此操作我需要更改我的基类，并想知道这是否是最好的方法。 例如， 我有一个基类：

class Base {} 

然后长线派生类：

class Derived_1:: public Base {} 
class Derived_2:: public Derived_1{} 
... 
... 
class Derived_n:: public Derived_M{} 

然后我有另一个类：

class DeepCopy 
{ 
    Base * basePtr; 

    public: 
    DeepCopy(DeepCopy & dc) {} 
} 

假设基地类和Derived_x类拷贝构造函数都被正确编码，那么为DeepCopy编写拷贝构造函数的最佳方法是什么？我们如何知道我们要复制的对象的basePtr中的类？

我能想到的唯一方法就是使用RTTI，但是使用一长串dynamic_casts似乎并不正确。此外，它需要DeepCopy了解Base类的继承层次结构。

我看到的另一种方法是here。但它需要Base和Derived类实现一个克隆方法。

那么有没有一个更容易，标准的做法呢？

Answer 1

您需要使用虚拟副本模式：

struct base { 
    virtual ~base() {}    // Remember to provide a virtual destructor 
    virtual base* clone() const = 0; 
}; 
struct derived : base { 
    virtual derived* clone() const { 
     return new derived(*this); 
    } 
}; 

然后DeepCopy对象只需要调用：在做副本，然后跨层次实现它的界面提供了一个虚拟函数功能：

class DeepCopy 
{ 
    Base * basePtr;  
public: 
    DeepCopy(DeepCopy const & dc)   // This should be `const` 
     : basePtr(dc.basePtr->clone()) 
    {} 
}; 

Answer 2

我认为模板是在这种情况下，以最好的一段路要走：

template<typename Sub> 
class DeepCopy 
{ 
    Base *base; 

    DeepCopy(Sub *sub) 
    { 
     base = new Sub(*sub); // use copy constructor 
    } 
} 

这确实意味着DeepCopy是不可分配的，但这是您用C++支付的价格。

Answer 3

使用采用clone()函数的方法是一个很好的解决方案。注意使用CRTP (the curiously recurring template pattern)可以为您节省一些工作。你这样做的方式是引入一个中间级别（以下称为BaseCRTP），它是一个模板并实现clone()函数。当您派生实际的类时，将它们用作它们派生自的基础的模板参数。他们将自动获得为他们实现的clone()函数。确保派生类实现一个拷贝构造函数（或者确保默认是你需要的）。

/* Base class includes pure virtual clone function */ 
class Base { 
public: 
    virtual ~Base() {} 
    virtual Base *clone() const = 0; 
}; 

/* Intermediate class that implements CRTP. Use this 
* as a base class for any derived class that you want 
* to have a clone function. 
*/ 
template <typename Derived> 
class BaseCRTP : public Base { 
public: 
    virtual Base *clone() const { 
     return new Derived(static_cast<Derived const&>(*this)); 
    } 
}; 

/* Derive further classes. Each of them must 
* implement a correct copy constructor, because 
* that is used by the clone() function automatically. 
*/ 
class Derived1 : public BaseCRTP<Derived1> { 
    /*... should have an ordinary copy constructor... */ 
}; 

class Derived2 : public BaseCRTP<Derived2> { 
    /*... should have an ordinary copy constructor... */ 
}; 

然后可以明显地实现DeepCopy类以通常的方式：

class DeepCopy 
{ 
    Base *basePtr;  
public: 
    DeepCopy(const DeepCopy &dc) 
    : basePtr(dc.basePtr->clone()) 
    {} 
};