Discussion :

[r0d]

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?

[Nogane]

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.

[JolyLoic]

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 ?

[r0d]

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.

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.

[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.

[JulienDuSud]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
shared_ptr< T > sp;
bool b = sp; // b = false
bool b = ( sp == shared_ptr< T >() ); // true

[r0d]

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.