Quelle est la meilleure méthode pour passer un shared_ptr
d'un type dérivé à une fonction qui prend un shared_ptr
d'un type de base?
Je passe généralement shared_ptr
s 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_cast
semble un peu excessif pour une simple distribution dérivée à la base. - Si je comprends bien,
dynamic_pointer_cast
cré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_ptr
valeur par, par exempleint foo(unique_ptr<bar> b)
. Les appelants doiventstd::move
la valeur dans la fonction.Les fonctions qui prolongent la durée de vie d'un objet doivent prendre une
shared_ptr
valeur par, par exempleint 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.
shared_ptr
? Pourquoi pas de référence const de barre?