Cómo hacer un método clon usando shared_ptr y heredando de enable_shared_from_this

Question

que he visto que una forma útil para escribir un método que devuelve un clon de impulso :: shared_ptr es hacer

class A 
{ 
public: 
    shared_ptr<A> Clone() const 
    { 
    return(shared_ptr<A>(CloneImpl())); 
    } 
protected: 
    virtual A* CloneImpl() const 
    { 
    return(new A(*this)); 
    } 
}; 

class B : public A 
{ 
public: 
    shared_ptr<B> Clone() const 
    { 
    return(shared_ptr<B>(CloneImpl())); 
    } 
protected: 
    virtual B* CloneImpl() const 
    { 
    return(new B(*this)); 
    } 
}; 

Esto permite el uso de covarianza con el puntero regular sin dejar de envolverlo en la seguridad de un puntero inteligente. Mi problema es que mi clase B necesita heredar de boost :: enable_shared_from_this porque justo después de la construcción necesita registrarse en una clase separada, pasando un puntero compartido a sí mismo. Tengo un método Create que envuelve la construcción y el registro para garantizar que siempre ocurran juntos. La implementación del método de clonación anterior no puede manejar este requisito, sin embargo. El registro no puede ocurrir en CloneImpl ya que todavía no existe shared_ptr que "posee" el objeto, impidiendo una llamada a shared_from_this(), y si esta lógica no está en la función virtual, shared_ptr apunta a B, no sabe acerca de las necesidades de registro de B cuando es clonado ¿Cuál es la mejor manera de manejar este problema?

Answer 1

Puesto que ya está implementando la pública interfaz de covarianza a sí mismo a través de las no virtuales Clone() funciones, se puede considerar el abandono de la covarianza para los CloneImpl() funciones.

Si sólo necesita shared_ptr y nunca el puntero del crudo, por lo que entonces podría hacer:

class X 
{ 
public: 
    shared_ptr<X> Clone() const 
    { 
    return CloneImpl(); 
    } 
private: 
    virtual shared_ptr<X> CloneImpl() const 
    { 
    return(shared_ptr<X>(new X(*this))); 
    } 
}; 

class Y : public X 
{ 
public: 
    shared_ptr<Y> Clone() const 
    { 
    return(static_pointer_cast<Y, X>(CloneImpl())); // no need for dynamic_pointer_cast 
    } 
private: 
    virtual shared_ptr<X> CloneImpl() const 
    { 
    return shared_ptr<Y>(new Y(*this)); 
    } 
}; 

CloneImpl() siempre se obtendrá una shared_ptr<Base> y ahora usted puede registrar su objeto dentro de la función B::CloneImpl() y devolver el shared_ptr Registerd .