Discussion :

[theprince009]

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
class machine /* classe mere */
{
 
public:
 
  string alias;
  string id_internet;
  string locbureau;
  string locreseau;
  string datachat;
  string lieuachat;
  string marque;
  string fournisseur;
  int nserie,nserieas,duree;
  bool cdm,pa;
  float prix;
 
 
 
public:
	machine(){};
	~machine(){};
 
	virtual void affiche(){  /* methode de la classe mere */
 
 
cout<<" Numero de Serie :"<<nserie<<endl;
cout<<"Alias :"<<alias<<" ID Internet :"<<id_internet<<" Localisation Bureaux :"<<locbureau<<" Localisation Reseaux :"<<locreseau<<endl;
		cout<<"Date Achat :"<<datachat<<" Lieu d Achat :"<<lieuachat<<" Marque :"<<marque<<" Fournisseur :"<<fournisseur<<" Prix d'Achat :"<<prix<<endl;
		if(cdm==true) cout<<"Duree du contrat de maintenance (en mois) :"<<duree<<endl;
		if(pa==true) cout<<" Numero de serie du peripherique associe :"<<nserieas<<endl;
 
	}
 
 
	class ordinateur : public machine   /* class derive */
{ private:
 
int ram,diskdur;
string cartrx;
string proc;
 
float cadence;
 
public :
 
 
	ordinateur(){};
	~ordinateur(){};
 
 
 
	void affiche(){ /* la methode que je veux faire appel dans la methode affiche de la machine */
 
cout<<"Ram :"<<ram<<" Taille disk :"<<diskdur<<" Carte Reseau :"<<cartrx<<" Processeur :"<<proc<<endl;
		cout<<"Cadence du Processeur :"<<cadence<<endl;
 
	}
 
}
 
 
 
 
 
}

[BlueMonkey]

Bonsoir,

Ci-dessous 2 cas à distinguer :

1) Si lorsqu'on appelle la méthode affiche depuis un objet du type classe dérivée (ordinateur), il faut appeler la méthode affiche de la classe parent,
le plus simple est de ne pas la déclarer dans la classe dérivée.

2) Si depuis la méthode affiche de la classe dérivée, il faut appeler la méthode affiche de la classe parent, préciser la portée.
voir exemple :

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
class machine
{
     public:
         machine(){};
         virtual ~machine(){};
         //...
         virtual void affiche(){}
};

class ordinateur : public machine
{
     public:
         ordinateur (){};
         virtual ~ordinateur (){};
         //...
         virtual void affiche()
         {
                machine::affiche();   //appelle la méthode affiche de la classe parent
         }
};

Attention à déclarer en virtual les destructeurs de classe destinée à être dérivé.

[Amy8492]

Salut,

J'ai l'impression que tu as plutôt envie d'avoir une méthode affiche, générale, non virtuelle dans la classe mère, et une méthode afficheSpecifique, virtuelle, définie dans chaque dérivée et appelée par la méthode affiche.

Hope that helps

[theprince009]

bonsoir,

Merci , et oui je pense que je veux une methode general dans la classe parents et qui prend en consideration les variable de la classe derivé!! est ce possible ?

[BlueMonkey]

Bonjour,

Je voudrais une méthode générale dans la classe parents et qui prend en considération les variables de la classe dérivée !! Est ce possible ?

Par principe on ne peut pas faire appel à des variables non déclarées.
Comme la méthode affiche est dans la classe parent, et les variables sont dans les classes dérivées, ce n'est pas possible.

Donc soit tu fais comme conseillé par Amy8492,

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
 
class machine
{
     //...
         virtual void afficheOption() {}
 
         void affiche()
         {
             //...
             // affiche les éléments connus par la classe parent.
             //...
             afficheOption();  // fera appel à une méthode de la classe enfant pour le complément
         }
};
 
class ordinateur : public machine
{
         //...
         // ne déclare pas de méthode affiche ici.
 
         virtual void afficheOption() 
         {
              //affiche uniquement les informations complémentaires
         }
};

Soit tu utilises la méthode présentée plus haut en appelant la méthode de la classe parent dans la classe enfant.

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
 
class machine
{
     //...
 
         virtual void affiche()
         {
            // affiche les éléments connus par la classe parent.
         }
};
 
