Prob de compilation avec GNU C++, mais pas Borland

Résolu
Signaler
Messages postés
3
Date d'inscription
dimanche 19 novembre 2000
Statut
Membre
Dernière intervention
17 juillet 2005
-
Messages postés
3
Date d'inscription
dimanche 19 novembre 2000
Statut
Membre
Dernière intervention
17 juillet 2005
-
Bonjour,

Voilà, je suis en train d'apprendre le c++ et j'ai décidé de tester le
programme récapitulatif de la deuxième partie de mon bouquin.

Mais à la compilation le lieur GNU me sort une vingtaine d'erreurs du
type "multiple definition of `NoeudPieces::LireSuivant() const' en
ligne 108". Le problème ne se pose pas pour les métodes membres
implémentés lors de la déclaration.

Le compilateur Borland compile pafaitement le programme, qui fonctionne correctement.

Je n'arrive donc pas à compiler ce programme ni avec Dev-C++ (GNU), ni
avec C++BuilderX (Borland) en choisissant le compilateur GNU, mais je
le compile avec C++BuilderX avec le compilateur made in Borland.



Quelqu'un pourrait-il m'expliquer le problème (et me dire comment le résoudre si possible) ?



Je vous copie le code si dessous (il doit être sous copyright CampusPress, même avec mes petites modifications).



Fichier "Classes.cpp" :

/********************************* Classes.cpp *********************************

/

/ Déclaration et implémentation des classes.

/

/ Classes :

/ -Pièce : contient les n° de pièces et d'autres info.

/ -NoeudPieces : noeud dans une ListePieces

/ -ListePieces : mécanisme pour une liste cheînée de pièces

/

/******************************************************************************/



#include <cstdlib>

#include



using namespace std;



//******************************** Piece ***************************************



// Classe de base abstraite de pièces

class Piece

{

public:

Piece():wNumPiece(1){}

Piece(int NumPiece):wNumPiece(NumPiece){}

virtual ~Piece(){}

int LireNumPiece() const { return wNumPiece; }

virtual void Afficher() const =0; //doit être substituée

private:

int wNumPiece;

};



//impémentation d'une fonction virtuelle pure pour chaîner les classes dérivées

void Piece::Afficher() const

{

cout << "Numero de piece : " << wNumPiece << endl;

}



//****************************** PieceAuto *************************************

class PieceAuto : public Piece

{

public:

PieceAuto():wAnneeAuto(1994){}

PieceAuto(int Annee, int NumPiece);

virtual void Afficher() const

{

Piece::Afficher();

cout << "Millesime : " << wAnneeAuto << endl;

}

private:

int wAnneeAuto;

};





PieceAuto::PieceAuto(int Annee, int NumPiece):

wAnneeAuto(Annee),

Piece(NumPiece)

{}



//***************************** PieceAvion *************************************

class PieceAvion : public Piece

{

public:

PieceAvion():wRefMoteur(1){}

PieceAvion(int RefMoteur, int NumPiece);

virtual void Afficher() const

{

Piece::Afficher();

cout << "Reference du moteur : " << wRefMoteur << endl;

}

private:

int wRefMoteur;

};



PieceAvion::PieceAvion(int RefMoteur, int NumPiece):

wRefMoteur(RefMoteur),

Piece(NumPiece)

{}



//***************************** NoeudPieces *************************************

class NoeudPieces

{

public:

NoeudPieces(Piece*);

~NoeudPieces();

void DefSuivant(NoeudPieces* pNoeud) { wpSuivant = pNoeud; }

NoeudPieces* LireSuivant() const;

Piece* LirePiece() const;

private:

Piece* wpPiece;

NoeudPieces* wpSuivant;

};



NoeudPieces::NoeudPieces(Piece* pPiece):

wpPiece(pPiece),

wpSuivant(0)

{};



NoeudPieces::~NoeudPieces()

{

delete wpPiece;

wpPiece = 0;

delete wpSuivant;

wpSuivant = 0;

}



//Renvoie NULL si pas de NoeuPieces suivant

NoeudPieces* NoeudPieces::LireSuivant() const

{

return wpSuivant;

}



Piece* NoeudPieces::LirePiece() const

{

if(wpPiece)

return wpPiece;

else

return NULL; //erreur

}



//******************************** ListePieces *********************************

class ListePieces

{

public:

ListePieces();

~ListePieces();

void Inserer(Piece*);

Piece* LirePremier() const;

int LireTotal() const { return wTotal; }

Piece* operator[](int) const;

Piece* Rechercher(int& position, int NumPiece) const;

void Traiter() const;

private:

NoeudPieces* pTete;

int wTotal;

};



