[debutant] Probleme d heritage

**Treuze** · 19/04/2006, 14h01

Bonjour a tous

Je commence slmt a utiliser les heritages et j ai bcp de mal ...

Je dois creer une base de donnees qui est en fait une liste de personnes.

Cette liste a ete cree avec un template afin de prendre n importe quel type

Les personnes seront des etudiants, des administratifs ou des profs.

Afin que la liste prenne en charge les 3 types (etudiants, profs, administratifs) , une classe abstraite personne est cree. Les 3 types de personnes sont un heritage public de la classe personne.

Je vous postes maintenant le code .. il est un peu long mais ej ne sais pas du tt jusqu ou peut remonter l erreur...

Voici le persones .h :

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
 
#ifndef PERSONNES_H
#define PERSONNES_H
 
#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <string.h>
#include "liste.h"
 
using namespace std;
 
#define FAUX    0
#define VRAI    ~FAUX
 
class personne { 
    private: 
        string nom ; 
        string prenom ;
        string etablissement ; 
    public:
        personne () : nom(""), prenom(""), etablissement(""){};
        personne (string nvnom, string nvprenom="", string nvetablis="") :
              nom(nvnom), prenom(nvprenom), etablissement(nvetablis){};
        virtual ~personne(){};
 
        virtual string get_nom() const;
        virtual string get_prenom() const;
        virtual string get_etablis() const;
        virtual string get_qualite() = 0;
        virtual int get_experience() = 0;
        virtual int get_emploitemps() = 0;
        virtual string get_emploi() = 0;
        virtual string get_filiere() = 0;
        virtual string get_branche() = 0;
        virtual int get_salaire() = 0;
 
        virtual personne& change_nom(string nvnom);
        virtual personne& change_prenom(string nvprenom);
        virtual personne& change_etablis(string nvetablis);
        virtual personne& change_qualite(string nvqualite)=0;
        virtual personne& change_experience(int nvexperience)=0;
        virtual personne& change_emploitemps(int nvemploitemps)=0;
        virtual personne& change_emploi(string nvemploi)=0;
        virtual personne& change_filiere(string nvfiliere)=0;
        virtual personne& change_branche(string nvsemestre)=0;
        virtual personne& change_salaire(int nvsalaire)=0;
 
        virtual void affiche() const;
 
}; 
 
class etudiant : public personne { 
    private : 
        // donnees specifiques a etudiant 
        string branche; 
        string filiere; 
        int emploitemps;
 
    public : 
 
        etudiant() : branche(""),filiere(""),emploitemps(0){};
 
        etudiant(string nvnom, string nvprenom,string nvbranche="", string    nvfiliere = "", int nvemploitemps = 0) : personne(nvnom, nvprenom),                  branche(nvbranche),filiere(nvfiliere),emploitemps(nvemploitemps){};
        ~etudiant(){};
 
 
        string get_branche() const;
        string get_filiere() const;
        int get_emploitemps() const;
 
        etudiant& change_branche ( string nvbranche);
        etudiant& change_filiere ( string nvfiliere);
        etudiant& change_emploitemps(int nvemploitemps);
        void affiche() const;
 
}; 
 
//template<class T>
class bddpersonnes {
 
    private :
        liste<personne> l;
    public : 
        bddpersonnes();
        bddpersonnes(const bddpersonnes& b){ liste<personne> l(b.l);};
        ~bddpersonnes();
 
        bddpersonnes& ajout(const personne& p);
        bddpersonnes& ajout(const bddpersonnes& b);
 
        bddpersonnes& suppr(const personne& p);
        bddpersonnes& suppr(int i);
        bddpersonnes& suppr_tete();
 
        //void affiche() const;
 
        //int longueur();
};
 
 
#endif

Voici le personnes.cc :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <string.h>
#include "personnes.h"
#include "liste.h"
 
using namespace std;
 
 
personne& personne :: change_nom(string nvnom){
 
nom = nvnom;
return *this;
}
 
personne& personne :: change_prenom(string nvprenom){
 
prenom = nvprenom;
return *this;
}
 
personne& personne :: change_etablis(string nvetablis){
 
etablissement = nvetablis;
return *this;
}
 
void personne :: affiche() const {
cout << "nom :"<<nom << "prenom :" << prenom;
}
 
 
 
