quel pointeur intelligent choisir?

Bonjour à tous,

j'avoue mon inculture crasse en ce qui concerne les pointeurs intelligents. Je viens donc vous demander conseil.

Voilà, j'ai un petit programme dans lequel j'ai 2 instances d'objets assez lourds. Je vais avoir besoin d'utiliser ces 2 objets dans mon programme, mais sans les modifier, et sans faire de copie. Il me faut donc un pointeur. Oui car en plus, j'ai besoin d'avoir le cas ou mon pointeur vaut NULL.

Il me faut donc un pointeur intelligent qui:
. N'a aucune relation de "propriété" sur l'objet pointé
. Peut être NULL

Quel est, à votre avis, celui qui convient le mieux?

Bonjour,
Le seul pointeur intelligent que je connaisse qui n'as aucune relation de propriété sur l'objet pointé, c'est le weak_ptr. Ça implique que ton objet doit être géré par shared_ptr.

Je ne suis pas certain de bien te suivre...

Comment sont créés ces objets ? Sur le pile ou sur le tas ?
Quelle est la relation entre la durée de vie des objets et celle des pointeurs ? Qu'est-il sensé se passer si l'objet est détruit alors que tu pointes encore dessus ?

Citation:

---

Envoyé par JolyLoic

Comment sont créés ces objets ? Sur le pile ou sur le tas ?

---

Pour l'instant, ils sont créés sur la pile. Mais ce n'est pas une contrainte, s'il le faut, je peux les créer sur le tas.

Citation:

---

Envoyé par JolyLoic

Quelle est la relation entre la durée de vie des objets et celle des pointeurs ? Qu'est-il sensé se passer si l'objet est détruit alors que tu pointes encore dessus ?

---

Normalement, cela ne devrait jamais arriver. Ils sont créés par un singleton (dit autrement: ils appartiennent à ce singleton) qui sera libéré en dernier dans le programme. Mais dans l'absolu, si ça arrive, il ne devrait rien se passer, car en fait, à chaque fois que je vais utiliser ces pointeurs, je vais vérifier qu'ils sont valide ( pour l'instant != NULL ).
En gros, ces pointeurs peuvent avoir 3 états: pointer sur l'objet 1, pointer sur l'objet 2 ou NULL.

Donc tu as deux objets dont la durée de vie est celle du programme, et tu veux pointer dessus ? Je ne vois pas trop quel service supplémentaire pourrait t'apporter un pointeur intelligent ici, à part éventuellement :
- Vérifier en debug que tu pointes bien sur un de ces objets, ou NULL.
- Vérifier en debug que tu n'utilise plus un de ces objets après l'avoir détruit (par exemple depuis le destructeur d'un objet global)

Mais franchement dans ton cas, un simple pointeur me semble une bonne solution.

Si tu veux éviter le partage de propriété, le weak_ptr me semble ce qu'il te faut ici.

weak_ptr<T>.lock() te renvoi un shared_ptr< T > valide si le pointé existe toujours, sinon shared_ptr< T >().

D'ailleurs, je crois que tu ne le sais pas quand je te lis, mais tous les pointeurs intelligents peuvent pointer sur NULL (bien que ça n'ait pas exactement la même utilité que les pointeurs nus).

En réalité, un pointeur intelligent "ne pointant pas", c'est un pointeur intelligent default-initialisé, ou en d'autres mots, shared_ptr< T >().

D'ailleurs, tu peux le tester, il est bool convertible.

Code:

---

1 2 3 4

shared_ptr< T > sp; bool b = sp; // b = false bool b = ( sp == shared_ptr< T >() ); // true

---

Citation:

---

Envoyé par JolyLoic

Donc tu as deux objets dont la durée de vie est celle du programme, et tu veux pointer dessus ? Je ne vois pas trop quel service supplémentaire pourrait t'apporter un pointeur intelligent ici, à part éventuellement :
- Vérifier en debug que tu pointes bien sur un de ces objets, ou NULL.
- Vérifier en debug que tu n'utilise plus un de ces objets après l'avoir détruit (par exemple depuis le destructeur d'un objet global)

Mais franchement dans ton cas, un simple pointeur me semble une bonne solution.

---

Ha ben là, ce que tu dis me rassure énormément. Parce qu'en fait, je ne voyais pas trop l'avantage que je pouvais obtenir en utilisant un pointeur intelligent. Mais comme il est généralement recommandé de ne pas utiliser des pointeurs nus, je ne savais pas trop qu'en penser.

Citation:

---

Envoyé par r0d

Ha ben là, ce que tu dis me rassure énormément. Parce qu'en fait, je ne voyais pas trop l'avantage que je pouvais obtenir en utilisant un pointeur intelligent. Mais comme il est généralement recommandé de ne pas utiliser des pointeurs nus, je ne savais pas trop qu'en penser.

---

En fait, il est déconseillé d'utiliser des pointeurs nus lorsque tu alloues dynamiquement, et donc que tu vas avoir besoin d'un delete quelque part :)

Si à la base tu n'alloues pas dynamiquement, alors une référence et/ou un pointeur nu ça convient très bien =)

(Sauf si bien sûr la durée de vie doit être partagé, mais ça ne semble pas être ton cas)

pourquoi pas un safe ptr qui en debug a un compteur de referencce sur l'objet, et si l'objet est detruit alors que quelqu un pointe dessus alors le destructeur râle ?

Citation:

---

Envoyé par screetch

pourquoi pas un safe ptr qui en debug a un compteur de referencce sur l'objet, et si l'objet est detruit alors que quelqu un pointe dessus alors le destructeur râle ?

---

Si j'ai bien compris, r0d s'en fout un peu si des pointeurs pointent encore sur son objet, vu que ceux-ci font le test de savoir si l'objet pointé est toujours en vie. Vu que ce pointeur est récupéré via une méthode d'un Singleton, il peut le tester à NULL.