shared_ptr: à quoi sert-il

Question

Je fais beaucoup usage de boost :: scoped_ptr dans mon code et c'est génial, mais je travaille actuellement avec un logiciel qui utilise shared_ptr partout et je me demande s'il me manque quelque chose.

Pour autant que je sache, un shared_ptr n’est utile que si différents threads vont accéder aux mêmes données et que vous ne savez pas dans quel ordre les threads vont se terminer (avec shared_ptr assurant que l’objet existe jusqu’à la fin du dernier thread il).

Existe-t-il d'autres cas d'utilisation?

Answer 1

Les discussions ne sont pas pertinentes ici. L’important est de savoir s’il est facile de spécifier un point où l’objet n’est plus utilisé.

Supposons que plusieurs objets différents souhaitent utiliser le même objet. Cela peut être un paquet de données, ou pour une entrée / sortie, ou un objet géométrique, ou autre. Vous souhaitez que l'objet partagé soit supprimé après la suppression de tous les objets utilisateurs, et non pas avant un cycle d'horloge. Plutôt que de déterminer quel objet propriétaire aura la plus longue durée de vie (et cela peut changer si vous modifiez le programme, ou peut-être par le biais d'une interaction utilisateur), vous pouvez utiliser un shared_ptr pour forcer ce comportement.

Peu importe que les objets utilisateurs se trouvent dans le même thread ou dans des threads différents. Les objets peuvent avoir une durée de vie imprévisible même s’ils sont tous dans le même fil.

Answer 2

  

Pour autant que je sache, shared_ptr n'est utile que si   différents fils vont être   accéder aux mêmes données

Eh bien, il s’agit de situations dans lesquelles plusieurs propriétaires possèdent le même objet pointé par le pointeur intelligent. Ils peuvent accéder aux pointeurs intelligents à partir de threads différents et shared_ptr est également utilisable dans ce domaine, mais ce n'est pas le point principal. Si le dernier propriétaire perd sa référence à l'objet pointé, le mécanisme shared_ptr supprime l'objet.

Vous pouvez utiliser un scoped_ptr si vous souhaitez simplement avoir un pointeur qui est supprimé lorsque la portée créée est laissée (par des exceptions, par un goto à l’extérieur, ou par un flux de contrôle normal ou par un autre mécanisme). Si vous l'utilisez comme cela, il n'est pas nécessaire de passer à shared_ptr.

Answer 3

La différence entre scoped_ptr et shared_ptr (et auto_ptr) réside principalement dans la sémantique de la copie.

• scoped_ptr est destiné à " L'allocation de ressources correspond à une initialisation " et n'est pas copiable (il ne peut pas être partagé avec d'autres instances et la propriété ne peut pas être transférée)
• shared_ptr est destiné à la récupération automatique de la mémoire lorsqu'elle est partagée entre plusieurs parties
• auto_ptr est copiable (et transfère la propriété lorsqu'il est attribué)

Answer 4

Une autre différence importante entre shared_ptr et scoped_ptr est que seuls shared_ptr fonctionnent avec faible_ptr. Les pointeurs faibles sont utilisés pour interrompre les cycles des pointeurs partagés, évitant ainsi les fuites de mémoire, mais faiblesse_ptr peut être utilisé à plus de reprises.

Les pointeurs partagés et faibles peuvent être utilisés pour exprimer la différence entre les références propriétaires et non propriétaires. La propriété non ambiguë des données conduit à une conception plus propre. Par conséquent, lorsque des objets de données possibles doivent appartenir à un autre objet via un shared_ptr. Toutes les autres références de longue durée à des objets de données doivent être des indicateurs faibles, exprimant leur non-propriété des données. Chaque fois que des modules non propriétaires accèdent aux données, ils doivent convertir le fichier faible_ptr en un fichier shared_ptr, auquel cas ils peuvent constater que l'objet de données n'existe plus. Cependant, tandis que les modules non propriétaires accèdent à l’objet de données, ils le conservent via transitoire shared_ptr, garantissant ainsi un fonctionnement sûr même si l’objet propriétaire libère les données.

Answer 5

Comme déjà répondu, shared_ptr concerne la propriété partagée. Cependant, je dirais que la propriété partagée est généralement une mauvaise chose (des exceptions existent, telles que le modèle poids mouche) et qu'il est préférable d'identifier un propriétaire et d'y placer un scoped_ptr.

Answer 6

Un shared_ptr est un type de pointeur intelligent qui effectue le comptage de références. S'il n'y a qu'un seul propriétaire pour l'objet (cas fréquent), alors scoped_ptr est la bonne solution. Si l'objet peut être partagé entre plusieurs parties du code, alors shared_ptr ne le laissera pas être détruit jusqu'à ce que toutes les références à celui-ci aient été publiées.