Problème de conversion const

Version imprimable

[edit]sujet déterré : ici [/edit]

Bonjour,

Je déterre un peu le sujet mais je suis tombé dessus en faisant une recherche sur Google ^^ Auriez-vous une explication claire du pourquoi de cette erreur ? Dans mon cas, c'est à cause du 'const' qui suit l'un des paramètres de mon opérateur <<.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 template <typename M> class VehiculeElectrique: public VehiculeNonHybride<M> { public: template <typename T> friend std::ostream & operator<<(std::ostream &, const VehiculeElectrique<T> &); }; template <typename T> std::ostream & operator<<(std::ostream & flux, const VehiculeElectrique<T> & vehicule) { flux << "Véhicule électrique (" << vehicule.getMoteur() << ")" << std::endl; return flux; }
Merci :-)

08/01/2012, 13h11
Invité

Bonjour,

Ta fonction membre getMoteur() est-elle déclarée avec le mot clé const?

Non, voilà à quoi ressemble ma classe VehiculeNonHybride:
Code:

1 2 3 4 5 6 7 8 9 10 11 template <typename M> class VehiculeNonHybride: public Vehicule { private: M moteur_; public: M & getMoteur(); }; template <typename M> M & VehiculeNonHybride<M>::getMoteur() { return moteur_; }
Si j'ajoute 'const' devant getMoteur(), il m'affiche une erreur.

Citation:

Envoyé par Gaspoute

Code:

1
2
3
 
template <typename M>
M const & VehiculeNonHybride<M>::getMoteur() const { return moteur_; }

Super merci :-)

J'ai une autre question avec l'ajout du 'const'. Pourquoi ceci m'affiche une erreur ?
Code:

1 2 3 4 5 6 template <typename M> void VehiculeElectrique<M>::demarrer() { VehiculeElectrique<M>::getMoteur().allumer(); std::cout << "Le véhicule démarre" << std::endl; }
et pas ça
Code:

1 2 3 4 5 6 template <typename M> void VehiculeElectrique<M>::demarrer() { M moteur = VehiculeElectrique<M>::getMoteur(); moteur.allumer(); std::cout << "Le véhicule démarre" << std::endl; }
J'ai peut-être un début de réponse mais sans être sûr: dans le deuxième bout de code, on fait un cast lorsqu'on assigne le retour à la variable 'moteur'.

08/01/2012, 15h10
JolyLoic

C'est presque ça :

Dans le premier, tu essaye d'appeler allumer sur une référence constante au moteur contenu par ton véhicule : Ca ne marche pas.

Dans le deuxième, tu dupliques l'objet moteur contenu dans ton véhicule pour en obtenir un nouveau (cette duplication est une opération constante, donc ça passe). Puis tu allumes cette copie, il n'y a pas de soucis.

Mais si tu appelles ensuite getMoteur().estAllume(); (au fait pourquoi mettre VehiculeElectrique<M>:: devant getMoteur() ?), tu pourras voir que le moteur de ton véhicule est toujours éteint !
08/01/2012, 15h50
Gaspoute

Le mieux alors serait de faire une référence à l'objet stocké par 'moteur_' ?

Je mets 'VehiculeElectrique<M>::' pcq 'getMoteur()' dépend d'un template. Ou est-ce une erreur ?

Je dois avouer que les templates est un sujet complexe ^^
08/01/2012, 20h46
Ekleog
Il te faudrait alors faire deux versions de la fonction getMoteur (enfin, si tu tiens absolument à mettre en place un tel get/setter) :
Code:

1 2 const M & getMoteur() const; M & getMoteur();
Mais ce n'est pas nécessaire.
En effet, tu es dans la classe VehiculeElectrique<M> (considères ça comme une classe, étant donné que le fait qu'elle soit template n'a pas d'importance ici).
Ceci a plusieurs conséquences.
D'abord, tu n'es pas obligé de mettre VehiculeElectrique<M>:: devant chacun de tes appels à des méthodes du même objet.
Et surtout, tu n'es tout bonnement pas obligé d'utiliser getMoteur() du tout !
Tu peux utiliser moteur_ tout court.

Ce qui t'amène à ceci :
Code:

1 2 3 4 5 template <typename M> void VehiculeElectrique<M>::demarrer() { moteur_.allumer(); std::cout << "Le véhicule démarre" << std::endl; }
08/01/2012, 22h41
koala01
Salut
Citation:
Envoyé par Equinoxe_

Il te faudrait alors faire deux versions de la fonction getMoteur (enfin, si tu tiens absolument à mettre en place un tel get/setter) :

Code:

1 2 const M & getMoteur() const; M & getMoteur();
Oh, bon dieu!!! non!!!

Il ne faut jamais créer un accesseur non constant ou renvoyant une référence non constante !!!

Autrement, tu perds tout contrôle sur les modifications que pourra subir ton objet, et, ca, c'est le premier pas sur un chemin qui ne peut te mener que vers un mur ;)

En outre, la présence même d'un accesseur (fut il constant :D ) ne se justifie à priori absolument pas :

Tout véhicule motorisé va très certainement exposer une série de comportements susceptibles d'agir sur l'état du moteur, mais il n'y a aucune raison que l'utilisateur du dit véhicule n'ait à connaitre le moteur pour être en mesure d'utiliser le véhicule ;)
08/01/2012, 23h12
JolyLoic

Citation:

Envoyé par koala01

Oh, bon dieu!!! non!!!

Il ne faut jamais créer un accesseur non constant ou renvoyant une référence non constante !!!

Tu veux dire, comme std::vector<T>::operator[] ?
08/01/2012, 23h56
koala01

Citation:

Envoyé par JolyLoic

Tu veux dire, comme std::vector<T>::operator[] ?

Ca, c'est l'exception qui confirme la règle, parce que vector a pour seule responsabilité de regrouper un ensemble d'objets types identique de manière contigüe en mémoire ;)

Il n'a donc absolument pas à décider s'il est cohérent ou non de permettre la modification des éléments qu'il contient déjà ;)

Par contre, le fait de permettre d'accéder au moteur d'un véhicule et de pouvoir le modifier à sa guise rentre bel et bien dans le cadre de la règle générale qui est : cela n'a aucun sens :D
09/01/2012, 01h14
Gaspoute
Si j'ai bien compris: dans mon cas, la méthode 'getMoteur()' n'a aucun sens et il serait alors plus judicieux d'utiliser directement l'attribut 'moteur_' de la classe 'VehiculeNonHybride' à l'intérieur de la classe 'VehiculeElectrique' comme l'a suggéré Equinoxe_ pour modifier son état comme ici 'moteur_.allumer()' ?

Cependant, admettons que ça soit cohérent de faire un getter, est-ce pour y accéder doit-on le faire comme ceci ?
Code:

1 2 VehiculeElectrique<M>::getter()
Encore merci de votre aide :)
09/01/2012, 06h12
koala01
Citation:

Envoyé par Gaspoute

Si j'ai bien compris: dans mon cas, la méthode 'getMoteur()' n'a aucun sens et il serait alors plus judicieux d'utiliser directement l'attribut 'moteur_' de la classe 'VehiculeNonHybride' à l'intérieur de la classe 'VehiculeElectrique' comme l'a suggéré Equinoxe_ pour modifier son état comme ici 'moteur_.allumer()' ?

Effectivement, la méthode getMoteur() n'a aucun sens, et il serait judicieux d'accéder directement à l'attribut moteur_ de la classe qui dispose de cet attribut ;)

Car j'ose espérer que tu ne fais pas dériver ta classe Vehicule hybride de VehiculeElectrique et de VehiculeNonHybride !!! :D

Les invariants du véhicule hybride (nombre de moteur(s), par exemple)ainsi que ses pré et post conditions (état du (des) moteur(s) en fonction de la vitesse, par exemple) sont en effet totalement incompatible avec un tel héritage multiple (aussi bien du point de vue de vehiculeNonHybride que du point de vue de VehiculeElectrique) ;)
Citation:
Cependant, admettons que ça soit cohérent de faire un getter, est-ce pour y accéder doit-on le faire comme ceci ?

Code:

1 2 VehiculeElectrique<M>::getter()

Encore merci de votre aide :)
Pour autant qu'un accesseur soit opportun, tu y fait appel depuis l'objet sur lequel tu souhaites utiliser l'accesseur, c'est donc plutot du genre de
Code:

1 2 3 4 5 6 7 Type obj; /* voir Type<T> obj; */ item = obj.getter(); // OU - OU - OU obj.getter().doSomething();
;)
09/01/2012, 09h02
Gaspoute