class ordinateur : public machine
{
         //...
         virtual void affiche() 
         {
              machine::affiche(); // affiche les éléments connus par la classe parent 
              //... écrit le code pour afficher les informations complémentaires.
         }
}

Le résultat à l'affichage peut être le même.
Seul change l'aspect conception, car les 2 méthodes ont leurs avantages et inconvénients.
(ordre d'affichage garanti par parent ou non, héritage à plus de 2 niveaux gérés ou non ...)

[koala01]

Salut,

En fait, je ne suis déjà pas persuadé qu'il soit opportun de donner la responsabilité de l'affichage à ta (hiérarchie de) classe(s)...

Je m'explique:

Typiquement, ce que tu appelles "affichage" et surtout la manière dont il va s'effectuer, va énormément dépendre du contexte.

Ce pourrait tout aussi bien être un affichage console "classique", mais, cela pourrait aussi prendre la forme d'un remplissage de formulaire, d'une écriture dans un fichier (log ou autre), voire, pourquoi pas, d'une transmission vers un socket quelconque.

De plus, on se rend compte que, le fait de parler de la responsabilité de l'affichage risque de mettre le principe de la responsabilité unique à mal : si une classe est responsable d'autre chose en plus de l'affichage, elle se retrouve avec... deux responsabilités (au moins), et c'est une situation qui devrait vraiment être évitée.

L'idéal serait donc de déléguer la responsabilité de l'affichage à une autre classe (voire à une autre hiérarchie de classes) qui ne s'occupera que de cela.

L'énorme avantage est que, si un jour, tu décides justement de permettre un affichage dans un contexte différent, il te "suffira" de créer une classe dérivée dont le comportement s'adaptera au nouveau contexte pour que tout fonctionne pour ce nouveau contexte sans que tu n'aies ni "à tout casser" ni à renoncer à l'affichage "classique" (celui que tu auras envisagé dans un premier temps)

La meilleure solution pour y arriver est, sans doute, de se baser sur le DP "visiteur"

Tu aurais donc une classe (appelons la Visitor, pour la facilité, meme s'il n'est pas exclu qu'un nom plus adapté soit envisageable ) visiteur proche de

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
class Visitor
{
    public:
        /* virtual */void visit(Derived1 const & visited) const
        {
            subVisit(visited);
            /* partie de l'affichage propre au type "Derived1" :D */
        }
        /* virtual */void visit(Derived2 const & visited) const
        {
            subVisit(visited);
            /* partie de l'affichage propre au type "Derived2" :D */
        }
        /* virtual */void visit(Derived3 const & visited) const
        {
            subVisit(visited);
            /* partie de l'affichage propre au type "Derived3" :D */
        }
    private:
        /* virtual */ void subVisit(Base const & visited) const
        {
            /* partie propre à l'affichage de la classe de base */
        }
};

et ta hiérarchie de classe deviendrait la partie "visitée" du pattern :

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
class Base
{
    public:
        virtual ~Base(){}
        virtual void accept(Visitor const & v) const = 0;
};
class Derived1 : public Base
{
    public:
        virtual ~Derived1 (){}
        virtual void accept(Visitor const & v) const{v.visit(*this);};
};
class Derived2 : public Base
{
    public:
        virtual ~Derived2 (){}
        virtual void accept(Visitor const & v) const{v.visit(*this);};
};
class Derived3 : public Base
{
    public:
        virtual ~Derived3 (){}
        virtual void accept(Visitor const & v) const{v.visit(*this);};
};

De cette manière, tant que la politique d'affichage (pour un contexte donné) ne changera pas, tu pourras ajouter autant de contexte (affichage dans un formulaire, envois vers un fichier ou un socket quelconque) que tu le voudras, tu n'auras pas à changer une seule ligne de l'existant : il te "suffira" de rajouter une classe dérivée de Visitor qui sera adaptée au contexte que tu veux ajouter

Il faut en effet te dire que s'il y a une chose dont on peut etre sur, c'est qu'on ne peut etre sur de rien, et que les besoins d'aujourd'hui sont très certainement incomplet par rapport à ceux de "demain".

Plus tu arriveras à séparer les différentes responsabilités, plus tu auras facile à faire évoluer l'existant de manière à rejoindre les besoins qui se feront jour par la suite

[theprince009]

merci tts le monde pour votre aide est ce que je peut utiliser la meme solution pour saisir les variable

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
 
class machine
{
 
public:
 
  string alias;
  string id_internet;
  string locbureau;
  string locreseau;
  string datachat;
  string lieuachat;
  string marque;
  string fournisseur;
  int nserie,nserieas,duree;
  bool cdm,pa;
  float prix;
 
 
 
public:
	machine(){};
	~machine(){};
 
	virtual void afficheOptions(){}
	virtual void saisiroptionord(){}
	virtual void saisiroptionecr(){}
 
 
 
 
	virtual void affiche(){
 
		cout<<" Numero de Serie :"<<nserie<<endl;
		cout<<"Alias :"<<alias<<" ID Internet :"<<id_internet<<" Localisation Bureaux :"<<locbureau<<" Localisation Reseaux :"<<locreseau<<endl;
		cout<<"Date Achat :"<<datachat<<" Lieu d Achat :"<<lieuachat<<" Marque :"<<marque<<" Fournisseur :"<<fournisseur<<" Prix d'Achat :"<<prix<<endl;
		if(cdm==true) cout<<"Duree du contrat de maintenance (en mois) :"<<duree<<endl;
		if(pa==true) cout<<" Numero de serie du peripherique associe :"<<nserieas<<endl;
		afficheOptions();
 
 
	}
 
 
	virtual void saisir() { 
	int choix;
	int t,v;
 
		cout<<"Donner Le Numero de Serie :"<<endl;
		cin>>nserie;
		cout<<"Donner L'Alias :"<<endl;
		cin>>alias;
		cout<<"Donner L'ID Internet :"<<endl;
		cin>>id_internet;
		cout<<"Donner La Localisation dans les Bureaux :"<<endl;
		cin>>locbureau;
		cout<<"Donner La Localisation Reseaux :"<<endl;
		cin>>locreseau;
		cout<<"Date d achat :"<<endl;
		cin>>datachat;
		cout<<"Lieu d achat :"<<endl;
		cin>>lieuachat;
		cout<<"Marque :"<<endl;
		cin>>marque;
		cout<<"Fournisseur :"<<endl;
		cin>>fournisseur;
		cout<<" Prix d'Achat :"<<endl;
		cin>>prix;
 
	do {
						cout<<"Avec ou sans Contrat de maintenance ? (0:oui , 1:non):"<<endl;
						cin>>v;}
						while ((v!=0)&&(v!=1)); 
 
						if(v!=1)
						{	cdm=true;
						cout<<"Duree du contrat de maintenance :"<<endl;
						cin>>duree;}
 
						cdm=false;
 
	do {
						cout<<"Peripherique associé ? (0:oui , 1:non):"<<endl;
						cin>>t;}
						while ((t!=0)&&(t!=1)); 
 
						if(t!=1)
						{	pa=true;
						cout<<"Numero du serie du peripherique associé :"<<endl;
						cin>>nserieas;}
 
						pa=false;
		do{
		cout<<"Quel type de machine (0: Ordinateur, 1: Ecran) :"<<endl;
		cin>>choix;
 
		switch(choix) 
		{ case 0: saisiroptionord();
		  case 1: saisiroptionecr();
 
		}} while ((choix!=0)&&(choix!=1));
	}
 
 
 
 
 
}
 
 
 
class ordinateur : public machine
{ private:
 
int ram,diskdur;
string cartrx;
string proc;
 
float cadence;
 
public :
 
 
	ordinateur(){};
	~ordinateur(){};
 
 
	virtual void saisiroptionord(){
	cout<<"Ram :"<<endl;
	cin>>ram;
	cout<<" Taille disk :"<<endl;
	cin>>diskdur;
	cout<<" Carte Reseau :"<<endl;
	cin>>cartrx;
	cout<<" Processeur :"<<endl;
	cin>>proc;
	cout<<"Cadence du Processeur :"<<endl;
	cin>>cadence;
	}
 
	virtual void afficheOptions(){
		cout<<"Ram :"<<ram<<" Taille disk :"<<diskdur<<" Carte Reseau :"<<cartrx<<" Processeur :"<<proc<<endl;
		cout<<"Cadence du Processeur :"<<cadence<<endl;
 
	}}

[3DArchi]

Salut,
En gros, d'accord avec Koala pour sortir l'affichage et la saisie de la classe.

Cependant, si ton exercice t'impose de définir dans la classe les fonctions d'affichage et de saisie, alors effectivement tu peux adapter les solutions de BlueMonkey pour la saisie.