Come implementare il polimorfismo con std :: shared_ptr?

Question

ho visto alcune delle altre domande su questo argomento, ma non hanno ancora trovato la risposta - Credo che mi manca qualcosa:

Ho definito due semplici classi di test:

class TestBase 
{ 

    public: 

    TestBase () { }; 
    ~ TestBase () { }; 

    protected: 

    inline virtual int getInt () 
    { 
     return 0; 
    } 

}; 

class TestDerived : public TestBase 
{ 

    protected: 

    inline int getInt () override 
    { 
     return 1; 
    } 

}; 

ho dichiarato typedef per semplificare il loro utilizzo con std::shared_ptr:

typedef std::shared_ptr<TestBase> spBase; 
typedef std::shared_ptr<TestDerived> spDerived; 

Problema: non riesco a compilare il codice per utilizzare questi shared_ptr dichiarazioni polymorphi Cally, anche se base in tutti questi casi è in realtà un esempio di spDerived:

spBase base; 
spDerived derived = static_cast <spDerived> (base); 

error: no matching function for call to ‘std::shared_ptr::shared_ptr(spBase&)

spDerived derived = dynamic_cast <spDerived> (base); 

error: cannot dynamic_cast ‘base’ (of type ‘spBase {aka class std::shared_ptr}’) to type ‘spDerived {aka class std::shared_ptr}’ (target is not pointer or reference)

spDerived derived = static_pointer_cast <spDerived> (base); 

error: conversion from ‘std::shared_ptr >’ to non-scalar type ‘spDerived {aka std::shared_ptr}’ requested

spDerived derived = dynamic_pointer_cast <spDerived> (base); 

error: conversion from ‘std::shared_ptr >’ to non-scalar type ‘spDerived {aka std::shared_ptr}’ requested

sto usando C++ 11 su una casella di Ubuntu 14.04 con la catena strumento di GCC di default. Il compilatore è gcc-4.9. Cosa sto sbagliando? Non è possibile utilizzare un parametro shared_pointer in modo polimorfico?

Answer 1

Un tipo passata a std::static_pointer_cast e std::dynamic_pointer_cast come primo argomento tipo di modello è il tipo di per sé il tipo di puntatore convertito, non dello intelligente tipo puntatore:

static_pointer_cast<T>(arg); 
       .~~~^ 
       v 
template <class T, class U> 
      .~~~~^ 
      v 
shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r); 


dynamic_pointer_cast<T>(arg); 
       .~~~~^ 
       v 
template <class T, class U> 
      .~~~~^ 
      v 
shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r); 

Detto questo, si potrebbe lo chiamano come di seguito:

spBase base = std::make_shared<TestDerived>(); 
spDerived derived = std::dynamic_pointer_cast<spDerived::element_type>(base); 
// or: 
spDerived derived2 = std::dynamic_pointer_cast<TestDerived>(base);