Discussion :

[kzwix]

Bonjour,

J'ai actuellement un problème en utilisant des pointeurs intelligents. En effet, ces pointeurs ont deux versions des opérateurs de déréférencement, une version constante, et une version "normale" (non constante, donc).

Le souci est que, si on utilise la version non-constante, un traîtement parasite (copie du contenu) est réalisé, alors que la version constante du déréférencement permet de garder une unique instance, partagée entre les différents pointeurs intelligents.

En gros, je cherche à pouvoir forcer de manière "simple" l'utilisation du déréférencement constant, quand c'est possible. Actuellement, avec un pointeur intelligent P<X> p, et une méthode X:: x() const (pouvant travailler sur un objet constant, donc), le fait d'appeler p->x() utilise le déréférencement non-constant, ce qui est gênant.


Plus de détails sur le forum Qt (question initialement posée là-bas, mais il semblerait que le souci soit plutôt dû à une mauvaise compréhension des règles C++, de ma part, d'où ce sujet ici.)

http://www.developpez.net/forums/d95...re-incorrecte/



Merci par avance.

[bacelar]

Avec un simple const_cast, non ?

[kzwix]

Euh... j'avais cru comprendre que le "const_cast" était là pour permettre de virer le modificateur const, non ? Si c'est le cas, ce n'est pas ce que je veux.


En gros, la classe A a deux opérateurs, T* operator ->() const, et const T* operator ->() const.

Je ne sais pas comment "forcer" l'un plutôt que l'autre, de manière agréable, sachant que si on écrit A->methode_const_de_T(), il a une fâcheuse tendance à utiliser le déréférencement non-constant quand même.



Parce que, bon, je peux toujours faire

Code :

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

1
2
const T *t = a.operator const T*();
t->methode_const_de_T();

mais je perds alors une bonne partie de l'intérêt du pointeur intelligent, à savoir s'utiliser comme un pointeur, sans réfléchir.

[bacelar]

Euh... j'avais cru comprendre que le "const_cast" était là pour permettre de virer le modificateur const, non ? Si c'est le cas, ce n'est pas ce que je veux.

Ca marche dans les deux sens.

[kzwix]

Bon à savoir, que ça marche dans les deux sens.

Cependant, c'est pas tellement d'avoir un const *T plutôt qu'un *T, qui m'intéresse. Ce que je voudrais réellement, c'est utiliser la méthode retournant un const *T plutôt que la méthode retournant un *T.

La raison est simple : la version non-constante ajoute une opération (un Copy On Write, via appel d'une méthode detach() ), que je ne veux surtout pas voir executée. Donc obtenir le pointeur non-constant, puis le rendre constant via un cast, n'est vraiment pas le comportement souhaité.


N'y-a-t'il pas de moyen pour inciter le compilateur C++ à utiliser la méthode retournant le type qui correspond exactement, plutôt qu'un type approchant qui est ensuite casté pour rentrer ?

[white_tentacle]

Si ton pointeur intelligent est lui-même const, ça devrait appeler la bonne méthode, non ?

En gros, la classe A a deux opérateurs, T* operator ->() const, et const T* operator ->() const

Il y a un const de trop sur le premier à mon avis, ça ne peut pas marcher ça. Hop, direction la doc Qt, c'est bien ça, c'est :

T* operator ->()
const T* operator ->() const

donc si tu as un const QSharedDataPointer, il appellera nécessairement la méthode const. Après, je ne sais pas si ça te pose un problème ailleurs qu'il soit const.