stimuler, shared_ptr Vs weak_ptr? Ce qui à utiliser quand?

Question

Dans mon projet actuel, je me sers boost::shared_ptr assez largement.

Récemment mes collègues équipiers ont également commencé à utiliser weak_ptr. Je ne sais pas lequel utiliser et quand.

En dehors de cela, que dois-je faire si je veux convertir weak_ptr à shared_ptr. Est-ce que mettre un verrou sur weak_ptr pour créer un shared_ptr affecte mon code dans un autre fil?

Answer 1

En général et résumé,

pointeurs forts garantir leur validité. Utilisez-les, par exemple, lorsque:

• Vous possédez l'objet pointé; vous créez et le détruire
• Vous n'avez pas le comportement défini si l'objet n'existe pas
• Vous devez appliquer que l'objet existe.

pointeurs faibles garantie sachant leur validité. Utilisez-les, par exemple, lorsque:

• Vous pouvez y accéder, mais il ne vous appartient pas.
• Vous avez défini le comportement si l'objet n'existe pas

Lock () sur un pointeur faible renvoie un pointeur fort; voici comment vous accédez au pointeur faible. Si l'objet n'est plus valide (il a été supprimé, etc.), le pointeur fort sera NULL, sinon, il pointera à l'objet. Vous aurez besoin de vérifier.

Il est configuré de cette manière afin que vous ne pouvez pas supprimer accidentellement l'objet pendant que vous utilisez, parce que vous avez fait un pointeur fort temporaire (local), et garunteed ainsi l'existence de l'objet alors que le pointeur fort reste. Lorsque vous avez fini d'utiliser l'objet, vous laissez généralement le pointeur forte chute hors de portée (ou réaffectant), ce qui permet ensuite l'objet à supprimer. Pour multithreading, les traiter avec soin même vous traitez d'autres choses qui ne sont intégrés en toute sécurité de fil, en notant que la garantie je l'ai mentionné ci-dessus tenir quand multithreading. Ils ne AFAIK font rien passé spécial.

Le coup de fouet des pointeurs ont également partagé garbage collector comme caractéristiques, depuis quand le dernier pointeur fort à un objet disparaît ou des points quelque part ailleurs, l'objet est supprimé.

Il y a aussi les performances et les dépendances circulaires mentionnées dans les autres réponses.

Au fond, je dirais que le coup de pouce bibliothèque de pointeur partagé vous permet de ne pas gâcher mettre sur pied un programme, mais il ne remplace pas prendre le temps de bien concevoir vos pointeurs, les autorisations des objets et des durées de vie. Si vous avez une telle conception, vous pouvez utiliser la bibliothèque pour l'appliquer. Si vous ne vous êtes avez pas une telle conception, susceptible de se heurter différents problèmes qu'auparavant.

Answer 2

Utilisez weak_ptr lorsque les objets que vous créez contiennent des références cycliques, à savoir shared_ptr à un objet avec un shared_ptr retour à vous-même. En effet, shared_ptr ne peut pas gérer des références cycliques - lorsque les deux objets hors de portée, le référencement mutuel signifie qu'ils ne sont pas « ramasse-miettes », de sorte que la mémoire est perdue et vous avez une fuite de mémoire. Étant donné que weak_ptr ne pas augmenter le nombre de références, le problème de référence cyclique ne se produit pas. Cela signifie aussi en général que si vous voulez juste prendre un pointeur à quelque chose qui est compté référence et ne veulent pas augmenter le nombre de références, utilisez weak_ptr.

Dans le cas contraire, vous pouvez utiliser shared_ptr.

Pour plus d'informations, consultez le documentation .

Answer 3

pointeurs partagés mettre en œuvre le comptage de références, faibles pointeurs n'affectent pas le comptage de références et si vous n'avez pas des pointeurs partagés à un objet, uniquement des pointeurs faibles, l'objet est supprimé et les pointeurs faibles vous disent maintenant que l'objet a été perdu .

Il y a deux raisons d'utiliser un pointeur faible:

1. Pour éliminer le coût du compte de référence augmentation / diminution; Cependant, vous ne devriez pas le faire parce qu'il est et ne sauve pas vraiment beaucoup de temps sujettes à erreur
2. Dans les structures de données de comptabilité, par exemple vous avez un index de tous les objets Foo qui sont « vivants », à savoir utilisé ailleurs, et vous ne voulez pas garder une vie Foo dans l'indice si tous les « vrais » utilisations ont pris fin. Tel est le cas d'utilisation réaliste de base pour les pointeurs faibles. Bien sûr, d'autres existent aussi.

Donc, en général, ma recommandation serait d'utiliser des pointeurs faibles que lorsque vous savez que vous voulez laisser les objets référencés soient supprimés et que vous voulez détecter. Dans d'autres cas utiliser des pointeurs partagés (comptage de référence), ou des pointeurs directs, esp. dans la méthode des variables locales quand on sait que les objets ne vont pas obtenir supprimé. De plus sujettes aux erreurs, cependant, mais plus rapide que les pointeurs partagés.

N.B.. objets cycliques ne ont pas besoin des pointeurs faibles, vous pouvez utiliser des pointeurs non cuits, régulièrement au lieu dans les programmes les plus correctement construits. pointeurs faibles moins risqué, cependant.

Answer 4

Vous ne devriez probablement pas essayer d'utiliser des pointeurs faibles à moins que vous essayez de mettre en œuvre un éboueur, ce qui est une idée chaude en C ++, car il est trop difficile de garder une trace de tout ce qui pourrait mal tourner assez près.