Comment supprimer intentionnellement un boost :: shared_ptr?

J’ai beaucoup d’objects boost::shared_ptr , et à un moment donné, je veux intentionnellement delete certains d’entre eux pour libérer de la mémoire. (Je sais à ce moment-là que je n’aurai plus jamais besoin des objects MyClass .) Comment puis-je le faire?

Je suppose que vous ne pouvez pas simplement appeler delete() avec le pointeur brut obtenu avec get() .

J’ai vu une fonction get_deleter(shared_ptr const & p) dans boost::shared_ptr , mais je ne suis pas sûr de savoir comment l’utiliser, et ça dit expérimental juste à côté. (Je pense que j’ai Boost 1.38.)

Peut-être simplement atsortingbuer un nouveau boost::shared_ptr vide boost::shared_ptr à la variable? Cela devrait jeter l’ancienne valeur et la supprimer.

Tu fais juste

 ptr.reset(); 

Voir le manuel shared_ptr . C’est équivalent à

 shared_ptr().swap(ptr) 

Vous appelez reset sur chaque pointeur intelligent qui ne doit plus faire référence à l’object. La dernière reset (ou toute autre action provoquant la chute du compte de référence à zéro) entraînera la libération automatique de l’object en utilisant le paramètre Deleter.

Vous êtes peut-être intéressé par les techniques de programmation de Smart Pointer . Il a une entrée sur la désallocation retardée .

Si vous voulez pouvoir supprimer intentionnellement des objects (je le fais tout le temps), vous devez utiliser la propriété unique. Vous avez été incité à utiliser shared_ptr lorsque cela ne convient pas à votre conception.

L’intérêt de boost::shared_ptr est que l’object pointee sera supprimé exactement au moment où aucun shared_ptr pointe dessus – c’est-à-dire lorsque le dernier shared_ptr pointant vers cet object va hors de scope ou est réaffecté pour pointer vers un object différent. Donc, tout ce que vous avez à faire pour supprimer un object, c’est de vous assurer qu’il n’y a pas de shared_ptr pointant dessus. Par exemple, si vous avez un seul shared_ptr appelé p pointant sur un object, laissez-le tomber hors de la scope ou appelez p.reset() (équivalent à p = NULL pour un pointeur simple), ou assignez-le au point à autre chose.

Si vous avez deux shared_ptr pointant vers l’object, vous devrez les réaffecter tous les deux.

EDIT: Merci à dehmann pour avoir souligné que p = NULL; n’est pas réellement un code valide pour un shared_ptr … 🙂

Ce que vous voulez faire est de renvoyer des références faibles en utilisant boost :: weak_ptr qui peut être converti en shared_ptr si nécessaire. Cela peut vous permettre de contrôler la durée de vie de l’object dans le shared_ptr et ceux qui veulent y accéder peuvent conserver le fichier_fil_ptr et essayer de convertir en object shared_ptr. Si cette conversion échoue, ils peuvent alors interroger à nouveau et ramener l’object en mémoire.