Trier un vecteur de classe en fonction d'un attribut ?

Version imprimable

Voir 40 message(s) de cette discussion en une page

19/03/2010, 12h08
lynal

[Résolu] Trier un vecteur de classe en fonction d'un attribut ?
Salut à tous !

Je suis confronté à un petit souci... J'ai créé un vecteur d'une classe A, et j'ai besoin de classer ce vecteur par l'intermédiaire d'un attribut de cette classe... Et je ne sais pas comment m'y prendre :/

Voici ma classe :
Code:

1 2 3 4 5 6 7 class A { private int numeroClasse; int position; }
je crée un vecteur de cette classe

Code:

vector<A> monVecteur;

Je rentre plusieurs objets de type A dans ce vecteur via les push_back.

Maintenant je voudrais classer les éléments du vecteur monVecteur via l'attribut "position".

Donc que les classes soient triées de celle qui a la position la plus petite à celle qui a la position la plus grande...

J'ai parcouru un peu le std::sort, mais à part faire un sort via les itérateurs monVecteur.begin() et monVecteur.end() je ne sais pas quoi faire d'autre :/

Merci de votre aide :)

Tu as trois solutions :
- soit tu définis l'opérator < dans la struct A
- soit tu utilise un foncteur du genre

Code:

1
2
3
4
5
6
7
8
9
 
struct compA {
     bool operator()(const A& a1, const A& a2)
     {
            return (a1.position() < a2.position());
      }
};
 
std::sort(vA.begin(), vA.end(), compA());

ou bien encore avec une fonction

Code:

1
2
3
4
5
6
7
 
bool compA(const A& a1, const A& a1)
{
 return (a1.position() < a2.position());
}
 
std::sort(vA.begin(), vA.end(), compA);

J'ai tenté la version Fonction :), j'imagine que position() est l'accesseur qui permet de renvoyer la valeur de "Position"

J'ai un message d'erreur :
Code:

1 2 3 Course.cpp:150: error: passing â€˜const VoilierEnCourseâ€™ as â€˜thisâ€™ argument of â€˜int VoilierEnCourse::getPositionX()â€™ discards qualifiers Course.cpp:150: error: passing â€˜const VoilierEnCourseâ€™ as â€˜thisâ€™ argument of â€˜int VoilierEnCourse::getPositionX()â€™ discards qualifiers make[2]: *** [build/Debug/Cygwin-Windows/Course.o] Error 1
Ma classe A c'est VoilierEnCourse

Voici le code de la fonction :
Code:

1 2 3 4 5 bool comparaisonPosition(const VoilierEnCourse& v1, const VoilierEnCourse& v2) { return (v1.getPositionX() < v2.getPositionX()); }
Et sa décalaration :

Code:

bool comparaisonPosition(const VoilierEnCourse& v1, const VoilierEnCourse& v2);

19/03/2010, 16h06
Sylvain Togni

Il manque un const à la fonction getPositionX() !

J'ai bien rajouté le const à la fonction int getPosition(), mais le message persiste :/

Voilà le code de la classe concernée

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
class VoilierEnCourse: public VoilierInscrit
{
    private:
        int numVoilierCourse;
        int positionX;
 
 
    public:
        VoilierEnCourse(VoilierInscrit* leVoilier);
        ~VoilierEnCourse();
 
        int setPositionX(int position);
        const int getPositionX();
 
        int affiche();
};

Et éventuellement le code de la fonction :

Code:

1
2
3
4
 const int VoilierEnCourse::getPositionX()
{
    return this->positionX;
}

19/03/2010, 18h16
bruno_pages
mais non, ce qu'il voulait dire c'est :
Code:

1 2 3 4 int VoilierEnCourse::getPositionX() const { return this->positionX; }
retourner un const int ne sert à rien :lol:

Okay !!

Ca commence à venir :D

Cette fois j'ai cette erreur :
Code:

1 2 Course.cpp:158: error: no matching function for call to â€˜Course::comparaisonPosition()â€™ Course.cpp:148: note: candidates are: bool Course::comparaisonPosition(const VoilierEnCourse&, const VoilierEnCourse&)
grrrrr

