Discussion :

[beegees]

Bonjour tout le monde,

J'ai un problème que je n'arrive pas à résoudre, je viens donc demander de l'aide.

J'ai un problème de linking, voici déjà les messages d'erreur :

Vehicule3.obj : error LNK2001: unresolved external symbol "public: char const * __thiscall CVoiture::Immatriculation(void)const " (?Immatriculation@CVoiture@@QBEPBDXZ)
Vehicule3.obj : error LNK2001: unresolved external symbol "public: short __thiscall CVoiture::NombreDePersonnes(void)const " (?NombreDePersonnes@CVoiture@@QBEFXZ)

Je pense que le problème vient de cette fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void CLeTout::Afficher() const
{
        printf("Voitures :\n");
        for (long nR=0; nR < 2; nR++) //m_TV.Nombre() à la place du 2
        {
 
                CVoiture& V = m_TV.Element(nR); //Voir la fonction CVoiture& CTabVotiures::Element...
                printf("- Immatriculation : %s\n  - Nombre de place : %lg\n  - VTM : %lg\n",V.Immatriculation(),V.NombreDePersonnes(),V.VTM()); 
                        /* exemple --> printf("- rectangle n°%ld :\n  - nom : %s\n  - longueur : %lg\n  - largeur : %lg\n  - surface : %lg\n",
                        nR+1,R.Nom(),R.Longueur(),R.Largeur(),R.Surface());*/
        }
 
}

Voici le .h qui va avec :

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
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
#include <BasicConsole.h>
#include "chaine.h"
 
class Vehicule3;
class CVoiture;
class CTabVoitures;
 
class Vehicule3
{
 
public:
 
        Vehicule3();
        Vehicule3(const Vehicule3& Modele);
        Vehicule3(const char* UneImmatriculation, short UnNombreDePlace);
        ~Vehicule3();
 
        const char*                     Immatriculation() const; // accesseur du nom
        bool                            EstValide() const;
 
        bool            Immatriculation(const char* UneImmatriculation); //modificateur de Immatriculation
        bool            NombreDePersonnes(short UnNombre); //Permet de modifier le membre m_NombreDePersonnes --> modificateur
        short           NombreDePersonnes() const; //Permet de retourner le nombre de Personnes
        bool            NombreDePersonnesEstValide() const; //permet de savoir si les valeurs dans m_NombreDePersonnes sont ok ou pas
 
private:
        CChaine         m_Immatriculation;
        short           m_NombreDePersonnes;
};
 
class CVoiture : public Vehicule3
{
friend CTabVoitures;
public:
        CVoiture();
        CVoiture(const CVoiture& Modele);
        CVoiture(const char* UneImmatriculation,short UnNombreDePlace,double UnVolumeTransportableDeMarchandise);
        ~CVoiture();
 
        double          VTM() const;
        bool            VTM(double UneValeurTransportableDeMarchandise);
        bool            EstValide() const;
        short           CVoiture::NombreDePersonnes() const;
        const char*     CVoiture::Immatriculation() const;
 
 
        private:
        static int                      FctnComparerN(const void* p1, const void* p2);
        static int                      FctnComparerSN(const void* p1, const void* p2);
        int                                     ComparerN(const CVoiture& Autre) const;
        int                                     ComparerSN(const CVoiture& Autre) const;
 
 
private:
        double          m_VTM; //Volume transportable de marchandise
 
 
};
 
 
 
class CTabVoitures
{
public:
        CTabVoitures();
        ~CTabVoitures();
 
 
        bool            Ajouter(const CVoiture& Modele);
        long            Nombre() const;
        bool            Supprimer(long Indice);
 
        CVoiture&                       Element(long Indice) const;
        long                            Indice(const char* Nom) const;
 
        void                            Vider();
        void                            Trier();
 
private:
        long            m_Nombre;
        CVoiture**      m_Tableau;
 
};
 
class CLeTout
{
public:
        CLeTout();
        ~CLeTout();
 