Citation:

Envoyé par koala01

Car j'ose espérer que tu ne fais pas dériver ta classe Vehicule hybride de VehiculeElectrique et de VehiculeNonHybride !!! :D

Effectivement, il y a un classe 'VehiculeHybride' dont héritent d'autres véhicules :)

Ca commence à devenir plus clair, merci :)
Je reviendrai p-e sur l'un ou l'autre sujet en cas de problème ^^
09/01/2012, 18h11
Ekleog

Citation:

Envoyé par koala01

Salut
Oh, bon dieu!!! non!!!

Il ne faut jamais créer un accesseur non constant ou renvoyant une référence non constante !!!

Autrement, tu perds tout contrôle sur les modifications que pourra subir ton objet, et, ca, c'est le premier pas sur un chemin qui ne peut te mener que vers un mur ;)

En outre, la présence même d'un accesseur (fut il constant :D ) ne se justifie à priori absolument pas :

Tout véhicule motorisé va très certainement exposer une série de comportements susceptibles d'agir sur l'état du moteur, mais il n'y a aucune raison que l'utilisateur du dit véhicule n'ait à connaitre le moteur pour être en mesure d'utiliser le véhicule ;)

Je me permettrai de préciser que c'est uniquement si il tient vraiment à mettre en place un tel accesseur. (cf. mon message d'au-dessus)

Mais, en fait, le principe même d'un accesseur est devenu à mes yeux étrange (en tout cas, un accesseur direct), cf. http://blog.emmanueldeloget.com/inde...des-accesseurs

J'ai suivi vos conseils et j'ai utilisé directement l'attribut 'moteur_' de ma classe 'VehiculeNonHybride' dont hérite 'VehiculeElectrique', cependant il m'affiche encore une erreur me signalant que cet attribut n'existe pas.

Citation:

In file included from projet.cpp:8:
VehiculeElectrique.hpp: In member function ‘void VehiculeElectrique<M>::demarrer() const’:
VehiculeElectrique.hpp:22: error: ‘moteur_’ was not declared in this scope

Je ne comprends pas pourquoi, pourtant j'ai bien mis l'attribut en 'protected' afin qu'il soit accessible par les classes qui héritent de 'VehiculeNonHybride'.

Voici ma classe 'VehiculeElectrique':
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #include <iostream> #include "VehiculeNonHybride.hpp" template <typename M> class VehiculeElectrique: public VehiculeNonHybride<M> { public: template <typename T> friend std::ostream & operator<<(std::ostream &, const VehiculeElectrique<T> &); void demarrer() const; }; template <typename T> std::ostream & operator<<(std::ostream & flux, const VehiculeElectrique<T> & vehicule) { flux << "Véhicule électrique" << std::endl; return flux; } template <typename M> void VehiculeElectrique<M>::demarrer() const { moteur_.allumer(); std::cout << "Le véhicule démarre" << std::endl; }
et ma classe 'VehiculeNonHybride':
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #ifndef VEHICULENONHYBRIDE_H #define VEHICULENONHYBRIDE_H #include "Vehicule.hpp" template <typename M> class VehiculeNonHybride: public Vehicule { protected: M moteur_; }; #endif

10/01/2012, 02h19
JolyLoic

Pas de bol, tu es tombé sur le cas spécial tordu...

La classe de base est un template, elle pourrait donc être spécialisée, donc le compilateur n'a pas le droit de regarder dedans avant de savoir ce que vaut M.

Maintenant, quand on a un nom dans un template, ce nom peut être de deux catégories : dépendant ou non dépendant d'un paramètre template. Les noms non dépendants sont résolus immédiatement, les noms en dépendant attendent l'instanciation du template pour être résolus (toujours pour ces histoires de spécialisation).

A priori, moteur_ ne dépend pas de ce paramètre, donc il doit être résolu immédiatement. Par contre, quand on cherche à le résoudre, on n'a pas le droit de regarder dans la classe de base. Du coup, on ne le trouve pas pendant cette phase.

Solution ? Rendre le nom dépendant.
Le plus simple est d'utiliser this->moteur_ au lieu de moteur_

Je ne sais pas si j'ai été clair, ce n'est pas facile à expliquer le pourquoi du comment...
10/01/2012, 21h26
Gaspoute

Je pense avoir compris merci :-)