Voici l'appel de la fonction dans mon code :

Code:

C std::sort(this->lesVoiliersEnCourse.begin(), this->lesVoiliersEnCourse.end(), this->comparaisonPosition());

La fonction comparaisonPosition est une méthode de la classe Course ;)

19/03/2010, 19h33
bruno_pages

il faut donner Course::comparaisonPosition, pas l'appeler comme vous le faites

si je puis me permettre, pourquoi ne lisez vous pas [U]vraiment/U] les messages d'erreur produits par le compilateur ? il dit clairement que vous appelez Course::comparaisonPosition() et qu'il n'existe qu'avec deux arguments, ensuite il suffit de charger la forme Course::comparaisonPosition() dans la ligne indiquée

Salut,
Soit comparaisonPosition est une fonction libre et tu n'as pas besoin de this :
Code:

1 2 3 4 5 bool comparaisonPosition(const VoilierEnCourse& v1, const VoilierEnCourse& v2) { return (v1.getPositionX() < v2.getPositionX()); }
Code:

1 2 3 // .... std::sort(this->lesVoiliersEnCourse.begin(), this->lesVoiliersEnCourse.end(), comparaisonPosition);
Soit comparaisonPosition est une fonction statique de Course et tu n'as toujours pas besoin de this :
Code:

