Jak zaimplementować polimorfizm za pomocą std :: shared_ptr?

Question

Widziałem kilka innych pytań na ten temat, ale nadal nie znalazłem odpowiedzi - Chyba jestem czegoś brakuje:

zdefiniowałem dwa proste zajęcia testowe:

class TestBase 
{ 

    public: 

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

    protected: 

    inline virtual int getInt () 
    { 
     return 0; 
    } 

}; 

class TestDerived : public TestBase 
{ 

    protected: 

    inline int getInt () override 
    { 
     return 1; 
    } 

}; 

oświadczyłem typedefs uprościć ich wykorzystanie z std::shared_ptr:

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

problem: nie mogę skompilować kod do korzystania z tych deklaracji shared_ptr polymorphi tycznie, choć base we wszystkich tych przypadkach jest faktycznie instancja 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

Używam C++ 11 na polu Ubuntu 14.04 z łańcuchem domyślne narzędzie GCC. Kompilator to gcc-4.9. Co robię źle? Czy zmienna_społeczna nie może być używana polimorficznie?

Answer 1

A type przekazany do std::static_pointer_cast i std::dynamic_pointer_cast jako pierwszy typ szablonu argumentu jest typem sam typ przekształconego wskazówka, a nie z inteligentnego typu palików:

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

Z powiedział, że mogłeś nazywają go jak poniżej:

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