Cómo lograr tipos de retorno covariantes al devolver un shared_ptr?

Question

using namespace boost; 

class A {}; 
class B : public A {}; 

class X { 
    virtual shared_ptr<A> foo(); 
}; 

class Y : public X { 
    virtual shared_ptr<B> foo(); 
}; 

Los tipos de devolución no son covariantes (ni son, por lo tanto, legales), pero lo serían si estuviera usando punteros sin procesar. ¿Cuál es el modismo comúnmente aceptado para solucionar este problema, si es que existe?

Answer 1

Creo que una solución es fundamentalmente imposible porque la covarianza depende de la aritmética del puntero que es incompatible con los punteros inteligentes.

Cuando Y::foo devuelve shared_ptr<B> a una persona que llama dinámica, que se tiene que convertir shared_ptr<A> antes de su uso. En su caso, un B* puede (probablemente) simplemente reinterpretarse como A*, pero para la herencia múltiple, necesitaría algo de magia para decirle a C++ sobre static_cast<A*>(shared_ptr<B>::get()).

Answer 2

No directamente, pero puede falsificarlo haciendo que las funciones virtuales reales sean inaccesibles desde fuera de la clase y envolviendo la llamada de función virtual en una función no virtual. Lo malo es que tendrá que recordar implementar esta función de contenedor en cada clase derivada. Pero podría evitar esto colocando tanto la declaración de la función virtul como la envoltura en la macro.

using namespace boost; // for shared_ptr, make_shared and static_pointer_cast. 

// "Fake" implementation of the clone() function. 
#define CLONE(MyType) \ 
    shared_ptr<MyType> clone() \ 
    { \ 
     shared_ptr<Base> res = clone_impl(); \ 
     assert(dynamic_cast<MyType*>(res.get()) != 0); \ 
     return static_pointer_cast<MyType>(res); \ 
    } 

class Base 
{ 
protected: 
    // The actual implementation of the clone() function. 
    virtual shared_ptr<Base> clone_impl() { return make_shared<Base>(*this); } 

public: 
    // non-virtual shared_ptr<Base> clone(); 
    CLONE(Base) 
}; 

class Derived : public Base 
{ 
protected: 
    virtual shared_ptr<Base> clone_impl() { return make_shared<Derived>(*this); } 

public: 
    // non-virtual shared_ptr<Derived> clone(); 
    CLONE(Derived) 
}; 


int main() 
{ 
    shared_ptr<Derived> p = make_shared<Derived>(); 
    shared_ptr<Derived> clone = p->clone(); 

    return 0; 
} 

Answer 3

Acabo de devolver un puntero desnudo y envolverlo inmediatamente en el puntero compartido.