Discussion :

[nonozor]

Bonjour,

j'ai des objets de type A dont un attribut est un pointeur vers un objet de type B. Cet objet de type B n'existe que pour être utilisé par un objet de type A et doit donc être supprimé lorsque l'objet qui l'utilise est supprimé.
Cependant, plusieurs objets de type A peuvent avoir leur attribut pointant vers le même objet de type B. Il ne faut donc pas que le destructeur de A supprime l'objet B pointé par l'attribut. Mais alors, quand tous les objets A seront supprimés, l'objet B sera toujours dans la mémoire alors qu'il devrait être supprimé.

Est ce que transformer l'attribut de A en shared pointer vers un objet B est la bonne solution à mon problème?

Est ce que je peux créer de nombreux shared pointers sans trop affecter mes ressources mémoires et temps CPU?

Merci d'avance!!!

[3DArchi]

Salut,
As-tu lus les 2 tutoriels suivant : Présentation des pointeurs intelligents en C++, par Loïc Joly et Boost.SmartPtr : Les pointeurs intelligents de Boost par Matthieu Brucher ?

De ce que tu décris, effectivement, les shared pointeur t'apportent une solution à ton problème.
Quand aux problèmes de perfs : en gros tu rajoutes un compteur de référence sur ton pointeur partagé et éventuellement une indirection supplémentaire s'il n'y a pas d'inlining. Si tu es sur PC, prouve-moi que cela a un impact mesurable sur tes perfs

[poukill]

+1.
La perte en perf est tellement minime que tu la verras pas. En plus, vu le gain avec les shared_ptr au niveau "safety", ce serait une hérésie que de ne pas les utiliser dans ton cas.

D'ailleurs, comment faire autrement ?

[nonozor]

Merci de vos réponses! Je vais utiliser les shared_ptr!!!

D'autre part, en y réflechissant, il y a peu de cas où les shared_ptr ne sont pas utiles par rapport aux pointeurs "nus".

Est ce qu'il y a des cas où vous utilisez des pointeurs nus plutot que des shared_ptr? Pour un "void func( const type * ptr )" ou un "const type * getter()", par exemple?

[Goten]

Non pour ce genre de chose j'utilise des références...

[nonozor]

citation de boost.org

A simple guideline that nearly eliminates the possibility of memory leaks is: always use a named smart pointer variable to hold the result of new. Every occurence of the new keyword in the code should have the form:

shared_ptr<T> p(new Y);

Si tout le monde faisait cela, on ne verrai jamais aucun "pointeur nu", non?
Qu'est ce que vous en pensez?
Il y a des cas où il vaut mieux utiliser des pointeurs nus???