Les pointeurs intelligents : Ou qui vous appartient le bébé ?

Question

C++ est tout au sujet de la mémoire de la propriété
Aka "Sémantique De Propriété"

Il est de la responsabilité du propriétaire d'un morceau de la mémoire allouée dynamiquement pour libérer de la mémoire. Donc, la question devient vraiment qui est propriétaire de la mémoire.

En C++, la propriété est documentée par le type d'un pointeur BRUT est enveloppé à l'intérieur donc dans une bonne (OMI) programme en C++, il est très rare [RARE de ne pas JAMAIS] pour voir RAW pointeurs passés autour (comme matières PREMIÈRES les pointeurs ont pas déduit de la propriété ainsi nous ne pouvons pas dire à qui appartient la mémoire et donc sans une lecture attentive de la documentation que vous ne pouvez pas dire qui est responsable de la propriété).

À l'opposé, il est rare de voir les PREMIÈRES pointeurs stockés dans une classe à chaque RAW pointeur est stocké à l'intérieur de son propre pointeur INTELLIGENT wrapper. (N. B.: Si vous ne possédez pas un objet que l'on ne doit pas être de les stocker, car vous ne pouvez pas savoir quand il va sortir de la portée et être détruit.)

Donc, la question:

• Ce type de Propriété Sémantique avoir des gens qui viennent de partout?
• Ce standard de classes sont utilisées pour mettre en œuvre ces sémantique?
• Quelles situations que vous les trouverez utiles?

Permet de garder 1 type de sémantique de la propriété par la réponse de sorte qu'ils peuvent être voté en haut et en bas individuellement

Résumé:

Sur le plan conceptuel pointeurs intelligents sont simples et naïfs implémentations sont faciles. J'ai vu de nombreuses tentatives de mises en œuvre, mais invariablement, ils sont brisés, d'une certaine façon qui n'est pas évident pour un usage occasionnel et des exemples. Donc je vous recommande de toujours utiliser bien testé "Pointeurs Intelligents" à partir d'une bibliothèque plutôt que de rouler votre propre. std::auto_ptr ou l'un des pointeurs intelligents de boost semblent couvrir tous mes besoins.

std::auto_ptr<T>:

Seule personne est propriétaire de l'objet.
Mais le transfert de propriété est autorisée.

Utilisation:
======
Cela vous permet de définir des interfaces qui montrent explicitement le transfert de propriété.

boost::scoped_ptr<T>

Seule personne est propriétaire de l'objet.
Le transfert de propriété n'est PAS autorisé.

Utilisation:
======
Utilisé pour montrer explicite de la propriété.
L'objet sera détruit par le destructeur ou lorsqu'il est explicitement réinitialiser.

boost::shared_ptr<T> (std::tr1::shared_ptr<T>)

La propriété Multiple.
C'est une simple référence compté pointeur. Lorsque, compte à rebours atteint zéro, l'objet est détruit.

Utilisation:
======
Lorsque l'objet peut avoir plusieurs eurs avec une durée de vie qui ne peut pas être déterminé au moment de la compilation.

boost::weak<T>

Utilisé avec shared_ptr<T>.
Dans les situations où un cycle de pointeurs peut arriver.

Utilisation:
======
Utilisé pour arrêter les cycles de conserver des objets uniquement lorsque le cycle est de maintenir un partagées refcount.

Answer 1

Simple C++ Modèle

Dans la plupart des modules que j'ai vu, par défaut, il a été supposé que le fait de recevoir des pointeurs était pas la réception de la propriété. En fait, les fonctions/méthodes de l'abandon de la propriété d'un pointeur étaient à la fois très rare et très explicitement exprimé dans leur documentation.

Ce modèle suppose que l'utilisateur est propriétaire de ce qu'il/elle attribue explicitement. Tout le reste est automatiquement éliminés (à l'étendue de sortie, ou par le biais de RAII). C'est un C-comme modèle, prolongée par le fait de la plupart des pointeurs sont détenus par des objets qui vont libérer automatiquement ou lorsque cela est nécessaire (à la destruction des objets, la plupart du temps), et que la durée de vie des objets sont prévisibles (RAII est votre ami, encore une fois).

Dans ce modèle, les premières pointeurs sont librement circuler et surtout pas dangereux, mais si le développeur est assez intelligent, il/elle utilise les références à la place, si possible).

• raw pointeurs
• std::auto_ptr
• boost::scoped_ptr

Smart Pointu C++ Modèle

Dans un code complet de pointeurs intelligents, l'utilisateur peut espérer ignorer la durée de vie des objets. Le propriétaire n'est jamais le code de l'utilisateur: C'est le pointeur intelligent lui-même (RAII, de nouveau). Le problème est que les références circulaires, mélangé avec un décompte de références pointeurs intelligents peut être mortel, de sorte que vous avez à traiter à la fois avec les deux partagé les pointeurs et des pointeurs faibles. Donc, vous avez toujours la propriété de prendre en considération la faiblesse du pointeur pourrait bien pointer sur rien, même si son avantage sur pointeur brut est qu'il peut vous le dire).

• boost::shared_ptr
• boost::weak

Conclusion

Peu importe les modèles que je décris, sauf exception, la réception d'un pointeur est pas la réception de sa propriété et il est toujours très important de savoir qui appartient à qui. Même pour le code C++ fortement à l'aide de références et/ou des pointeurs intelligents.

Answer 2

Pour moi, ces 3 sortes de couvrir la plupart de mes besoins:

shared_ptr de référence compté, de libération de la mémoire lorsque le compteur atteint zéro

weak - même que ci-dessus, mais c'est un "esclave" pour un shared_ptr, ne peut pas désallouer

auto_ptr - lors de la création et de désallocation de se produire à l'intérieur de la même fonction, ou lorsque l'objet doit être considéré comme un propriétaire-jamais. Lorsque vous affectez un pointeur à un autre, le second "vole" l'objet de la première.

J'ai ma propre mise en œuvre, pour ces derniers, mais ils sont également disponibles dans Boost.

J'ai encore passer des objets par référence (const chaque fois que possible), dans ce cas, la méthode doit assumer l'objet est vivant uniquement durant le temps de l'appel.

Il ya un autre type de pointeur que j'utilise ce que j'appelle hub_ptr. C'est quand vous avez un objet qui doit être accessible à partir d'objets imbriqués à l'intérieur (le plus souvent comme une classe de base virtuelle). Ceci peut être résolu par le passage d'un weak, mais il n'a pas un shared_ptr à lui-même. Comme il sait que ces objets ne vivent pas plus longtemps que lui, il passe un hub_ptr à eux (c'est juste un wrapper de modèle à un pointeur normal).

Answer 3

Ne pas avoir la propriété partagée. Si vous le faites, assurez-vous que c'est uniquement avec du code que vous ne contrôlez pas.

Cela résout 100% des problèmes, car cela vous oblige à comprendre comment tout interagit.

Answer 4

• Propriété partagée
• boost :: shared_ptr

Lorsqu'une ressource est partagée entre plusieurs objets. Le boost shared_ptr utilise le comptage de références pour s'assurer que la ressource est désallouée lorsque tout le monde est terminé.

Answer 5

std::tr1::shared_ptr<Blah> est assez souvent votre meilleur pari.