        bool            Charger(const char* NomFichier);
        void            Afficher() const;
        CChaine         Immatriculation() const;
private:
 
        private:
        static bool                     FctnTraiterLigne(const CChargeurFichierTexte& CC, void* Contexte);
        bool                            TraiterLigne(const CChargeurFichierTexte& CC);
 
 
 
private:
        CTabVoitures    m_TV; //Tableau de voitures
};

et au cas où voici le code entier de mon cpp :

Je vous remercie d'avance pour votre aide.

beegees

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
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
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
#include <BasicConsole.h>
#include "vehicule3.h"
#include "chaine.h"
#include <search.h>
 
///////////////////////////////
// Class Vehicule3           //
///////////////////////////////
Vehicule3::Vehicule3()
:m_Immatriculation(""),m_NombreDePersonnes(0)
{
}
 
Vehicule3::Vehicule3(const Vehicule3& Source)
:m_Immatriculation(Source.m_Immatriculation),m_NombreDePersonnes(Source.m_NombreDePersonnes)
{
}
 
Vehicule3::Vehicule3(const char* UneImmatriculation,short UnNombreDePlace)
{
}
 
Vehicule3::~Vehicule3()
{
}
 
bool Vehicule3::EstValide() const
{
        return !m_Immatriculation.EstVide();
 
}
 
bool Vehicule3::Immatriculation(const char* UneImmatriculation)
{
        return m_Immatriculation.Chaine(UneImmatriculation);
}
 
short   Vehicule3::NombreDePersonnes() const
{
        return m_NombreDePersonnes;
}
 
bool Vehicule3::NombreDePersonnesEstValide() const
{
        return ((m_NombreDePersonnes > 0) && (m_NombreDePersonnes < 200));
}
 
bool  Vehicule3::NombreDePersonnes(short UnNombre)
{
        if (NombreDePersonnes < 0) return false;
        m_NombreDePersonnes = UnNombre;
        return true;
 
}
 
/*const char* Vehicule3::Nom() const
{
        return m_Immatriculation.Chaine();
}*/
 
///////////////////////////////
// Class Voiture             //
///////////////////////////////
 
CVoiture::CVoiture()//constructeur par défaut
:m_VTM(0.0)
{
}
 
CVoiture::CVoiture(const CVoiture& Source) //constructeur par copie
:Vehicule3(Source),m_VTM(Source.m_VTM) //une question que je me pose, est-ce que Vehicule3(Source) contient tous les membres de Véhicules3 ?
{
}
 
CVoiture::CVoiture(const char* UneImmatriculation,short
          UnNombreDePlace,double UnVolumeTransportableDeMarchandise)
          :Vehicule3(UneImmatriculation, UnNombreDePlace),m_VTM(0.0)
{
        VTM(UnVolumeTransportableDeMarchandise);
}
 
CVoiture::~CVoiture()
{
 
}
 
bool            CVoiture::EstValide() const
{
        return ((Vehicule3::EstValide) && (m_VTM > 0) && (Vehicule3::NombreDePersonnes()));
}
 
bool CVoiture::VTM(double UneValeurTransportableDeMarchandise)
{
        if(UneValeurTransportableDeMarchandise <= 0.0) return false;
        m_VTM = UneValeurTransportableDeMarchandise;
        return true;
 
}
 
double CVoiture::VTM() const
{
        return m_VTM;
}
 
CVoiture& CTabVoitures::Element(long Indice) const
{
        static CVoiture Poubelle;
        return ( (Indice >= 0) && (Indice < m_Nombre) ) ? *(m_Tableau[Indice]) : Poubelle;
}
 
/*static*//* int CVoiture::FctnComparerN(const void* p1, const void* p2)
{
        const CVoiture** r1 = (const CVoiture**)p1;
        const CVoiture** r2 = (const CVoiture**)p2;
        return (*r1)->ComparerN(*(*r2));
}*/
 
