Wie implementiere ich Polymorphie mit std :: shared_ptr?

Question

Ich habe einige der anderen Fragen zu diesem Thema gesehen, aber haben noch nicht gefunden die Antwort - ich glaube, ich bin etwas fehlt:

ich zwei einfache Testklassen definiert:

class TestBase 
{ 

    public: 

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

    protected: 

    inline virtual int getInt () 
    { 
     return 0; 
    } 

}; 

class TestDerived : public TestBase 
{ 

    protected: 

    inline int getInt () override 
    { 
     return 1; 
    } 

}; 

ich erklärte typedefs ihre Nutzung mit std::shared_ptr:

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

Problem zu vereinfachen: ich kann nicht Code kompilieren können diese shared_ptr Erklärungen verwenden polymorphi nisch, obwohl base in all diesen Fällen ist tatsächlich eine Instanz von 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

ich mit der Standard-GCC-Toolkette C++ 11 auf eine Ubuntu 14.04 Box bin mit. Compiler ist gcc-4.9. Was mache ich falsch? Kann ein shared_pointer nicht polymorph verwendet werden?

Answer 1

A-Typ übergeben std::static_pointer_cast und std::dynamic_pointer_cast als die erste Art Template-Argument ist die Art der den Typ des umgewandelten Zeiger selbst, nicht der Smart Zeigertyp:

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); 

Mit dieser sagte, Sie könnten nennen sie es wie folgt:

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);