Comment supprimer intentionnellement un boost :: shared_ptr?
J'ai beaucoup d'objets boost::shared_ptr<MyClass>, Et à un moment donné, je veux intentionnellement delete certains d'entre eux pour libérer de la mémoire. (Je sais à ce stade que je n'aurai plus jamais besoin des objets pointés MyClass.) Comment puis-je faire cela?
Je suppose que vous ne pouvez pas simplement appeler delete() avec le pointeur brut que j'obtiens avec get().
J'ai vu une fonction get_deleter(shared_ptr<T> const & p) dans boost::shared_ptr, Mais je ne sais pas comment l'utiliser, et elle dit aussi expérimental juste à côté. (Je pense que j'ai Boost 1.38.)
Peut-être affectez-vous simplement un nouveau boost::shared_ptr Vide à la variable? Cela devrait supprimer l'ancienne valeur et la supprimer.
Tu fais juste
ptr.reset();
Voir le shared_ptr manual . C'est équivalent à
shared_ptr<T>().swap(ptr)
Vous appelez reset sur chaque pointeur intelligent qui ne devrait plus faire référence à l'objet. La dernière reset (ou toute autre action qui fait en sorte que le nombre de références tombe à zéro, en fait) libèrera automatiquement l'objet à l'aide du suppresseur.
Peut-être que vous êtes intéressé par les Techniques de programmation Smart Pointer . Il a une entrée sur désallocation retardée .
Si vous voulez pouvoir supprimer intentionnellement des objets (je le fais tout le temps), vous devez utiliser la propriété unique. Vous avez été incité à utiliser shared_ptr lorsque cela ne correspond pas à votre conception.
L'intérêt de boost::shared_ptr<T> Est que l'objet pointee sera supprimé exactement au moment où aucun point shared_ptr<T> Ne sera dans ce cas, c'est-à-dire lorsque le dernier shared_ptr<T> pointant sur cet objet est hors de portée ou est réaffecté pour pointer vers un autre objet. Donc, tout ce que vous avez à faire pour supprimer un objet est de vous assurer qu'il n'y a pas de shared_ptr<T> Pointant dessus. Par exemple. si vous n'avez qu'un seul shared_ptr<T> appelé p pointant sur un objet, laissez-le tomber hors de portée ou appelez p.reset() (équivalent à p = NULL pour un pointeur simple), ou affectez-le pour pointer vers autre chose.
Si vous avez deux shared_ptr<T> Pointant vers l'objet, vous devrez les réaffecter tous les deux.
EDIT: Merci à dehmann d'avoir souligné que p = NULL; N'est pas réellement un code valide pour un shared_ptr<T> ... :)
Ce que vous voulez faire, c'est renvoyer des références faibles en utilisant boost :: faiblesse_ptr qui peut être converti en shared_ptr en cas de besoin. Cela peut vous permettre de contrôler la durée de vie de l'objet dans le shared_ptr et ceux qui veulent y accéder peuvent conserver le faible_ptr et essayer de se convertir en shared_ptr. Si cette conversion échoue, ils peuvent alors réinterroger et ramener l'objet en mémoire.