Quand souhaitez-vous utiliser un std::auto_ptr au lieu de boost::shared_ptr?

Nous avons assez bien déplacé à l'aide de boost::shared_ptr dans l'ensemble de notre code, nous avons cependant encore quelques cas isolés où nous utilisons std::auto_ptr, y compris les classes singleton:

template < typename TYPE >
class SharedSingleton
{
public: 
    static TYPE& Instance()
    {
        if (_ptrInstance.get() == NULL)
            _ptrInstance.reset(new TYPE);
        return *_ptrInstance;
    }

protected: 
    SharedSingleton() {};

private:
    static std::auto_ptr < TYPE > _ptrInstance;
};

J'ai dit qu'il y a une très bonne raison pour laquelle cela n'a pas été fait shared_ptr, mais pour la vie de moi je ne comprends pas pourquoi? Je sais que auto_ptr finira par être marqué comme déprécié dans le prochain standard, donc j'aimerais sais quoi/comment je peux remplacer cette mise en œuvre.

Aussi, existe-il d'autres raisons pour lesquelles vous devez envisager d'utiliser un auto_ptr au lieu d'un shared_ptr? Et voyez-vous des problèmes pour le déplacement à shared_ptr dans l'avenir?

Edit:

Donc, en réponse à la question "puis-je remplacer en toute sécurité auto_ptr avec shared_ptr dans le code ci-dessus", la réponse est oui, mais je vais prendre un petit gain de performance.
Quand auto_ptr est finalement marqué comme déprécié et nous nous déplaçons sur std::shared_ptr, nous aurons besoin de tester notre code pour faire en sorte que nous sommes en respectant les différentes sémantique de propriété.

auto_ptr est remplacé, en raison surtout de la façon de traiter avec la sémantique de déplacement, que le maintien de la compatibilité ascendante est plus propre que de le mettre à jour, dans ce cas. La nouvelle classe doit *croise les doigts* être presque une baisse-dans le remplacement, si.

InformationsquelleAutor Alan | 2009-08-04

auto-ptr boost c++shared-ptr stl

35

auto_ptr et shared_ptr résoudre entièrement les problèmes. L'un ne remplace pas l'autre.

auto_ptr est une mince wrapper autour de pointeurs pour mettre en œuvre RAII de la sémantique, de sorte que les ressources sont toujours relâchés, même face à des exceptions. auto_ptr n'effectue pas de comptage de référence ou à tous les, il ne fait pas plusieurs pointeurs pointent vers le même objet lors de la création de copies. En fait, c'est très différent. auto_ptr est l'une des rares classes où l'opérateur d'affectation modifie le source de l'objet. Considérez ceci sans vergogne fiche de la auto_ptr page wikipedia:
```
int *i = new int;
auto_ptr<int> x(i);
auto_ptr<int> y;

y = x;

cout << x.get() << endl; //Print NULL
cout << y.get() << endl; //Print non-NULL address i
```
Remarque comment l'exécution de
```
y = x;
```
modifie non seulement y mais aussi x.

La boost::shared_ptr modèle permet de gérer plusieurs pointeurs vers le même objet, et l'objet n'est supprimé après la dernière référence à il est allé hors de portée. Cette fonctionnalité n'est pas utile dans votre scénario, qui (tente de) mettre en œuvre un Singleton. Dans votre scénario, il y a toujours 0 références 1 de référence pour le seul objet de la classe, le cas échéant.

En essence, auto_ptr objets et shared_ptr objets totalement différents de la sémantique (c'est pourquoi vous ne pouvez pas utiliser l'ancienne dans des conteneurs, mais de le faire avec le dernier est très bien), et j'espère bien que vous avez de bons tests pour attraper toutes les régressions vous avez mis en place lors de portage de votre code. :- }

InformationsquelleAutor Frerich Raabe
14

D'autres ont répondu pourquoi ce code utilise une auto_ptr au lieu d'un shared_ptr. Pour répondre à vos autres questions:

Quoi/comment je peux remplacer cette mise en œuvre?

Utiliser boost::scoped_ptr ou unique_ptr (disponible en Boost et la nouvelle norme C++). Les deux scoped_ptr et unique_ptr fournir stricte de la propriété (et pas de comptage de référence généraux), andthey éviter le surprenant supprimer-sur-la sémantique de copie de auto_ptr.

Aussi, existe-il d'autres raisons pour lesquelles vous devez envisager d'utiliser un auto_ptr au lieu d'un shared_ptr? Et voyez-vous des problèmes pour le déplacement à shared_ptr dans l'avenir?

Personnellement, je ne voudrais pas utiliser un auto_ptr. Supprimer-sur-copie est tout simplement trop non intuitive. Herb Sutter semble d'accord. Commutation de scoped_ptr, unique_ptr, ou shared_ptr devrait offrir pas de problèmes. Plus précisément, shared_ptr devrait être une baisse-dans le remplacement si vous n'avez pas de soins sur le comptage de référence généraux. scoped_ptr est un remplacement si vous n'utilisez pas auto_ptr's de transfert de propriété des capacités. Si vous êtes à l'aide de transfert de propriété, puis unique_ptr est presque une baisse-dans le remplacement, sauf que vous devez à la place d'appeler explicitement move de transfert de propriété. Voir ici pour un exemple.

InformationsquelleAutor Josh Kelley
1

auto_ptr est le seul type de pointeur intelligent que j'utilise. Je l'utilise car je n'utilise pas de coup de pouce, et parce que je préfère en général mon entreprise/de l'application des classes orientées explicitement
définir la suppression de la sémantique et de l'ordre, plutôt que de dépendre de
les collections de la, ou des, des pointeurs intelligents.
- Les pointeurs intelligents sont des outils utiles pour l'écriture sûre et efficace du code en C++. Il est très difficile d'écrire exception neutre, fuite de mémoire des programmes gratuits sans eux.
- auto_ptr (dont je vous ai déjà dit que j'utilise) EST un pointeur intelligent!
- Bien auto_ptr est pas si malin 😉 Vous ne pouvez pas gérer les ressources partagées avec elle. Donc, vous avez probablement écrit, ou devrait avoir, vos propres ref compté pointeur pour cela et c'est exactement ce que shared_ptr est fait pour vous. Je trouve ça de très mauvais conseil de ne pas utiliser le smart pointeur à l'exception auto_ptr. Je voudrais des conseils exactement le contraire parce que auto_ptr est donné deux responsabilités: s'assurer qu'il est correctement détruit n'importe comment, nous quittons le champ d'application et de transférer en toute sécurité des objets d'un endroit à un autre. shared_ptr ou unique_ptr devrait être utilisé à la place.
- Je ne crois pas en commun des ressources. Une ressource doit appartenir à une seule instance d'une classe. Et je n'ai pas donné le conseil de ne pas utiliser n'importe quel autre type de pointeur intelligent - j'ai décrit ce que je fais.
- Et qu'en est transversale des préoccupations, le contexte des objets, des données partagées, les stratégies d'optimisation, des interfaces matérielles, ... - N'est pas de décrire ce que vous faites et de donner des conseils à la même chose :S
InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.