1 2 3 4 5 6 7 8 9 10 11 class Course { //[...] static bool comparaisonPosition(const VoilierEnCourse& v1, const VoilierEnCourse& v2); }; bool Course::comparaisonPosition(const VoilierEnCourse& v1, const VoilierEnCourse& v2) { return (v1.getPositionX() < v2.getPositionX()); }
Code:

1 2 3 // .... std::sort(this->lesVoiliersEnCourse.begin(), this->lesVoiliersEnCourse.end(), &Course::comparaisonPosition);
Soit comparaisonPosition est une fonction membre non statique de Course, mais pourquoi ?

P.S. : VoilierEnCourse dérive de VoilierInscrit. C'est bizarre à la lecture. On dirait plutôt 2 états d'un Voilier plutôt qu'une relation d'héritage. Mais, bon, c'est certainement justifié.

Pour l'héritage oui, c'est normal, c'est même une obligation :).

En tout cas, grâce à 3DArchi, la compilation se passe bien, mais à l'affichage, il n'y a pas de tri en fonction de Position X :/

La fonction sort trie directement le vecteur où je dois enregistrer le résultat quelque part ???

Je suis désolé, apparemment je parais un peu... hmmm... (con) stupide, mais je tente désespérément de comprendre ><

C'est peut être ma fonction d'affichage qui foire, après le sort ?
Code:

1 2 3 4 5 6 7 8 9 10 cout<<"Statut actuel de la Course." << endl << endl; for(int i=0; i < this->lesVoiliersEnCourse.size(); i++) { cout << "Numéro : " << this->lesVoiliersEnCourse[i]->getNumVoilierCourse() << endl; cout << "Nom du voilier : "<< this->lesVoiliersEnCourse[i]->getNom() << endl; cout << "- Position X : " << this->lesVoiliersEnCourse[i]->getPositionX() << endl; cout << "- Classement : " << i+1; cout << endl << endl; }
Le Numéro c'est juste un ID, et le classement justement, c'est ce que je tente de faire, mais à l'affichage les voiliers sont toujours dans le même ordre, même si je change la valeur de positionX :/

Bonsoir,

Citation:

Envoyé par lynal

La fonction sort trie directement le vecteur où je dois enregistrer le résultat quelque part ???

sort modifie le vecteur de la position donnée par le premier argument inclue à celle exclue donnée par le deuxième argument (donc v.begin() et v.end() pour tout trier comme vous l'aviez écrit)

Citation:

C'est peut être ma fonction d'affichage qui foire, après le sort ?

celle-ci ne peut changer l'ordre, par contre comme vous avez un vecteur de VoilierEnCourse (et non de pointeurs de VoilierEnCourse) cela veut dire qu'il y aura des recopies de VoilierEnCourse et affectation pour faire les échanges dans le vecteur. Avez-vous redéfini le constructeur par copie ou l'opérateur = d'une façon qui puisse poser un problème ?

sinon, en dehors de votre problème il aurait mieux valut définir un print sur VoilierEnCourse (à quoi sert affiche définie dans une des première réponse ?) et utiliser un itérateur plutôt que d'utiliser []

exemple complet qui marche :
Code:

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 #include <iostream> #include <vector> using namespace std; class C { public: C(int v) : v_(v) { } int get() const { return v_; } void print(ostream & os) const; private: int v_; }; void C::print(ostream & os) const { os << v_; } bool inf(const C & a, const C & b) { return a.get() < b.get(); } int main(int, char **) { vector<C> v; v.push_back(C(3)); v.push_back(C(1)); v.push_back(C(2)); sort(v.begin(), v.end(), inf); vector<C>::iterator it; for (it = v.begin(); it != v.end(); ++it) { (*it).print(cout); cout << ' '; } cout << endl; return 0; }

20/03/2010, 08h51
3DArchi

Salut,
VoilierEnCourse dérive de VoilierInscrit. Sur quel type est défini ton vecteur ? Et quels sont les éléments que tu y mets ?

Salut 3DArchi !

VoilierEnCourse dérive bien de VoilierInscrit, mais ce n'est qu'un détail :D.

Le vecteur contient des pointeurs vers les objets de type VoilierEnCourse, et j'y mets des new VoilierEnCourse.

Salut bruno_pages !

Je suis contraint d'utiliser une méthode "affiche" dans mon code:/,

Je ne suis pas à ce stade de compréhension du C++ :aie:, je me creuse la tête pour comprendre vos lignes.

Sinon, c'est ma classe Course qui contient le vecteur "LesVoilierEnCourse" (il contient bien des pointeurs vers la classe VoilierEnCourse):

Code:

vector<VoilierEnCourse*> lesVoiliersEnCourse;

A l'affichage tout est bon sauf l'ordre. Je me suis amusé à récupérer les valeurs des positions dans un vecteur<int> et à le trier, et là ça marche... mais bon je n'ai fait que trier des entiers quoi.

Voici mon horreur : (et encore merci infiniment de me donner de votre temps pour m'aider)

Code:

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
int Course::statutCourse()
{
// Tri des voiliers en course selon leur position.
// Ce vecteur contient la position de chaque voilier (ce sont des entiers)
    vector<int> lesPositions;
 
// On récupère la position des voiliers dans ce vecteur //
    for(int i= 0; i < this->lesVoiliersEnCourse.size(); i++)
    {
        lesPositions.push_back(this->lesVoiliersEnCourse[i]->getPositionX());
    }
 
// On affiche ce qu'on a récupéré //
    for(int i= 0; i < lesPositions.size(); i++)
    {
        cout << "Position : " << lesPositions[i] << endl;
    }
    cout << endl;
 
// On fait un sort des positions
    std::sort(lesPositions.begin(), lesPositions.end());
// La ligne suivante ne semble pas marcher
    std::sort(this->lesVoiliersEnCourse.begin(), this->lesVoiliersEnCourse.end(), comparaisonPosition);
// On affiche le vecteur lesPositions cette fois trié
    cout << endl << "Trié " << endl;
 
    for(int i= 0; i < lesPositions.size(); i++)
    {
        cout << "Position : " << lesPositions[i] << endl;
    }
    cout << endl;
// L'affichage indique bien qu'il y a eu un tri
 
 
//***************************************************************************//
    cout<<"Statut actuel de la Course." << endl << endl;
    for(int i=0; i < this->lesVoiliersEnCourse.size(); i++)
    {
        cout << "Numéro : " << this->lesVoiliersEnCourse[i]->getNumVoilierCourse() << endl;
        cout << "Nom du voilier : "<< this->lesVoiliersEnCourse[i]->getNom() << endl;
        cout << "- Position X : " << this->lesVoiliersEnCourse[i]->getPositionX() << endl;
        cout << "- Classement : " << i+1;
        // Si le vecteur est trié, son premier élément sera le voilier
        // avec la position la plus proche de 0 (c'est pour ça que j'affiche la
        // valeur de l'index comme étant le n° du classement (avec +1 pour ne
        // pas commencer à 0))
        cout << endl << endl;
    }
    return 0;
}

25/03/2010, 11h39
bruno_pages

si comparaisonPosition se base bien sur la position alors cela doit marcher, et vous vous retrouvez avec quelque chose comme l'exemple complet qui marche de ma précédente réponse

[edit]donnez donc TOUT le code (.h et .cpp) de votre dernière version[/edit]

Bonjour !

Alors voici le code de Course .h et .cpp :

Code:

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
 
#ifndef _COURSE_H
#define	_COURSE_H
#include "inclusions.h"
 
class Course
{
    private:
        int numCourse;
        int DateDep;
        std::string villeDep;
        std::string villeArr;
        vector<Entreprise*> LesSponsorsCourse;
        vector<VoilierInscrit*> lesVoiliersInscrits;
        vector<VoilierEnCourse*> lesVoiliersEnCourse;
 
    public:
        static int NumerosCourses;
 
        Course(int DateDep, std::string villeDep, std::string villeArr);
        virtual ~Course();
 
        int getNumCourse();
        int getNombredeCourses();
        int getDateDep();
        std::string getVilleDep();
        std::string getVilleArr();
        VoilierEnCourse* getVoilierEnCourse(int index);
        VoilierInscrit* getVoilierInscrit(int index);
        vector<VoilierInscrit*> getVectorVoilierInscrit();
 
        int setDateDep(int date);
        int setvilleDep(std::string villedep);
        int setvilleArr(std:: string villearr);
        int setNumCourse(int num);
 
        int ajoutSponsor(Entreprise* leSponsor);
        int ajoutVoilier(VoilierInscrit* leVoilier);
        int ajoutVoilierEnCourse(VoilierEnCourse* leVoilier);
 
        int affiche();
        int statutCourse();
        int modifCoorVoilierCourse();
 
};
 
 
#endif	/* _COURSE_H */

Code:

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
#include"Course.h"
 
 
bool comparaisonPosition(const VoilierEnCourse& v1, const VoilierEnCourse& v2)
{
    return (v1.getPositionX() < v2.getPositionX());
}
 
 
int Course::NumerosCourses = 0;
 
//******************************************************//
Course::Course(int DateDep, std::string villeDep, std::string villeArr)
{
    this->DateDep = DateDep;
    this->villeDep = villeDep;
    this->villeArr = villeArr;
 
    this->NumerosCourses++;
    this->numCourse = NumerosCourses;
}
 
Course::~Course()
{
}
//******************************************************//
 
int Course::setDateDep(int date)
{
    this->DateDep = date;
    return 0;
}
 
int Course::setvilleArr(std::string villearr)
{
    this->villeArr = villearr;
    return 0;
}
 
int Course::setvilleDep(std::string villedep)
{
    this->villeDep = villedep;
    return 0;
}
 
int Course::setNumCourse(int num)
{
    this->numCourse = num;
}
 
//******************************************************//
 
int Course::getNumCourse()
{
    return this->numCourse;
}
 
int Course::getNombredeCourses()
{
    return this->NumerosCourses;
}
 
int Course::getDateDep()
{
    return this->DateDep;
}
 
std::string Course::getVilleDep()
{
    return this->villeDep;
}
 
std::string Course::getVilleArr()
{
    return this->villeArr;
}
 
vector<VoilierInscrit*> Course::getVectorVoilierInscrit()
{
    return this->lesVoiliersInscrits;
}
 
VoilierInscrit* Course::getVoilierInscrit(int index)
{
    return this->lesVoiliersInscrits[index];
}
 
 
VoilierEnCourse* Course::getVoilierEnCourse(int index)
{
    return this->lesVoiliersEnCourse[index];
}
 
//******************************************************//
 int Course::ajoutVoilier(VoilierInscrit* levoilier)
{
    this->lesVoiliersInscrits.push_back(levoilier);
    return 0;
}
 
int Course::ajoutSponsor(Entreprise* leSponsor)
{
    this->LesSponsorsCourse.push_back(leSponsor);
    return 0;
}
 
int Course::ajoutVoilierEnCourse(VoilierEnCourse* leVoilier)
{
    this->lesVoiliersEnCourse.push_back(leVoilier);
    return 0;
}
 
//*****************************************************//
int Course::affiche()
{
    cout <<"Numéro de la course : " << this->numCourse << endl;
    cout <<"Date de départ : " << this->DateDep << endl;
    cout <<"Ville de départ : " << this->villeDep << endl;
    cout <<"Ville d'arrivée : " << this->villeArr << endl;
 
    if(this->LesSponsorsCourse.size() == 0)
    {
        cout <<"Il n'y a pas de sponsor pour cette course." << endl;
    }
    else
    {
        cout << "Sponsors pour cette course : " << endl;
        for(int i = 0; i < this->LesSponsorsCourse.size(); i++)
        {
            this->LesSponsorsCourse[i]->affiche();
        }
        cout << endl;
    }
    if(this->lesVoiliersInscrits.size() == 0)
    {
        cout << "Il n'y a pas de voiliers inscrits pour cette course." << endl;
    }
    else
    {
        cout <<"Voiliers inscrits : "<< endl;
        for(int i = 0; i < this->lesVoiliersInscrits.size(); i++)
        {
            this->lesVoiliersInscrits[i]->affiche();
        }
    }
 
    cout << endl << endl;
    return 0;
}
//*****************************************************//
 
int Course::statutCourse()
{
// Tri des voiliers en course selon leur position.
// Ce vecteur contient la position de chaque voilier
    vector<int> lesPositions;
 
// On récupère la position des voiliers dans ce vecteur //
    for(int i= 0; i < this->lesVoiliersEnCourse.size(); i++)
    {
        lesPositions.push_back(this->lesVoiliersEnCourse[i]->getPositionX());
        cout << "Valeur : " << i << endl;
    }
 
// On affiche ce qu'on a récupéré //
    for(int i=0; i < lesPositions.size(); i++)
    {
        cout << "Position : " << lesPositions[i] << endl;
    }
    cout << endl;
 
// On fait un sort des positions
    std::sort(lesPositions.begin(), lesPositions.end());
// Ce code ne semble pas marcher
    std::sort(this->lesVoiliersEnCourse.begin(), this->lesVoiliersEnCourse.end(), comparaisonPosition);
// On affiche le vecteur lesPositions cette fois trié
    cout << endl << "Trié " << endl;
 
    for(int i=0; i < lesPositions.size(); i++)
    {
        cout << "Position : " << lesPositions[i] << endl;
    }
    cout << endl;
// L'affichage indique bien qu'il y a eu un tri
 
 
//***************************************************************************//
    cout<<"Statut actuel de la Course." << endl << endl;
    for(int i=0; i < this->lesVoiliersEnCourse.size(); i++)
    {
        cout << "Numéro : " << this->lesVoiliersEnCourse[i]->getNumVoilierCourse() << endl;
        cout << "Nom du voilier : "<< this->lesVoiliersEnCourse[i]->getNom() << endl;
        cout << "- Position X : " << this->lesVoiliersEnCourse[i]->getPositionX() << endl;
        cout << "- Classement : " << i+1;
        // Si le vecteur est trié, son premier élément sera le voilier
        // avec la position la plus proche de 0 (c'est pour ça que j'affiche la
        // valeur de l'index comme étant le n° du classement (avec +1 pour ne
        // pas commencer à 0
        cout << endl << endl;
    }
    return 0;
}
 
 
int Course::modifCoorVoilierCourse()
{
    int choix=0;
    int coordonnee=0;
// Affichage des voiliers en course//
    this->statutCourse();
    cout <<"Choisissez le voilier dont vous voulez modifier les coordonnées : " << endl;
    cout <<"Choix : ";
    cin >> choix;
 
    cout <<"Entrez la nouvelle coordonnée : ";
    cin >> coordonnee;
    this->lesVoiliersEnCourse[choix]->setPositionX(coordonnee);
    cout <<"Modification effectuée." <<endl;
    return 0;
}

Ca fait pas mal :p, j'ai aussi d'autres classes qui rentrent en jeu, si vous avez besoin, mais y'en a pas mal.

Voici le .h

Code:

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
 
#ifndef _VOILIERENCOURSE_H
#define	_VOILIERENCOURSE_H
 
class VoilierEnCourse: public VoilierInscrit
{
    private:
        int numVoilierCourse;
        int classementActuel;
        int positionX;
        int tempsBrut;
        int tempsReel;
       // std::vector<Penalite*> lesPenalites;
 
 
    public:
        static int NBTotalVoiliersCourse;
 
        VoilierEnCourse(std::string nom, std::string codeVoilier, std::string date, int codeInscript, std::string carac);
        VoilierEnCourse(VoilierInscrit* leVoilier);
        ~VoilierEnCourse();
 
        int setClassementActuel(int nombre);
        int setPositionX(int position);
        int setTempsBrut(int temps);
        int setTempsReel(int temps);
 
        int getNumVoilierCourse();
        int getNBTotalVoiliersCourse();
        int getClassementActuel();
        int getPositionX() const;
        int getTempsBrut();
        int getTempsReel();
 
//        int ajoutPenalite(Penalite* laPenalite);
 
        int affiche();
};
 
 
#endif	/* _VOILIERENCOURSE_H */

Et le .cpp

Code:

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
#include "inclusions.h"
 
int VoilierEnCourse::NBTotalVoiliersCourse = 0;
 
VoilierEnCourse::VoilierEnCourse(std::string nom, std::string codeVoilier, std::string date, int codeInscript, std::string carac)
: VoilierInscrit(nom, codeVoilier, date, codeInscript, carac)
{
    this->classementActuel = 0;
    this->positionX = 0;
    this->numVoilierCourse = this->NBTotalVoiliersCourse;
    this->NBTotalVoiliersCourse++;
 
}
 
VoilierEnCourse::VoilierEnCourse(VoilierInscrit* leVoilier)
{
    this->setCode(leVoilier->getCodeVoilier());
    this->setDate(leVoilier->getDate());
    this->setNom(leVoilier->getNom());
    this->setNumVoilier(leVoilier->getNumVoilier());
    this->setCaracteristique(leVoilier->getCaracteristique());
    this->setInscription(leVoilier->getInscription());
 
    this->classementActuel = 0;
    this->positionX = 0;
    this->numVoilierCourse = this->NBTotalVoiliersCourse;
    this->NBTotalVoiliersCourse++;
}
 
VoilierEnCourse::~VoilierEnCourse()
{
}
 
//*************************************************//
int VoilierEnCourse::setPositionX(int position)
{
    this->positionX = position;
     return 0;
}
 
int VoilierEnCourse::setTempsBrut(int temps)
{
    this->tempsBrut = temps;
     return 0;
}
 
int VoilierEnCourse::setTempsReel(int temps)
{
    this->tempsReel = temps;
    return 0;
}
 
int VoilierEnCourse::setClassementActuel(int nombre)
{
    this->classementActuel = nombre;
    return 0;
}
 
 
int VoilierEnCourse::getNumVoilierCourse()
{
    return this->numVoilierCourse;
}
 
int VoilierEnCourse::getNBTotalVoiliersCourse()
{
    return this->NBTotalVoiliersCourse;
}
 
 int VoilierEnCourse::getPositionX() const
{
    return this->positionX;
}
 
int VoilierEnCourse::getTempsBrut()
{
    return this->tempsBrut;
}
 
int VoilierEnCourse::getTempsReel()
{
    return this->tempsReel;
}
 
int VoilierEnCourse::getClassementActuel()
{
    return this->classementActuel;
}
 
//*************************************************//
 
int VoilierEnCourse::affiche()
{
    cout <<"Voilier n° : " << this->numVoilierCourse << endl;
    cout <<"Nom du voilier : " << this->getNom() << endl;
    cout <<"Date d'inscription : " << this->getDate() << endl;
    cout <<"Code Inscription : " << this->getInscription() << endl;
    cout <<"Caractéristiques : " << this->getCaracteristique() << endl;
    cout <<"Classement actuel : " << this->classementActuel << endl;
    cout <<"Position : " << this->positionX << endl;
}

25/03/2010, 14h04
bruno_pages
:roll: bêtes que nous sommes

la chose à trier est vector<VoilierEnCourse*> lesVoiliersEnCourse et non vector<VoilierEnCourse> lesVoiliersEnCourse, les éléments du vecteur à triés sont donc des pointeurs, la fonction de comparaison doit donc être
Code:

1 2 3 4 bool comparaisonPosition(const VoilierEnCourse * v1, const VoilierEnCourse * v2) { return (v1->getPositionX() < v2->getPositionX()); }
25/03/2010, 14h36
bruno_pages
remarques complémentaires :
- des fois il y a std::, des fois non. Il faut choisir, personnellement je suis fainéant donc j'utilise using namespace std; et je n'utilise jamais std::, cela rend aussi le code plus simple à lire
- il ne sert à rien d'écrire this->, les cas ou il faut impérativement écrire this sont rares, il ne faut le faire qu'à bon escient sinon cela trouble le lecteur car tout ce qui apparait dans un code doit être justifié
- #include "inclusions.h" ne me plait pas, cela veut dire que plusieurs fichiers vont faire cette inclusion, et il y a de forte chance que des choses soient finalement inclue pour rien. Donc mettre explicitement la liste des inclusions nécessaires
- toutes les opérations ne modifiant pas l'élément doivent être const, en particulier les getters (exemple int getNumCourse() const, de plus un getter qui ne fait rien d'autre que rendre un attribut devrait plutôt être inline
- il y a un tas d'opération retournant int pour rien, et par exemple dans setNumCourse il manque le return. Quand il n'y a rien a rendre on ne rend rien, donc pas exemple void setDateDep(int date)
- utiliser des noms qui ont un sens sémantique et non liés à l'implémentation, donc par exemple renommer getVectorVoilierInscrit en getVoillierInscrits. J'avoue que je n'aime pas non plus les préfixes get, mais bon, c'est perso
- éviter les recopies et rendre une référence constante, donc const vector<VoilierInscrit*> & getVectorVoilierInscrit() const
- définir affiche sur VoilierEnCourse pour éviter à Course::statutCourse d'en savoir trop sur VoilierEnCourse
- utiliser un itérateurs plutôt qu'un index pour parcourir un vecteur (sauf si celui-ci change de taille, la stl ne mettant pas à jour les itérateurs :cry:)
25/03/2010, 15h35
lynal

Je prends en compte vos remarques, je suis en train de changer tout mon code.

Effectivement, j'ai suivi les cours de mon formateur bêtement sans outre comprendre les mécanismes du C++, j'imagine qu'il n'est pas aussi infaillible que :)

....

Oh punaise !!!! Avec votre dernière remarque le tri a marché !!!!

Merci mille fois !!!!!!!!!!!

Je vais faire un petit changement pour que le tri se fasse dans l'ordre inverse (le premier élément soit le voilier avec la position la plus éloignée).

Alors là, merci infiniment !!
25/03/2010, 15h40
bruno_pages

Citation:

Envoyé par lynal

Je vais faire un petit changement pour que le tri se fasse dans l'ordre inverse (le premier élément soit le voilier avec la position la plus éloignée).

est-il bien utile de modifier le tri lui même pour cela ? il suffit juste de changer l'ordre d'affichage

Voir 40 message(s) de cette discussion en une page