Discussion :

[benzoben]

Salut,

le probleme que je soulève est surement bateau mais je ne le comprends pas.
J'ai la hiérarchie de classe 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
 
class Widget {
public:
    Widget() {}
 
    virtual ~Widget() {}
 
    virtual void draw() = 0;
};
 
class Button : public Widget {
public:
 
    //! Constructs a new button.
    Button() : Widget() {
 
    }
 
    ~Button() { }
 
    //! Draw the widget on screen
    void draw();
 
    virtual void handleFocusLost();
 
 
};
 
class ToggleButton : public Button{
public:
    //! Constructs a new button.
    ToggleAction(int x);
 
    virtual void handleFocusLost();
};

Ce sont des widgets pour une interface graphique. Il y a des boutons et des boutons particuliers, les ToggleButton.

Par ailleurs j'ai une classe Menu qui affiche tous ses widgets et qui maintient donc une liste de widget, déclarée ainsi dans la classe:

Code :

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

1
2
 
std::list<Button> actions_;

Finalement, dans une méthode de la classe Menu, je parcours les widgets pour en appeler la méthode handleFocusLost() ainsi:

Code :

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

1
2
3
4
5
6
7
 
for (std::list < Button>::iterator it = actions_.begin();
         it != actions_.end(); it++) {
        Button & b = *it;
 
        b.handleFocusLost();
    }

Mais a l'exécution (en mettant une trace spécifique a chaque implémentation de méthode), le code précédent appelle systématiquement l'implémentation de la classe Button même si j'ai à faire à une instance de ToggleButton.
Pourquoi est-ce le cas? La méthode handleFocusLost() est pourtant déclarée virtuelle.
J'ai remarqué que j'ai un bon fonctionnement lorsque j'utilise des pointeurs tel que:

Code :

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

std::list<Button*> actions_;

Quelqu'un a t-il l'explication?

[Michel_57]

Ca donne quoi si tu remplaces

Code :

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

1
2
        Button & b = *it;
        b.handleFocusLost();

Par

Code :

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

        (*it).handleFocusLost();

?

J'imagine que quand tu mets dans b tu perds les informations relatives à la classe fille.


En tout cas je ne sais pas quelle est la bonne pratique, mais moi j'utilise systématiquement des pointeurs plutôt que des objets directement.
Si t'as un pointeur tu peux le caster comme t'as envie, alors que si tu caste un objet je pense que tu peux perdre de l'information ...

Que quelqu'un me corrige si je me trompe, je n'ai pas l'habitude de donner des conseiuls ici


EDIT : j'essaie d'expliquer où je veux en venir : quand tu fais <Button> il stocke effectivement un Button et rien de plus. Tout ce qui dépasse est perdu. Et si tu fais <Button*> tu stockes quoiqu'il arrive une adresse, et ce qui se trouve à cette adresse peut être de type Button ou un descendant.

[r0d]

Bonjour,

je suis d'accord avec Michel_57: en faisant le cast (Button & b = *it; est un cast; caché, mais c'est bien un cast), tu perd la "partie" fille de l'élément.

[Mat007]

Salut,

C'est un problème de slicing.

MAT.

[nowahn]

Salut,

Pour préciser, c’est bien un problème de slicing, au moment du stockage du bouton dans la liste (tu ne peux rien y changer en modifiant le code du corps de ta boucle for, le slicing a eu lieu avant).

La solution est d’utiliser :

Code C++ :

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

std::list<Button*>

et même certainement mieux avec des pointeurs intelligents à la place des pointeurs simples.

[r0d]

La solution est d’utiliser :

Code C++ :

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

std::list<Button*>

Il existe bien d'autres solutions