/*static*//* int CVoiture::FctnComparerSN(const void* p1, const void* p2)
{
        const CVoiture** r1 = (const CVoiture**)p1;
        const CVoiture** r2 = (const CVoiture**)p2;
        return (*r1)->ComparerSN(*(*r2));
}*/
 
/*int CVoiture::ComparerN(const CVoiture& Autre) const
{
        return strcmp(Nom(),Autre.m_Immatriculation());
}*/
/*
int CVoiture::ComparerSN(const CVoiture& Autre) const
{
        if (Surface() < Autre.Surface()) return -(-1);
        if (Surface() > Autre.Surface()) return -(1);
        return strcmp(Nom(),Autre.Nom());
        //return ComparerN(Autre);
}*/
 
///////////////////////////////
// Class CTabVoitures        //
///////////////////////////////
 
CTabVoitures::CTabVoitures()
:m_Nombre(0),m_Tableau(NULL)
{
}
 
CTabVoitures::~CTabVoitures()
{
        Vider();
}
 
CLeTout::CLeTout()
{
 
}
 
CLeTout::~CLeTout()
{
 
}
 
bool CTabVoitures::Ajouter(const CVoiture& Modele)
{
        if (!Modele.EstValide()) return false;
        //if (Indice(Modele.Nom()) >= 0) return true;
        CVoiture* AAjouter = new CVoiture(Modele); //constructeur par copie
        if (AAjouter == NULL) return false;
        void* Nouveau = realloc(m_Tableau,(m_Nombre+1)*sizeof(CVoiture*));
        if (Nouveau == NULL)
        {
                delete AAjouter;
                return false;
        }
        m_Tableau = (CVoiture**)Nouveau;
        m_Tableau[m_Nombre] = AAjouter;
        m_Nombre++;
        return true;
}
 
void CTabVoitures::Vider()
{
        if (m_Tableau != NULL)
        {
                for (long n=0; n < m_Nombre; n++) delete m_Tableau[n];
                free(m_Tableau);
                m_Tableau = NULL;
                m_Nombre = 0;
        }
}
 
bool CTabVoitures::Supprimer(long Indice)
{
        if ( (Indice < 0) || (Indice >= m_Nombre) ) return false;
        delete m_Tableau[Indice];
        if (Indice < (m_Nombre-1)) memmove(m_Tableau+Indice,m_Tableau+(Indice+1),((m_Nombre-1)-Indice)*sizeof(CVoiture*));
        m_Nombre--;
        /*
        if (m_Nombre > 0)
                m_Tableau = (CCercle**)realloc(m_Tableau,m_Nombre*sizeof(CCercle*));
        else
        {
                free(m_Tableau);
                m_Tableau = NULL;
        }
        */
        return true;
}
 
long CTabVoitures::Nombre() const
{
        return m_Nombre;
}
 
/*CVoiture& CTabVoitures::Element(long Indice) const
{
        static CVoiture Poubelle;
        return ( (Indice >= 0) && (Indice < m_Nombre) ) ? *(m_Tableau[Indice]) : Poubelle;
}*/
 
/*long CTabVoitures::Indice(const char* Nom) const
{
        if (m_Nombre == 0) return -1;
        CVoiture        ModeleRecherche(Nom,1,1);
        //if (!ModeleRecherche.EstValide()) return -1;
        CVoiture*       pRecherche = &ModeleRecherche;
        unsigned int n = m_Nombre;
        CVoiture** pResultat = (CVoiture**)_lfind(&pRecherche,m_Tableau,&n,sizeof(CVoiture*),CVoiture::FctnComparerN);
        return (pResultat != NULL) ? pResultat - m_Tableau : -1;
}*/
 
/*
void CTabVoitures::Trier()
{
        if (m_Nombre >= 2) qsort(m_Tableau,m_Nombre,sizeof(CVoiture*),CVoiture::FctnComparerSN);
}*/
 
 
///////////////////
// Class CLeTout //
///////////////////
 
