Discussion :

[theprince009]

est ce que c 'est possible de faire afficher a l'aide d'une methode dans une classe mere des variables de classe filles ?? et comment !! merci

[dragonjoker59]

A part en faisant du cast moche, non.

[themadmax]

Pas directement mais regarde ce simple 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
22
23
24
25
26
27
28
29
#include <iostream>
 
class A 
{
public:
	virtual void show() {};
};
 
class B : public A
{
	int var ;
public:
	B() : var(123) {}
	virtual void show()
	{
		std::cout << "var=" << var << std::endl ;
	}
};
 
void print(A* a)
{
	a->show();
}
 
int main()
{
	B b;
	print(&b);
}

[koala01]

Salut,

L'idéal est sans doute d'éviter de rendre la classe (que ce soit la classe mère ou la classe fille) responsable de l'affichage...

En effet, cela donne une responsabilité à la classe qu'elle ne devrait sans doute, conceptuellement parlant, pas avoir.

De plus, l'affichage peut prendre un grand nombre de formes, telles que l'affichage dans une console, dans un formulaire issu d'une bibliothèque quelconque, voire, qui sait, l'envoi vers des flux divers et variés.

La meilleure solution passe donc sans doute par quelque chose qui pourrait se rapprocher du DP visiteur:

Tu aurais une classe visiteur qui se rapprocherait 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
class Visitor
{
    public:
        /* virtual */ void visit(Derived1 const &  d1) const
        {
            /* ce qu'il faut faire */
        }
        /* virtual */ void visit(Derived2 const &  d1) const
        {
            /* ce qu'il faut faire */
        }
        /* virtual */ void visit(Derived3 const &  d1) const
        {
            /* ce qu'il faut faire */
        }
        /* ... */
};

et, d'un autre coté, ta hiérarchie de classes pourrait ressembler à

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

Grace au double dispatch que cela occasionne, il est possible de faire en sorte que le visiteur effectue une action particulière en fonction du type réel de la variable que tu souhaites visiter, et il est meme possible (si la fonction visit() est virtuelle) de créer une hiérarchie de visiteur qui adapte le comportement de celui-ci aux différents contextes que j'ai cité au début de mon intervention

[therwald]

Simple question de ma part: le découpage ne pourrait-il pas être de type:

• fournir donnée à afficher (responsabilité direct hiérarchie), avec format genre clé/valeur, xml ou json.
• afficher données (responsabilité hiérarchie d'afficheurs)