Passer shared_ptr <Derived> comme shared_ptr <Base>

Quelle est la meilleure méthode pour passer un shared_ptrd'un type dérivé à une fonction qui prend un shared_ptrd'un type de base?

Je passe généralement shared_ptrs par référence pour éviter une copie inutile:

int foo(const shared_ptr<bar>& ptr);

mais cela ne fonctionne pas si j'essaye de faire quelque chose comme

int foo(const shared_ptr<Base>& ptr);

...

shared_ptr<Derived> bar = make_shared<Derived>();
foo(bar);

je pourrais utiliser

foo(dynamic_pointer_cast<Base, Derived>(bar));

mais cela semble sous-optimal pour deux raisons:

• A dynamic_castsemble un peu excessif pour une simple distribution dérivée à la base.
• Si je comprends bien, dynamic_pointer_castcrée une copie (quoique temporaire) du pointeur à passer à la fonction.

Y a-t-il une meilleure solution?

Mise à jour pour la postérité:

Il s'est avéré être un problème de fichier d'en-tête manquant. De plus, ce que j'essayais de faire ici est considéré comme un anti-modèle. Généralement,

• Les fonctions qui n'ont pas d'impact sur la durée de vie d'un objet (c'est-à-dire que l'objet reste valide pendant toute la durée de la fonction) doivent prendre une simple référence ou un pointeur, par exemple int foo(bar& b).

• Les fonctions qui consomment un objet (c'est-à-dire sont les utilisateurs finaux d'un objet donné) devraient prendre une unique_ptrvaleur par, par exemple int foo(unique_ptr<bar> b). Les appelants doivent std::movela valeur dans la fonction.

• Les fonctions qui prolongent la durée de vie d'un objet doivent prendre une shared_ptrvaleur par, par exemple int foo(shared_ptr<bar> b). Les conseils habituels pour éviter les références circulaires s'appliquent.

Voir la présentation de Herb Sutter Back to Basics pour plus de détails.

Bien que Baseet Derivedsoient covariants et bruts, les pointeurs agissent en conséquence shared_ptr<Base>et neshared_ptr<Derived> sont pas covariants. Il dynamic_pointer_casts'agit de la manière correcte et la plus simple de gérer ce problème.

( Modifier: static_pointer_cast serait plus approprié car vous effectuez un cast de dérivé vers la base, ce qui est sûr et ne nécessite pas de vérifications à l'exécution. Voir les commentaires ci-dessous.)

Cependant, si votre foo()fonction ne souhaite pas participer à l'extension de la durée de vie (ou, plutôt, participer à la propriété partagée de l'objet), il est préférable d'accepter a const Base&et de déréférencer le shared_ptrlors de sa transmission foo().

void foo(const Base& base);
[...]
shared_ptr<Derived> spDerived = getDerived();
foo(*spDerived);

En passant, comme les shared_ptrtypes ne peuvent pas être covariants, les règles des conversions implicites entre les types de retour covariants ne s'appliquent pas lors du retour des types de shared_ptr<T>.

Cela se produira également si vous avez oublié de spécifier l' héritage public sur la classe dérivée, c'est à dire si comme moi vous écrivez ceci:

class Derived : Base
{
};

On dirait que vous essayez trop fort. shared_ptrest bon marché à copier; c'est l'un de ses objectifs. Les faire circuler par référence ne fait pas grand-chose. Si vous ne voulez pas de partage, passez le pointeur brut.

Cela dit, il y a deux façons de faire cela auxquelles je peux penser du haut de ma tête:

foo(shared_ptr<Base>(bar));
foo(static_pointer_cast<Base>(bar));

Vérifiez également que le #includefichier d'en-tête contenant la déclaration complète de la classe dérivée se trouve dans votre fichier source.

J'ai eu ce problème. Le std::shared<derived>ne serait pas jeté std::shared<base>. J'avais déclaré en avant les deux classes afin que je puisse contenir des pointeurs vers elles, mais parce que je n'avais pas #includele compilateur ne pouvait pas voir qu'une classe était dérivée de l'autre.