etudiant& etudiant :: change_branche ( string nvbranche){
branche = nvbranche;
return *this;
}
 
etudiant& etudiant :: change_filiere ( string nvfiliere){
filiere = nvfiliere;
return *this;
}
 
etudiant& etudiant :: change_emploitemps(int nvemploitemps){
emploitemps = nvemploitemps;
return *this;
}
 
void etudiant :: affiche() const{
personne :: affiche();
cout << "branche :" << branche << "filiere :" ;
cout << filiere << "charge hebdomadaire : " << emploitemps;
}
 
 
 
enseignant& enseignant :: change_qualite(string nvqualite){
qualite = nvqualite;
return *this;
}
 
enseignant& enseignant :: change_salaire(int nvsalaire){
salaire = nvsalaire;
return *this;
}
 
enseignant& enseignant :: change_experience(int nvexperience){
experience = nvexperience;
return *this;
}
 
void enseignant :: affiche() const{
personne :: affiche();
cout << "qualite :" << qualite << "salaire :" << salaire << "experience :" << experience << endl;
}
 
 
 
administration& administration :: change_emploi(string nvemploi){
emploi = nvemploi;
return *this;
}
 
administration& administration :: change_salaire(int nvsalaire){
salaire = nvsalaire;
return *this;
}
 
administration& administration :: change_experience(int nvexperience){
experience = nvexperience;
return *this;
}
 
void administration :: affiche() const{
personne :: affiche();
cout << "emploi : " << emploi << "salaire :" << salaire << "experience :" << experience << endl;
}
 
bddpersonnes& bddpersonnes :: ajout(const personne& p){
    liste<personne> :: operator+(p);
    return *this;
}
 
bddpersonnes& bddpersonnes :: ajout(const bddpersonnes& b){
    liste<personne> :: operator+(b);
    return *this;
}
 
bddpersonnes& bddpersonnes :: suppr(const personne& p){
    liste<personne> :: operator-(p);
    return *this;
}
 
bddpersonnes& bddpersonnes :: suppr(int i){
    liste<personne> :: operator-(i);
    return *this;
}
 
bddpersonnes& bddpersonnes :: suppr_tete(){
    liste<personne> :: supprime_tete();
    return *this;
}
        //void affiche() const;
 
        //int longueur();

Si vous trouvez des erreurs qui ne concernent meme pas le probleme posé , je prends aussi ! comme je vous l ai dis j ai bcp de problemes avec ces histoires d heritages ( et c est pas faute de m etre renseigne...) et ttes informations pourraient m aider a comprendre...

Merci !

**Treuze** · 19/04/2006, 14h03

Voila... le compilateur me renvoit de belles erreurs qui ont (je pense ) ttes la meme origine : l impossibilte de creer une liste avec un objet personnes :

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
 
 liste.h: In instantiation of ‘maillon<personne>’:
 personnes.cc:145:   instantiated from here
 liste.h:31: erreur: cannot declare field ‘maillon<personne>::data’ to be of abstract type ‘personne’
 personnes.h:15: note:   because the following virtual functions are pure within ‘personne’:
 personnes.h:29: note:  virtual std::string personne::get_qualite()
 personnes.h:30: note:  virtual int personne::get_experience()
 personnes.h:31: note:  virtual int personne::get_emploitemps()
 personnes.h:32: note:  virtual std::string personne::get_emploi()
 personnes.h:33: note:  virtual std::string personne::get_filiere()
 personnes.h:34: note:  virtual std::string personne::get_branche()
 personnes.h:35: note:  virtual int personne::get_salaire()
 personnes.h:40: note:  virtual personne& personne::change_qualite(std::string)
 personnes.h:41: note:  virtual personne& personne::change_experience(int)
 personnes.h:42: note:  virtual personne& personne::change_emploitemps(int)
 personnes.h:43: note:  virtual personne& personne::change_emploi(std::string)
 personnes.h:44: note:  virtual personne& personne::change_filiere(std::string)
 personnes.h:45: note:  virtual personne& personne::change_branche(std::string)
 personnes.h:46: note:  virtual personne& personne::change_salaire(int)
 personnes.cc: In member function ‘bddpersonnes& bddpersonnes::ajout(const personne&)’:
