[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.

[debutant] Probleme d heritage

C++

Vue hybride

Discussions similaires

Partager

Partager