Come eseguire tipi di ritorno covarianti quando si restituisce un parametro 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(); 
}; 

I tipi di ritorno non sono covarianti (e non sono, quindi, legali), ma lo sarebbero se usassi invece dei puntatori grezzi. Qual è l'idioma comunemente accettato per aggirare questo, se ce n'è uno?

Answer 1

Penso che una soluzione sia fondamentalmente impossibile perché la covarianza dipende dall'aritmetica del puntatore che è incompatibile con i puntatori intelligenti.

Quando Y::foo restituisce shared_ptr<B> in un chiamante dinamico, è necessario eseguire il cast su shared_ptr<A> prima dell'utilizzo. Nel tuo caso, un B* può (probabilmente) essere semplicemente reinterpretato come A*, ma per l'ereditarietà multipla, è necessario un po 'di magia per dire a C++ su static_cast<A*>(shared_ptr<B>::get()).

Answer 2

Non direttamente, ma è possibile simularlo rendendo le funzioni virtuali effettive inaccessibili dall'esterno della classe e avvolgendo la chiamata di funzione virtuale in una funzione non virtuale. Il rovescio della medaglia è che dovrete ricordare di implementare questa funzione wrapper su ogni classe derivata. Ma potresti aggirare questo mettendo sia la dichiarazione della funzione virtul che il wrapper nella 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

Ho appena restituito un puntatore nudo e lo avvolgo immediatamente nel puntatore condiviso.