Passer des pointeurs partagés comme arguments

Si je déclare un objet enveloppé dans un pointeur partagé:

std::shared_ptr<myClass> myClassObject(new myClass());

alors j'ai voulu le passer comme argument à une méthode:

DoSomething(myClassObject);

//the called method
void DoSomething(std::shared_ptr<myClass> arg1)
{
   arg1->someField = 4;
}

Est-ce que ce qui précède incrémente simplement le nombre de références de shared_pt et tout est cool? Ou laisse-t-il un pointeur suspendu?

Êtes-vous toujours censé le faire?:

DoSomething(myClassObject.Get());

void DoSomething(std::shared_ptr<myClass>* arg1)
{
   (*arg1)->someField = 4;
}

Je pense que la 2ème manière peut être plus efficace car elle n'a qu'à copier 1 adresse (par opposition à l'ensemble du pointeur intelligent), mais la 1ère manière semble plus lisible et je ne prévois pas de repousser les limites de performances. Je veux juste m'assurer qu'il n'y a pas quelque chose de dangereux à ce sujet.

Merci.

Je souhaite transmettre un pointeur partagé à une fonction. Pouvez-vous m'aider?

Bien sûr, je peux vous aider. Je suppose que vous avez une certaine compréhension de la sémantique de propriété en C ++. Est-ce vrai?

Ouais, je suis assez à l'aise avec le sujet.

Bien.

Ok, je ne peux penser qu'à deux raisons de prendre un shared_ptrargument:

1. La fonction veut partager la propriété de l'objet;
2. La fonction effectue une opération qui fonctionne spécifiquement sur shared_ptrs.

Laquelle vous intéresse?

Je cherche une réponse générale, donc je m'intéresse aux deux. Je suis curieux de savoir ce que vous voulez dire dans le cas n ° 2, cependant.

Des exemples de telles fonctions incluent std::static_pointer_castdes comparateurs personnalisés ou des prédicats. Par exemple, si vous avez besoin de trouver tous les shared_ptr uniques à partir d'un vecteur, vous avez besoin d'un tel prédicat.

Ah, quand la fonction a réellement besoin de manipuler le pointeur intelligent lui-même.

Exactement.

Dans ce cas, je pense que nous devrions passer par référence.

Oui. Et si cela ne change pas le pointeur, vous voulez passer par référence const. Il n'est pas nécessaire de copier puisque vous n'avez pas besoin de partager la propriété. C'est l'autre scénario.

Ok, compris. Parlons de l'autre scénario.

Celui dont vous partagez la propriété? D'accord. Avec quoi partagez-vous la propriété shared_ptr?

En le copiant.

Ensuite, la fonction devra faire une copie d'un shared_ptr, correct?

Évidemment. Alors je le passe par une référence à const et je le copie dans une variable locale?

Non, c'est une pessimisation. S'il est passé par référence, la fonction n'aura d'autre choix que de faire la copie manuellement. S'il est passé par valeur, le compilateur choisira le meilleur choix entre une copie et un déplacement et l'exécutera automatiquement. Alors, passez par valeur.

Bon point. Je dois me rappeler plus souvent cet article " Vous voulez de la vitesse? Passez par la valeur. "

Attendez, que se passe-t-il si la fonction stocke le shared_ptrdans une variable membre, par exemple? Cela ne fera-t-il pas une copie redondante?

La fonction peut simplement déplacer l' shared_ptrargument dans son stockage. Déplacer un shared_ptrest bon marché car cela ne change aucun nombre de références.

Ah, bonne idée.

Mais je pense à un troisième scénario: et si vous ne voulez pas manipuler le shared_ptr, ni partager la propriété?

Dans ce cas, cela shared_ptrn'a aucun rapport avec la fonction. Si vous souhaitez manipuler la pointee, prenez une pointee et laissez les appelants choisir la sémantique de propriété qu'ils souhaitent.

Et dois-je prendre la pointee par référence ou par valeur?

Les règles habituelles s'appliquent. Les pointeurs intelligents ne changent rien.

Passez par valeur si je vais copier, passez par référence si je veux éviter une copie.

Droite.

Hmm. Je pense que vous avez oublié un autre scénario. Et si je veux partager la propriété, mais uniquement en fonction d'une certaine condition?

Ah, un cas de pointe intéressant. Je ne m'attends pas à ce que cela arrive souvent. Mais quand cela se produit, vous pouvez soit passer par valeur et ignorer la copie si vous n'en avez pas besoin, soit passer par référence et faire la copie si vous en avez besoin.

Je risque une copie redondante dans la première option et perd un mouvement potentiel dans la seconde. Je ne peux pas manger le gâteau et l'avoir aussi?

Si vous êtes dans une situation où cela compte vraiment, vous pouvez fournir deux surcharges, l'une prenant une référence const lvalue et l'autre prenant une référence rvalue. L'un copie, l'autre bouge. Un modèle de fonction de transfert parfait est une autre option.

Je pense que cela couvre tous les scénarios possibles. Merci beaucoup.

Je pense que les gens ont inutilement peur d'utiliser des pointeurs bruts comme paramètres de fonction. Si la fonction ne va pas stocker le pointeur ou affecter sa durée de vie, un pointeur brut fonctionne tout aussi bien et représente le plus petit dénominateur commun. Considérez par exemple comment vous passeriez a unique_ptrdans une fonction qui prend a shared_ptrcomme paramètre, soit par valeur, soit par référence const?

void DoSomething(myClass * p);

DoSomething(myClass_shared_ptr.get());
DoSomething(myClass_unique_ptr.get());

Un pointeur brut en tant que paramètre de fonction ne vous empêche pas d'utiliser des pointeurs intelligents dans le code appelant, là où cela compte vraiment.

Oui, l'idée même d'un shared_ptr <> est que plusieurs instances peuvent contenir le même pointeur brut et la mémoire sous-jacente ne sera libérée que lorsque la dernière instance de shared_ptr <> sera détruite.

J'éviterais un pointeur vers un shared_ptr <> car cela va à l'encontre de l'objectif car vous avez à nouveau affaire à raw_pointers.

Le passage par valeur dans votre premier exemple est sûr, mais il y a un meilleur idiome. Passez par référence const lorsque cela est possible - je dirais oui même lorsque vous traitez avec des pointeurs intelligents. Votre deuxième exemple n'est pas exactement cassé mais il est très !???. Idiot, ne rien accomplir et vaincre une partie de l'intérêt des pointeurs intelligents, et vous laisser dans un monde bogué de douleur lorsque vous essayez de déréférencer et de modifier les choses.

dans votre fonction, DoSomething vous modifiez un membre de données d'une instance de classe de myClass sorte que ce que vous modifiez est l'objet géré (pointeur brut) et non l'objet (shared_ptr). Ce qui signifie qu'au point de retour de cette fonction, tous les pointeurs partagés vers le pointeur brut géré verront leur membre de données: myClass::someFieldchangé en une valeur différente.

dans ce cas, vous passez un objet à une fonction avec la garantie que vous ne le modifiez pas (en parlant de shared_ptr et non de l'objet possédé).

L'idiome pour exprimer cela est à travers: un const ref, comme ça

void DoSomething(const std::shared_ptr<myClass>& arg)

De même, vous assurez à l'utilisateur de votre fonction que vous n'ajoutez pas un autre propriétaire à la liste des propriétaires du pointeur brut. Cependant, vous avez conservé la possibilité de modifier l'objet sous-jacent pointé par le pointeur brut.

CAVEAT: Ce qui signifie que si, d'une manière ou d'une autre, quelqu'un appelle shared_ptr::resetavant d'appeler votre fonction, et à ce moment-là, c'est le dernier shared_ptr possédant le raw_ptr, alors votre objet sera détruit et votre fonction manipulera un pointeur pendant pour détruire l'objet. TRÈS DANGEREUX!!!