personnes.cc:145: erreur: cannot call member function ‘liste<T>& liste<T>::operator+(T) [with T = personne]’ without object
 personnes.cc: In member function ‘bddpersonnes& bddpersonnes::ajout(const bddpersonnes&)’:
 personnes.cc:150: erreur: no matching function for call to ‘liste<personne>::operator+(const bddpersonnes&)’
 liste.h:67: note: candidats sont: liste<T>& liste<T>::operator+(T) [with T = personne]
liste.h:68: note:                 liste<T>& liste<T>::operator+(const maillon<T>&) [with T = personne]
liste.h:69: note:                 liste<T>& liste<T>::operator+(const liste<T>&) [with T = personne]
 personnes.cc: In member function ‘bddpersonnes& bddpersonnes::suppr(const personne&)’:
 personnes.cc:155: erreur: cannot call member function ‘liste<T>& liste<T>::operator-(T) [with T = personne]’ without object
 personnes.cc: In member function ‘bddpersonnes& bddpersonnes::suppr(int)’:
 personnes.cc:160: erreur: cannot call member function ‘liste<T>& liste<T>::operator-(int) [with T = personne]’ without object
 personnes.cc: In member function ‘bddpersonnes& bddpersonnes::suppr_tete()’:
 personnes.cc:165: erreur: cannot call member function ‘void liste<T>::supprime_tete() [with T = personne]’ without object

