Bonjour,

Bon, j'ai encore un souci avec ma surchage de l'opérateur >> :
L'application que j'ai codé utilise le polymorphisme. J'ai une classe de base Element, contenant plusieurs méthodes virtuelles pures:

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
 
class Element
{
    protected:  
 
        short numero;
        float vitesse;
        Point debut;
        Point fin;
 
	public:
 
		Element(float _vitesse);
		virtual void Afficher(ostream& flux) const = 0;
.
.
.
};
Il y a 3 classes dérivées qui sont Segment, Stop et ArcCercle, qui comportent (entre autres) une méthode Afficher et la surchage de l'opérateur >> :

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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
class Segment : public Element
{
    private:
 
        float longueur;
        float angle;
 
	public:
 
		Segment(float _longueur, float _angle, float _vitesse);
		virtual void Afficher(ostream& flux) const;
                friend ostream& operator <<(ostream& os, const Segment& seg); 
.
.
.
};
 
class Stop : public Element
{
    private:
 
        float duree;
 
	public:
 
		Stop(float _duree, float _vitesse);
		virtual void Afficher(ostream& flux) const;
                friend ostream& operator <<(ostream& os, const Stop& stp);  
.
.
.
};
 
class ArcCercle : public Element
{
    private:
 
        float rayon;
        float angleDebut;
        float angleFin; 
        Point centre;     
 
	public:
 
		ArcCercle(float _rayon, float _angleDebut, float _angleFin, float _vitesse);
		virtual void Afficher(ostream& flux) const;
                friend ostream& operator <<(ostream& os, const ArcCercle& arc);
.
.
.
};
Il y a ensuite la classe Trajectoire qui a comme donnée membre un vecteur qui stock toute les instances de dérivées de Element :

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
 
class Trajectoire
{
    private:
 
        vector<Element*>mesElements;   
        short nbEtapes;
        Point pDepart;   
 
	public:
 
		Trajectoire();
		bool Ajouter();
		void Afficher();
.
.
.
};
voici comment j'ai implémenté la surchage de l'opérateur << dans chaque classe dérivée de Element (ici l'implémentation dans Segment):

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
 
ostream& operator <<(ostream& os, const Segment& seg)
{     
    seg.Afficher(os);
 
    return os;
}
En effet j'ai besoin de faire appel a la méthode Afficher car une surchage d'opérateur ne peut être définie comme virtuelle.
Voici l'implémentation de la méthode Afficher dans la classe Segment (pour exemple) :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
 
void Segment::Afficher(ostream& flux) const
{ 
    flux << "\n\t   (" << numero << ") SEGMENT L = " << longueur << "m" << " A = " << angle << "rad" << " V = " << vitesse << "km/h" << endl;
}
Voici comment je compte utiliser la surchage, dans la méthode Afficher() de la classe Trajectoire :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
 
for(i = 0; i < mesElements.size(); i++)
{ 
            cout << mesElements[i];
}
Voilà pour ce qu'il en est du contexte.
J'ai l'impression de bien m'y être pris correctement, mais voici ce que le compilateur me répond quand je lance la compil (j'utilise Devcpp 4.9.9.2) :


Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
 
17 C:\Documents and Settings\Anne Laure\Bureau\TP4\element.h variable or field `Afficher' declared void 
17 C:\Documents and Settings\Anne Laure\Bureau\TP4\element.h `Afficher' declared as a `virtual' field 
17 C:\Documents and Settings\Anne Laure\Bureau\TP4\element.h expected `;' before '(' token
La ligne 17 correspond à la déclaration de la méthode Afficher dans le fichier d'en-tête de la classe Element (le premier extrait de code dans le post).

Si vous pouviez m'éclairer sur mon erreur j'en serais très reconnaissant, Merci!