Discussion :

[Gaspoute]

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

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

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 :-)

[Invité]

Bonjour,

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

[Gaspoute]

Non, voilà à quoi ressemble ma classe VehiculeNonHybride:

Code :

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

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.

[JolyLoic]

Code :

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

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

[Gaspoute]

Super merci :-)

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

Code :

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

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 :

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

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

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

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

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

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

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 :

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

1
2
3
4
5
template <typename M>
void VehiculeElectrique<M>::demarrer() {
	moteur_.allumer();
        std::cout << "Le véhicule démarre" << std::endl;
}

[koala01]

Salut

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

Code :

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

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 ) 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

[JolyLoic]

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[] ?

[koala01]

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

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

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

1
2
 
VehiculeElectrique<M>::getter()

Encore merci de votre aide

[koala01]

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 !!!

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)

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

Code :

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

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 :

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

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

[Gaspoute]

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

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 ^^

[Ekleog]

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 ) 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

[Gaspoute]

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.

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 :

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

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 :

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

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

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

[Gaspoute]

Je pense avoir compris merci :-)