bool CLeTout::FctnTraiterLigne(const CChargeurFichierTexte& CC, void* Contexte)
{
        return ((CLeTout*)Contexte)->TraiterLigne(CC);
}
 
 
 
bool CLeTout::Charger(const char* NomFichier) //copie telle quelle
{
        CChargeurFichierTexte   Chargeur;
 
        /*chargeur.Charger, je lui passe le nom du fichier et le contexte et il faudra aussi lui 
          passer le séparateur de caractère qui est utilisé par la méthode "Définir" de la classe 
          "CChaineComposée" et il faut aussi lui passer en plus du contexte la fonction qu'il doit 
          appeler, ça sera "FctnTraiterLigne", ici je lui passe l'adresse de cette fonction là.*/
        return Chargeur.Charger(NomFichier,'\t',CLeTout::FctnTraiterLigne,this);
}
 
bool CLeTout::TraiterLigne(const CChargeurFichierTexte& CC)
{
        if (strlen(CC.Champs(0)) == 1) switch (CC.Champs(0)[0])
        {
                case 'V':
                        if (CC.NombreChamps() == 4) m_TV.Ajouter(CVoiture(CC.Champs(1),atof(CC.Champs(2)),atof(CC.Champs(3))));
                        break;
        }
        return true;
}
 
/*CChaine Immatriculation() const
{
        return 
}*/
 
 
  void CLeTout::Afficher() const
{
        printf("Voitures :\n");
        for (long nR=0; nR < 2; nR++) //m_TV.Nombre() à la place du 2
        {
 
                CVoiture& V = m_TV.Element(nR); //Voir la fonction CVoiture& CTabVotiures::Element...
                printf("- Immatriculation : %s\n  - Nombre de place : %lg\n  - VTM : %lg\n",V.Immatriculation(),V.NombreDePersonnes(),V.VTM()); 
                        /* exemple --> printf("- rectangle n°%ld :\n  - nom : %s\n  - longueur : %lg\n  - largeur : %lg\n  - surface : %lg\n",
                        nR+1,R.Nom(),R.Longueur(),R.Largeur(),R.Surface());*/
        }
 
}

[JolyLoic]

Tu as déclaré dans la classe CVoiture une fonction nommé Immatriculation, mais elle n'est définie nulle part...

[beegees]

Tu as déclaré dans la classe CVoiture une fonction nommé Immatriculation, mais elle n'est définie nulle part...

Bonjour Loic,

En effet, je me suis rendu compte d'un problème que j'avais déjà rencontré la semaine dernière.

J'ai maintenant créer la fonction dans le cpp et NombreDePersonnes fonctionne (Vehicule3 renvoie m_NombreDePersonnes car lui seul peut accèder à sa variable privée)

Par contre, je continues à chercher pour l'immatriculation.

Merci pour tout et super ton avatar !

beegees

[koala01]

Salut,

Je sais que le sujet est résolu, mais, je t'ai déjà incité grandement à utiliser la classe string qui est disponible (comme tout le reste de la bibliothèque standard du C++) dans l'espace de noms std quand tu inclus le fichier d'en-tête <string>

