Downcasting shared_ptr <Base> en shared_ptr <Derived>?

Mise à jour: le shared_ptr dans cet exemple est comme celui de Boost, mais il ne prend pas en charge shared_polymorphic_downcast (ou dynamic_pointer_cast ou static_pointer_cast d'ailleurs)!

J'essaye d'initialiser un pointeur partagé vers une classe dérivée sans perdre le nombre de références:

struct Base { };
struct Derived : public Base { };
shared_ptr<Base> base(new Base());
shared_ptr<Derived> derived;

// error: invalid conversion from 'Base* const' to 'Derived*'
derived = base;  

Jusqu'ici tout va bien. Je ne m'attendais pas à ce que C ++ convertisse implicitement Base * en Derived *. Cependant, je veux la fonctionnalité exprimée par le code (c'est-à-dire maintenir le nombre de références tout en abaissant le pointeur de base). Ma première pensée a été de fournir un opérateur de cast dans Base afin qu'une conversion implicite en Derived puisse avoir lieu (pour les pédants: je vérifierais que le down cast est valide, ne vous inquiétez pas):

struct Base {
  operator Derived* ();
}
// ...
Base::operator Derived* () {
  return down_cast<Derived*>(this);
}

Eh bien, cela n'a pas aidé. Il semble que le compilateur a complètement ignoré mon opérateur de transtypage. Des idées sur la façon dont je pourrais faire fonctionner le devoir shared_ptr? Pour les points supplémentaires: quel type de type Base* constest-ce? const Base*Je comprends, mais Base* const? A quoi fait constréférence dans ce cas?

Vous pouvez utiliser dynamic_pointer_cast. Il est soutenu par std::shared_ptr.

std::shared_ptr<Base> base (new Derived());
std::shared_ptr<Derived> derived =
               std::dynamic_pointer_cast<Derived> (base);

Documentation: https://en.cppreference.com/w/cpp/memory/shared_ptr/pointer_cast

De plus, je ne recommande pas d'utiliser l'opérateur de cast dans la classe de base. Un casting implicite comme celui-ci peut devenir la source de bogues et d'erreurs.

-Update: Si le type n'est pas polymorphe, std::static_pointer_castpeut être utilisé.

Je suppose que vous utilisez boost::shared_ptr... Je pense que vous voulez dynamic_pointer_castou shared_polymorphic_downcast.

Cependant, ceux-ci nécessitent des types polymorphes.

quel genre de type Base* constest? const Base*Je comprends, mais Base* const? A quoi fait constréférence dans ce cas?

• const Base *est un pointeur mutable vers une constante Base.
• Base const *est un pointeur mutable vers une constante Base.
• Base * constest un pointeur constant vers un mutable Base.
• Base const * constest un pointeur constant vers une constante Base.

Voici un exemple minimal:

struct Base { virtual ~Base() { } };   // dynamic casts require polymorphic types
struct Derived : public Base { };

boost::shared_ptr<Base> base(new Base());
boost::shared_ptr<Derived> derived;
derived = boost::static_pointer_cast<Derived>(base);
derived = boost::dynamic_pointer_cast<Derived>(base);
derived = boost::shared_polymorphic_downcast<Derived>(base);

Je ne sais pas si c'était intentionnel que votre exemple crée une instance du type de base et la jette, mais cela sert à bien illustrer la différence.

La static_pointer_castvolonté "faites-le simplement". Cela entraînera un comportement indéfini (un Derived*pointage sur la mémoire allouée et initialisée par Base) et causera probablement un plantage, ou pire. Le comptage de référence basesera incrémenté.

Le dynamic_pointer_castaboutira à un pointeur nul. Le décompte des références baserestera inchangé.

Le shared_polymorphic_downcastaura le même résultat qu'un cast statique, mais déclenchera une assertion, plutôt que de sembler réussir et de conduire à un comportement indéfini. Le comptage de référence basesera incrémenté.

Voir (lien mort) :

Parfois, il est un peu difficile de décider d'utiliser static_castou dynamic_cast, et vous souhaiteriez pouvoir avoir un peu des deux mondes. Il est bien connu que dynamic_cast a une surcharge d'exécution, mais c'est plus sûr, alors que static_cast n'a pas de surcharge du tout, mais il peut échouer silencieusement. Comme ce serait bien si vous pouviez l'utiliser shared_dynamic_castdans les versions de débogage et shared_static_castdans les versions de version. Eh bien, une telle chose est déjà disponible et s'appelle shared_polymorphic_downcast.

Si quelqu'un arrive avec boost :: shared_ptr ...

C'est ainsi que vous pouvez effectuer un downcast vers le Boost dérivé shared_ptr. En supposant que Derived hérite de Base.

boost::shared_ptr<Base> bS;
bS.reset(new Derived());

boost::shared_ptr<Derived> dS = boost::dynamic_pointer_cast<Derived,Base>(bS);
std::cout << "DerivedSPtr  is: " << std::boolalpha << (dS.get() != 0) << std::endl;

Assurez-vous que la classe / structure 'Base' a au moins une fonction virtuelle. Un destructeur virtuel fonctionne également.