ListePieces::ListePieces():

pTete(0),

wTotal(0)

{}



ListePieces::~ListePieces()

{

delete pTete;

}



Piece* ListePieces::LirePremier() const

{

if(pTete)

return pTete->LirePiece();

else

return NULL; //interception d'erreur

}



Piece* ListePieces::operator[](int Decalage) const

{

NoeudPieces* pNoeud = pTete;

if(!pTete)

return NULL; //interception d'erreur



if(Decalage > wTotal)

return NULL; //erreur



for(int i=0; i<Decalage; i++)

pNoeud = pNoeud->LireSuivant();



return pNoeud->LirePiece();

}



Piece* ListePieces::Rechercher(int& Position, int NumPiece) const

{

NoeudPieces* pNoeud = 0;

for(pNoeud=pTete, Position=0;

pNoeud!=NULL;

pNoeud=pNoeud->LireSuivant(), Position++)

{

if(pNoeud->LirePiece()->LireNumPiece() == NumPiece)

break;

}

if(pNoeud == NULL)

return NULL;

else

return pNoeud->LirePiece();

}



void ListePieces::Traiter() const

{

if(!pTete)

return;

NoeudPieces* pNoeud=pTete;

do

pNoeud->LirePiece()->Afficher();

while( pNoeud = pNoeud->LireSuivant() );

}



void ListePieces::Inserer(Piece* pPiece)

{

NoeudPieces* pNoeud = new NoeudPieces(pPiece);

NoeudPieces* pEnCours = pTete;

NoeudPieces* pSuivant = 0;



int Nouveau = pNoeud->LirePiece()->LireNumPiece();

int Suivant = 0;

wTotal++;



if(!pTete)

{

pTete = pNoeud;

return;

}



//si celui-ci est plus pettit que Tete,

//il devient le noeud de tête.

if(pTete->LirePiece()->LireNumPiece() > Nouveau)

{

pNoeud->DefSuivant(pTete);

pTete = pNoeud;

return;

}



for(;;)

{

//si pas de suivant, ajouter celui-ci

if(!pEnCours->LireSuivant())

{

pEnCours->DefSuivant(pNoeud);

return;

}



//s'il vient après celui-ci et avant le suivant,

//l'insérer ici, sinon lire le suivant

pSuivant = pEnCours->LireSuivant();

Suivant = pSuivant->LirePiece()->LireNumPiece();

if(Suivant>Nouveau)

{

pEnCours->DefSuivant(pNoeud);

pNoeud->DefSuivant(pSuivant);

return;

}

pEnCours = pSuivant;

}

}





//***************************** Fin de Classes.cpp *****************************



Fichier "main.cpp" :

/************************** Révision de la Partie 2 ****************************

/

/ Programme de démonstration de liste chaînée.

/

/ Classes :

/ -Piece : contient les n° de pièces et d'autres info.

/ -NoeudPieces : noeud dans une ListePieces

/ -ListePieces : mécanisme pour une liste cheînée de pièces

/

/******************************************************************************/







//*************************** Début du Programme *******************************



//***************************** Initialisation *********************************



#include "Classes.cpp" //déclarations et implémentations



//*************************** Corps du Programme *******************************



int main(int argc, char *argv[])

{

ListePieces LP;

Piece* pPiece = 0;

int NumPiece;

int Valeur;

int Choix;



while(1)

{

cout << "(0) quitter, (1)Auto, (2)Avion - Votre choix : ";

cin >> Choix;

if(!Choix)

break;



cout << "Entrez un numero de piece : ";

cin >> NumPiece;



if(Choix==1)

{

cout << "Millesime ? ";

cin >> Valeur;

pPiece = new PieceAuto(Valeur, NumPiece);

}

else

{

cout << "Reference moteur ? ";

cin >> Valeur;

pPiece = new PieceAvion(Valeur, NumPiece);

}



LP.Inserer(pPiece);

}

LP.Traiter();





system("PAUSE");

return EXIT_SUCCESS;

}

//**************************** Fin du Programme ********************************

2 réponses

Messages postés
3
Date d'inscription
dimanche 19 novembre 2000
Statut
Membre
Dernière intervention
17 juillet 2005

J'ai résolu mon problème en renommant le fichier "Classes.cpp" en "Classes.hpp".

Désopilant.



Sur ce, @+.
Messages postés
3
Date d'inscription
dimanche 19 novembre 2000
Statut
Membre
Dernière intervention
17 juillet 2005

J'ai oublié de précisé qu'il y a 2 fichiers (Classes.cpp et main.cpp).

Merci de prêter attention à mon problème.