J aimerai precise que le header liste.h ressemble a ca :

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
template <class T> class maillon { // Champs prives private: T data ; maillon<T> *suivant ; // Forme canonique de Coplien public: maillon(); maillon(const maillon<T>&) ; maillon(const T); ~maillon() ; ....

Mais qu elle marche tres bien avec des types classiques (int , char..)

**Matthieu Brucher** · 19/04/2006, 14h09

Tu fais une liste de personnes, donc chaque élément sera de type personne, type qui n'existe pas.
En fait, yu ne fais que des

Code :

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

personne* moi = new chef;

ou si chef hérite de personne, tu peux faire un

Code :

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

chef moi;

mais quand tu le copieras dans ta liste, si ça marchait, tu n'aurais accès qu'à la partie personne, la partie chef n'ayant pas été recopiée dans la liste !
Donc si tu hérites virtuellement de personne, classe abstraite pure, tu dois faire une list<personne*>.

**Laurent Gomila** · 19/04/2006, 14h09

Comme te le dit fort bien le compilo, tu n'as pas redéfini toutes les virtuelles pures dans tes classes dérivées.

**Treuze** · 19/04/2006, 14h21

Ok je vais essayer tt ca ! je vous tiens au courant merci !

**Treuze** · 19/04/2006, 14h30

est que declarer une methode virtuelle pure a pour seul but de signaler au compilateur que c est une classe abstraite ?

**Matthieu Brucher** · 19/04/2006, 14h32

En quelque sorte oui, on ne pourra jamais déclarer une variable de type "personne", et c'est ce que font les conteneurs si on fait un conteneur<personne>.

**Laurent Gomila** · 19/04/2006, 15h32

Envoyé par Treuze

est que declarer une methode virtuelle pure a pour seul but de signaler au compilateur que c est une classe abstraite ?

Disons que c'est plutôt une conséquence, à la base lorsque tu déclares une fonction virtuelle pure c'est pour forcer les classes dérivées à la redéfinir.

**Treuze** · 19/04/2006, 15h36

Bon je dosi avoir encore quelque probleme a comprendre ce concept ...

le compilateur me donne cette erreur que je n arrive pas a resoudre :

Code :

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

1
2
3
4
5
6
 
personnes.cc: In member function ‘bddpersonnes& bddpersonnes::ajout(const person ne&)’:
personnes.cc:145: erreur: no matching function for call to ‘liste<personne*>::op erator+(const personne&)’
liste.h:67: note: candidats sont: liste<T>& liste<T>::operator+(T) [with T = per sonne*]
liste.h:68: note:                 liste<T>& liste<T>::operator+(const maillon<T> &) [with T = personne*]
liste.h:69: note:                 liste<T>& liste<T>::operator+(const liste<T>&)  [with T = personne*]

Ce qui corresponds a cette ligne ds le personnes.cc :

Code :

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

1
2
3
4
5
 
bddpersonnes& bddpersonnes :: ajout(const personne& p){
    liste<personne*> :: operator+(p);
    return *this;
}

Ce qui est cense rappeler une de ces fonctions ds le liste.h :

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
 
// Classe maillon
template <class T> class maillon {
 
 
      // Champs prives
      private:
        T data ;
        maillon<T> *suivant ;
 
      // Forme canonique de Coplien
      public:
        ...
};
 
// Classe liste
template <class T> class liste {
      // Champs prives
      private:
        maillon<T>* tete;
        maillon<T>* fin ;
 
      // Forme canonique de Coplien
      public:
        liste() ;
        liste(const liste<T>&) ;
    ~liste() ;
        liste<T>& operator=(const liste<T>&) ;
 
      // Ajout de maillons
         liste<T>& operator+ (const T) ;
         liste<T>& operator+ (const maillon<T>&) ;
         liste<T>& operator+ (const liste<T>&) ;
 
};

ce qui implemente de la facon suivante :

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
 
template <class T>
liste<T>& liste<T> :: operator+ (const T valeur)
{ 
 
  if (longueur() == 0) // Si pas de liste 
    {
      tete = new maillon<T> (valeur); //Creation du maillon de tete (constructeur(int))
      fin = tete; // la fin est la tete (1 maillon ds la liste)
 
    }
  else
    {
      maillon<T>* tmp; 
      tmp = new maillon<T> (valeur); //creation d un nouveau maillon tmp
      (*tmp).pointeurnull(); // il pointe sur null
      (*fin).modifpointeur(*tmp); //la fin de la liste pointe sur le nouveau maillon tmp
      fin = tmp; // la fin est maintenat le nouveau maillon
 
    }
  return *this;
}
 
template <class T> 
liste<T>& liste<T> :: operator+ (const maillon<T>& m)
{
 
  *this + m.valeur(); // appel de la methode operator+(T)
  return *this;
}
 
template <class T>
liste<T>& liste<T> :: operator+ (const liste<T>& l)
{
  (*fin).modifpointeur(*l.tete);//la fin de la liste courante pointe sur le debut de la 2eme 
  fin = l.fin; // la fin de la liste parametre devient la fin de la liste courante 
  return *this;
}

Est ce que passe en reference l argument personne dans liste<personne*>::operator+(const personne&) a un sens ?

Est ce que je suis ioblige d utiliser l operateur de portee liste :: ds cette derniere fonction ?

Enfin comment puis je resoudre le probleme que m indique le compilo ?!

Merci d avance !

**Matthieu Brucher** · 19/04/2006, 15h39

C'est surtout que qu'ajouter des "const personne&" n'a pas de sens puisque ta liste est une liste de "personne*" !

**Treuze** · 19/04/2006, 15h49

alors une reference sur personne* ?

J ai modife le programme pour avoir ceci :

Code :

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

1
2
3
4
5
6
 
 
 bddpersonnes& bddpersonnes :: ajout(const personne* p){
    liste<personne*> :: operator+(p);
    return *this;
}

mais le compilo me dit :

Code :

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

1
2
 
personnes.cc:145: erreur: cannot call member function ‘liste<T>& liste<T>::operator+(const maillon<T>&) [with T = personne*]’ without object

et la encore une fois je comprends pas .....

**Treuze** · 19/04/2006, 15h59

En fait ca me paraissait plus logique de faire comme ca :

Code :

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

1
2
3
4
5
 
bddpersonnes& bddpersonnes :: ajout(const personne* p){
    liste<personne*> :: operator+(*p);
    return *this;
}

Mais je me retrouve avec ces erreurs :

Code :

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

1
2
3
4
5
6
 
 
personnes.cc:145: erreur: no matching function for call to ‘liste<personne*>::operator+(const personne&)’
liste.h:67: note: candidats sont: liste<T>& liste<T>::operator+(T) [with T = personne*]
liste.h:68: note:                 liste<T>& liste<T>::operator+(const maillon<T>&) [with T = personne*]
liste.h:69: note:                 liste<T>& liste<T>::operator+(const liste<T>&) [with T = personne*]

Edit : non en fait c pas plus logique pusique j ai une lsite de personne* ... j ai du mal avec ca moa...

**Laurent Gomila** · 19/04/2006, 16h08

Ta liste manipule des Personne*, donc il faut lui donner à manger des Personne*.

Ensuite tu appelles ton opérateur + comme s'il s'agissait d'une fonction statique, ou comme si ta classe dérivait de liste<Personne*>.

Tu ne voudrais pas l'appeler sur ta liste l par hasard ? Et puis un opérateur += ne serait pas plus approprié ?

**Treuze** · 19/04/2006, 16h38

Bon y a du progres... mais je sens que ca va etre pire maintenant...

J ai modifie ma fonction (sur les remarques de loulou , merci !!) de cette facon :

Code :

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

1
2
3
4
5
6
 
 
bddpersonnes& bddpersonnes :: ajout(personne* p){
    l.operator+(p);
    return *this;
}

J ai du aussi enlever le const devant personnes* ... mais pourquoi ???

Donc maintenat le compilo me retourne ca :

Code :

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

1
2
3
4
5
 
 
../sysdeps/i386/elf/start.S:115: référence indéfinie vers « main »
/tmp/ccfmHYGn.o: dans la fonction « bddpersonnes::ajout(personne*)     »:
personnes.cc:(.text+0x4af): référence indéfinie vers « liste<personne*>::operator+(personne*)»

Je n ai aucune idee d ou ca ca peut venir tt ca ...

**Laurent Gomila** · 19/04/2006, 16h55

J ai du aussi enlever le const devant personnes* ... mais pourquoi ???

Parce que ton opérateur + ne prend pas une pointeur const en paramètre ? Ne fais pas n'importe quoi avec les const, et lorsque tu en ajoutes ou retires un demande toi si c'est logique ou non.

Code :

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

l.operator+(p);

Si tu ne récupères pas le résultat de ton + ça ne risque pas de faire grand chose. Et pourquoi ne pas faire "l + p" ? C'est quand même le but des surcharges d'opérateur, de ne pas avoir une syntaxe style appel de fonction.

référence indéfinie vers « liste<personne*>::operator+(personne*)»

Tu as bien écrit le corps de cette fonction ?

**Treuze** · 19/04/2006, 17h06

Parce que ton opérateur + ne prend pas une pointeur const en paramètre ? Ne fais pas n'importe quoi avec les const, et lorsque tu en ajoutes ou retires un demande toi si c'est logique ou non.

bien cette methodes prends bien en parametre un const :

Code :

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

1
2
3
 
 
liste<T>& operator+ (const T) ;

Si tu ne récupères pas le résultat de ton + ça ne risque pas de faire grand chose.

en fait c est un operateur de type += mal ecrit ...

Tu as bien écrit le corps de cette fonction ?

Cette methode marche tres bien avec des types classiques comme int et char :

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
 
template <class T>
liste<T>& liste<T> :: operator+ (const T valeur)
{ 
 
  if (longueur() == 0) // Si pas de liste 
    {
      tete = new maillon<T> (valeur); //Creation du maillon de tete (constructeur(int))
      fin = tete; // la fin est la tete (1 maillon ds la liste)
 
    }
  else
    {
      maillon<T>* tmp; 
      tmp = new maillon<T> (valeur); //creation d un nouveau maillon tmp
      (*tmp).pointeurnull(); // il pointe sur null
      (*fin).modifpointeur(*tmp); //la fin de la liste pointe sur le nouveau maillon tmp
      fin = tmp; // la fin est maintenat le nouveau maillon
 
    }
  return *this;
}

Code :

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

1
2
3
4
5
6
7
 
template <class T>
maillon<T> :: maillon (const T valeur)
{ 
 data = valeur;
 suivant = NULL;
}

**Laurent Gomila** · 19/04/2006, 17h22

Code :

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

liste<T>& operator+ (const T) ;

En remplaçant T par Personne*, ça donne un T* const et non un T const *. Nuance.

en fait c est un operateur de type += mal ecrit ...

Pas bien

**Treuze** · 19/04/2006, 17h40

Pardon je le ferai plus ...

Mais pour mon probleme de reference indefinie , est ce que c est possible que mon compilo enj trouve pas mon liste.h(je sais aps trop je cherche) ?