Tu peut alors renvoyer une référence (pour éviter la copie de la chaine) constante (pour éviter que l'on essaye de modifier l'immatriculation

Le code de ta classe Vehicule3 devient alors

Pour le fichier d'en-tête

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
#include <BasicConsole.h>
#include <string>
#include "chaine.h"
 
class Vehicule3;
class CVoiture;
class CTabVoitures;
 
class Vehicule3
{
 
public:
 
        Vehicule3();
        Vehicule3(const Vehicule3& Modele);
        Vehicule3(const char* UneImmatriculation, short UnNombreDePlace);
        ~Vehicule3();
 
        const std::string& Immatriculation() const; // accesseur du nom
        bool                            EstValide() const;
 
        bool reImmatriculate(const std::string& UneImmatriculation); //modificateur de Immatriculation
        bool            NombreDePersonnes(short UnNombre); //Permet de modifier le membre m_NombreDePersonnes --> modificateur
        short           NombreDePersonnes() const; //Permet de retourner le nombre de Personnes
        bool            NombreDePersonnesEstValide() const; //permet de savoir si les valeurs dans m_NombreDePersonnes sont ok ou pas
 
private:
        std::string m_Immatriculation;
        short           m_NombreDePersonnes;
};

et l'implémentation devient, tout simplement

Code :

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

1
2
3
4
5
6
7
8
9
10
const std::string& Vehicule3::Immatriculation() const
{
    return m_Immatriculation;
}
bool Vehicule3::reImmatriculate(const std::string& UneImmatriculation)
{
    /*éventuellement un test de validité de l'immatriculation */
    m_Immatriculation=UneImmatriculation;
    return true;
}

NOTA:

1. j'ai juste renommé le mutateur pour le membre m_Immatriculation (en plus d'avoir utilisé la std::string), histoire d'éviter les noms trop proches qui font deux choses différente
2. Typiquement, je me dis que ce mutateur n'a pas vraiment de raison d'être...

[beegees]

Salut,

Je sais que le sujet est résolu, mais, je t'ai déjà incité grandement à utiliser la classe string qui est disponible (comme tout le reste de la bibliothèque standard du C++) dans l'espace de noms std quand tu inclus le fichier d'en-tête <string>

Tu peut alors renvoyer une référence (pour éviter la copie de la chaine) constante (pour éviter que l'on essaye de modifier l'immatriculation

Le code de ta classe Vehicule3 devient alors

Pour le fichier d'en-tête

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
#include <BasicConsole.h>
#include <string>
#include "chaine.h"
 
class Vehicule3;
class CVoiture;
class CTabVoitures;
 
class Vehicule3
{
 
public:
 
        Vehicule3();
        Vehicule3(const Vehicule3& Modele);
        Vehicule3(const char* UneImmatriculation, short UnNombreDePlace);
        ~Vehicule3();
 
        const std::string& Immatriculation() const; // accesseur du nom
        bool                            EstValide() const;
 
        bool reImmatriculate(const std::string& UneImmatriculation); //modificateur de Immatriculation
        bool            NombreDePersonnes(short UnNombre); //Permet de modifier le membre m_NombreDePersonnes --> modificateur
        short           NombreDePersonnes() const; //Permet de retourner le nombre de Personnes
        bool            NombreDePersonnesEstValide() const; //permet de savoir si les valeurs dans m_NombreDePersonnes sont ok ou pas
 
private:
        std::string m_Immatriculation;
        short           m_NombreDePersonnes;
};

et l'implémentation devient, tout simplement

Code :

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

1
2
3
4
5
6
7
8
9
10
const std::string& Vehicule3::Immatriculation() const
{
    return m_Immatriculation;
}
bool Vehicule3::reImmatriculate(const std::string& UneImmatriculation)
{
    /*éventuellement un test de validité de l'immatriculation */
    m_Immatriculation=UneImmatriculation;
    return true;
}

NOTA:

1. j'ai juste renommé le mutateur pour le membre m_Immatriculation (en plus d'avoir utilisé la std::string), histoire d'éviter les noms trop proches qui font deux choses différente
2. Typiquement, je me dis que ce mutateur n'a pas vraiment de raison d'être...

Salut Koala,

Merci pour ta réponse.

Crois moi, je suis entierrement d'accord avec toi mais je dois suivre ce que le prof m'enseigne, en tout cas jusqu'à l'examen.

Sache qu'apèrs l'examen, je n'utiliserai PLUS QUE la classe string car le const char* me semble compliqué et je ne comprends pas bien cette technique à 100%.

Tes messages sont maintenant dans mon cours, je vais en parler avec mon Porf, lui demander si on va voir la classe String, mais j'en doute

Mais à nouveau, dans le future, je n'utiliserai plus que cette classe qui me semble bien facile d'utilisation.

Merci sincèrement pour tout.

beegees