C++ Girl
  1. C++ Girl
  3. Utilisation idiomatique de std :: auto_ptr ou utilisez uniquement shared_ptr?
Intereting Posts
Quelles classes c ++ standard ne peuvent pas être réimplémentées en c ++? Pourquoi une suppression surchargée n’est-elle pas appelée lorsqu’une exception est levée dans un destructeur? La variable membre const de la classe peut-elle être initialisée dans une méthode au lieu d’un constructeur? obtenir l’adresse du membre de la fonction Une exception utilise-t-elle la sémantique de déplacement lorsqu’elle est émise en C ++ 11? en utilisant boost lambda avec des expressions composées copie profonde de vecteur utilisant un foncteur ou un lambda Nombre premier avec c ++, qu’est-ce qui ne va pas avec le code et comment l’optimiser? Comment afficher float si l’utilisateur entre un chiffre avec une décimale et un entier si l’utilisateur entre un nombre entier en utilisant une surcharge Vim: formatage du code source Différence entre – retourner un caractère ‘local’ d’une fonction ou retourner un int * local ‘d’une fonction Choix de la langue pour la bibliothèque portable Paralléliser quatre et plus boucles nestedes avec CUDA Impossible d’attraper l’exception c ++ à l’aide de catch (…) Comportement étrange de GCC

Utilisation idiomatique de std :: auto_ptr ou utilisez uniquement shared_ptr?

Maintenant que shared_ptr est dans tr1, que pensez-vous qu’il devrait arriver à l’utilisation de std::auto_ptr ? Ils ont tous deux des cas d’utilisation différents, mais tous les cas d’utilisation de auto_ptr peuvent également être résolus avec shared_ptr . Allez-vous abandonner auto_ptr ou continuer à l’utiliser dans les cas où vous souhaitez exprimer explicitement qu’une seule classe est propriétaire à un moment donné?

auto_ptr moi, utiliser auto_ptr peut append de la clarté au code, précisément en ajoutant des nuances et une indication de la conception du code, mais en ajoutant un autre problème subtil lors de la formation de nouveaux programmeurs: ils doivent comprendre les pointeurs intelligents et les détails de leur fonctionnement. Lorsque vous utilisez un seul pointeur intelligent partout, vous pouvez simplement définir une règle qui consiste à «envelopper tous les pointeurs dans shared_ptr ».

Quel est votre avis là-dessus?

Pour fournir un peu plus de munitions au camp ‘eviter std::auto_ptr ‘: auto_ptr est obsolète dans le prochain standard (C ++ 0x). Je pense que cela seul est une arme suffisante pour qu’un argument puisse utiliser autre chose.

Cependant, comme Konrad Rudolph l’a mentionné, le remplacement par défaut de auto_ptr devrait probablement être boost::scoped_ptr . La sémantique de scoped_ptr plus étroitement à celle de auto_ptr et est destinée à des utilisations similaires. Le prochain standard C ++ 09 aura quelque chose de similaire appelé unique_ptr.

Cependant, utiliser shared_ptr n’importe où et scoped_ptr devrait être utilisé ne cassera rien, cela ne fera qu’append un tout petit peu d’inefficacité pour gérer le nombre de références si l’object ne sera jamais réellement partagé. Donc, pour les pointeurs membres privés qui ne seront jamais dissortingbués à un autre object – utilisez scoped_ptr . Si le pointeur doit être dissortingbué à quelque chose d’autre (cela inclut de les utiliser dans des conteneurs ou si tout ce que vous voulez, c’est transférer la propriété et ne pas la conserver ni la partager) – utilisez shared_ptr .

auto_ptr est bien dans les signatures aussi. Lorsqu’une fonction prend auto_ptr par valeur, cela signifie qu’elle consumra le T Si une fonction retourne un auto_ptr , il est clair qu’elle renonce à la propriété. Cela peut communiquer vos intentions sur la durée de vie.

D’autre part, utiliser scoped_ptr implique que vous ne voulez pas vous soucier de la durée de vie du T Cela implique également que vous pouvez l’utiliser dans plus d’endroits. Les deux pointeurs intelligents sont des choix valables, vous pouvez certainement les avoir tous les deux dans un même programme.

“Utiliser shared_ptr partout” est une bonne règle par défaut, et certainement un bon sharepoint départ pour apprendre aux gens à utiliser les pointeurs intelligents de manière responsable. Cependant, ce n’est pas toujours le meilleur choix.

Si vous n’avez pas besoin de propriété partagée, shared_ptr est excessif: il doit allouer un bloc de mémoire distinct pour le compte de référence, ce qui peut avoir un impact sur les performances, et la documentation est moins claire.

Personnellement, j’utilise std::auto_ptr dans de nombreux endroits où boost::scoped_ptr suffirait également: par exemple, tenir un object alloué par tas avant que la propriété ne soit transférée ailleurs, où les opérations intermédiaires pourraient être lancées.

C ++ 0x aura std::unique_ptr pour compléter std::shared_ptr tant que meilleure alternative à std::auto_ptr . Quand il sera largement disponible, je commencerai à l’utiliser.

Je crois que la meilleure pratique consiste à substituer toutes les utilisations de std::auto_ptr par boost::scoped_ptr moins que std::tr1::shared_ptr réponde mieux aux exigences, si cela ne vous dérange pas d’utiliser Boost. D’un autre côté, il était certainement intentionnel que scoped_ptr ne soit pas inclus dans TR1.

Je pense que “envelopper tous les pointeurs dans shared_ptr ” devrait bien être le mode par défaut, et constitue un conseil approprié à donner à vos codeurs débutants Cependant, dans les cas spéciaux de propriété que vous avez mentionnés, auto_ptr est en effet plus approprié et son utilisation devrait être encouragée dans de telles circonstances.