C ++: « ... est pas un type polymorphes » en utilisant boost :: dynamic_pointer_cast
-
27-10-2019 - |
Question
Pourquoi est-ce que je reçois l'erreur suivante pour le code suivant?
1>C:\Libs\boost_1_44\boost/smart_ptr/shared_ptr.hpp(259): error C2683: 'dynamic_cast' : 'my_namespace::A' is not a polymorphic type
1> D:\[location]\[header_filename].h(35) : see declaration of 'my_namespace::A'
1> C:\Libs\boost_1_44\boost/smart_ptr/shared_ptr.hpp(522) : see reference to function template instantiation 'boost::shared_ptr<T>::shared_ptr<my_namespace::A>(const boost::shared_ptr<my_namespace::A> &,boost::detail::dynamic_cast_tag)' being compiled
1> with
1> [
1> T=my_namespace::B
1> ]
1> [location]\[source_filename].cpp(217) : see reference to function template instantiation 'boost::shared_ptr<T> boost::dynamic_pointer_cast<my_namespace::B,striker::A>(const boost::shared_ptr<my_namespace::A> &)' being compiled
1> with
1> [
1> T=my_namespace::B
1> ]
1>C:\Libs\boost_1_44\boost/smart_ptr/shared_ptr.hpp(260): fatal error C1903: unable to recover from previous error(s); stopping compilation
Le code C ++ est plus ou moins ce qui suit:
#include <list>
#include "boost/pointer_cast.hpp"
#include "boost/shared_ptr.hpp"
struct A
{
public:
A(const MyEnum an_enum_, const int an_int_) :
an_enum(an_enum_),
an_int(an_int_)
{}
const MyEnum an_enum;
const int an_int;
};
struct B : public A {
public:
B(const int some_int_, const MyStruct &a_struct_) :
A(ENUM_OPTION_A, an_int_),
a_struct(a_struct_)
{}
const MyStruct a_struct;
};
// Ussage in some function:
// ...
boost::shared_ptr<A> a_ptr = boost::shared_ptr<A>( new B() );
std::list<boost::shared_ptr<A>> a_list;
a_list.push_back(a_ptr);
// ...
boost::shared_ptr<A> a_ptr2 = a_list.front();
boost::shared_ptr<B> b_ptr = boost::dynamic_pointer_cast<B>(a_ptr2); // <-- error here
// ...
La solution
dynamic_cast
fonctionne UNIQUEMENT avec classe polymorphes. Et la classe polymorphic
est celle qui a atleast une fonction virtual
, soit même pas le destructor.
//polymorphic classes
struct A
{
virtual ~A(); //even virtual destructor makes a class polymorphic!
};
struct B : A
{
void f();
};
//non-polymorphic classes
struct C
{
~C(); //not virtual
};
struct D : C
{
void f(); //not virtual either
};
Dans le code ci-dessus, A
et B
sont des classes polymorphes, mais C
et D
ne sont pas.
A *pA = new B();
B *pB = dynamic_cast<B*>(pA); //okay
C *pC = new D();
D *pD = dynamic_cast<D*>(pC); //error - not polymorphic class
Notez que dans dynamic_cast
, seul le besoin du type de source à polymorphes afin de compiler. Si la destination est pas polymorphes , puis dynamic_cast
retournera pointeur NULL.
D *pD = dynamic_cast<D*>(pA); //okay - source (pA) is polymorphic
if ( pD )
cout << "pD is not null" ;
else
cout << "pD is null";
Sortie:
pD is null
Démo en ligne: https: // web. archive.org/web/20000000000000/http://www.ideone.com/Yesxc
Autres conseils
'dynamic_cast' : 'my_namespace::A' is not a polymorphic type
parce qu'il ne définit pas ou hériter d'une seule fonction virtual
. Il suffit d'ajouter un destructor virtuel et vous serez très bien.
dynamic_cast
ne fonctionne que pour ces types 'polymorphes'.
struct A
n'a pas de méthode virtuelle (même pas un destructor), de sorte que vous ne pouvez pas dynamic_cast
de A*
- pointeurs uniquement aux types avec au moins une fonction membre virtuel peut être utilisé sur dynamic_cast
. boost::dynamic_pointer_cast
fait dynamic_cast
l'intérieur, à lui est soumis aux mêmes exigences.