Discussion :

[NoIdea]

En tentant de faire un GUI, je me suis rendu compte de quelques problèmes :

Considérons la classe ci-dessous (donnée avec le GUI)

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
class Button : public Objet
{
    private :
        //Choses hérités de Objets (ne sont pas réellement présents
        std::vector<Callback> Callbacks;
        void handle_event(Evenement*evenement)
        {
            for(unsigned int i=0;i<Callbacks.size();i++)
            {
                if(Callbacks[i].get_event()==evenement->get_event())
                    Callbacks[i](evenement);
            }
        }
        //Choses spécifiques au bouton (par exemple la police, le fond, ... ne sont pas indiqué ici
    public :
        //Les constructeurs ne sont pas présentés mais ils connectent tous ce dont il y a besoin
        enum Event{PRESSED,UNPRESSED,CLIKED, REDIM};//Ceci n'est qu'un exemple
        inline void emit(Evenement*evenement)
        {
            handle_event(evenement);
            safe_delete(evenement);
        }
        inline void connect(Function fc, int Declanch/*En réalité un Event*/)
        {
            Callbacks.push_back(Callback(fc,Declanch));
        }
 
};
 
class My_Button : public Button//On souhaite rajouter un type d'evenement
{
    private :
        //Que ce qui est hérité de Button
    public :
        enum Event{PRESSED,UNPRESSED,CLIKED, REDIM, CHANGED/*Attention*/};//On utilise le masquage pour introduire de nouveaux Event
 
};

Pas de problème dans ce cas ci car CHANGED est bien rajouté après les autres Event de Button ; ainsi, ils interfèrerons pas.

Cependant, dans les 2 cas ci-dessous il y a un problème :

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 My_Button : public Button//On souhaite rajouter un type d'evenement
{
    private :
        //Que ce qui est hérité de Button
    public :
        enum Event{PRESSED,CHANGED/*Attention*/,UNPRESSED,CLIKED, REDIM};//On utilise le masquage pour introduire de nouveaux Event
 
};
 
class My_Button : public Button//On souhaite rajouter un type d'evenement
{
    private :
        //Que ce qui est hérité de Button
    public :
        enum Event{PRESSED, REDIM, CHANGED/*Attention*/};//On utilise le masquage pour introduire de nouveaux Event
 
};

Hors, je ne peux demander a mon utilisateur de connaitre tous les Event prédéfinis de ma classe Button et de les recopier puis rajouter les nouveaux.

Ce qu'il faudrait, c'est pouvoir faire enum My_Button_Event{Button_Event,CHANGED}; auquel cas, chaque objet aurait pour Event : enum object_name(parent_object_name,Evenement propre à l'objet).

A ma surprise un tel code compile :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
 
using namespace std;
 
enum Button_Event{PRESSED,RELEASED,CLICKED,REDIM};
enum My_Button_Event{Button_Event,CHANGED};
 
int main()
{
    std::cout<<PRESSED<<RELEASED<<CLICKED<<REDIM<<CHANGED<<Button_Event;//Ne devrais pas compiler avec ce dernier cout
    return 0;
}

Mais malheureusement affiche 012310 et non 01234 avec une erreur de compilation pour Button_Event

Comment pallier à ce problème ?

[méphistopheles]

Je ne suis pas sûr de bien comprendre pourquoi tu utilise des enum, mais ne serait-il pas plus simple d'utiliser des tuples ou mieux, des classes de traits pour obtenir ce comportement ?

Sinon, avant que kohala ne tente de te recruter , sache qu'un projet de gui est actuellement lancé (bien que peu actif ces temps cis ) sur le forum.

Peut-être pourrais-tu y contribuer/t'en inspirer ?...

[NoIdea]

Le enum Event sert seulement d'identifiant pour savoir quel Fonction a connecter à quel signal (si tu relis handle_event, tu comprendras sans doute mieux...). Il me semblait qu'un enum serait parfait...

Quant à ce projet de GUI, j'en avais pas entendu parlé. De plus, c'est le troisième post que je poste sur ce projet de GUI et je pense que si kohala avait voulu me recruté, il l'aurait déjà fait.

[méphistopheles]

Le enum Event sert seulement d'identifiant pour savoir quel Fonction a connecter à quel signal (si tu relis handle_event, tu comprendras sans doute mieux...). Il me semblait qu'un enum serait parfait...

si cet enum n'est pas destiné à être modifié, oui. sinon , on risque justement d'avoir les problèmes de comportement que tu pointe. Problème que tu n'aurais pas avec des tuples.

[koala01]

Salut,

Sinon, avant que kohala ne tente de te recruter

KISSESSA kohala

[3DArchi]

Salut,
Tu masques tout simplement un symbole par un autre. Button_Event devient une des valeurs de My_Button_Event et n'est plus un type.
De la même façon dans ta classe dérivée tu redéfinis de nouveau symbole avec de nouvelle valeur.

Pour info, l'ensemble des messages windows est défini dans un .h et donc visible par tous le monde mais ce n'est peut être pas le meilleur exemple.

wxWidgets utilise héritage de type pour différencier les différents messages plutôt que des valeurs et des enums.

Je ne sais pas comment fonctionne Qt.

Je pense qu'il y a moyen de faire sans des enums et des valeurs. Regardes comment font d'autres API GUI (Qt, wxWidgets par expl).

[atttchoum]

Avec Qt il me semble que c'est une énumération qui contient une plage (entre QEvent::User et QEvent::MaxUser) réservé pour les events perso. et pour créer un event perso, on utilise la fonction registerEventType() qui va retourné un entier inclus dans cette plage et qui n'as pas encore été utilisé.

[Flob90]

Tu pourrais essayer quelque chose à base de TypeList de Int2Type, et de typedef pour simplifier le nommage. Quelque chose du genre :

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 Widget
{
	protected:
		typedef LOKI_TYPELIST_2(Loki::Int2Type<0>, Loki::Int2Type<1>) ListEvent;
 
	public:
		typedef Loki::TL::TypeAt<ListEvent, 0>::Result Pressed;
		typedef Loki::TL::TypeAt<ListEvent, 1>::Result Changed;
		inline void get_event(int) {} //en réalité un Int2Type<int>::value
};
 
class ExtendWidget : public Widget
{
	protected:
		typedef Loki::TL::Append<Widget::ListEvent, Loki::Int2Type<2> >::Result ListEvent;
 
	public:
		typedef Loki::TL::TypeAt<ListEvent, 2>::Result Cliked;
};

Ca permet un ajout simple d'event à la classe, on pourrait améliorer encore en rendant la numérotation automatique, il resterait un problème au niveau de létape de nommage, mais ca doit se résoudre via des macros.
Il resterait la question de comment faire si l'on ne veut pas ajouter des Event mais en enlever, en rélaité la question ne se pose pas au vue du LSP.
Le dernier point est que l'appel de la fonction est moins naturel :

Code :

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

1
2
3
 
ExtendWidget w;
w.get_event(ExtendWidget::Pressed::value);

[Goten]

J'allais parler de tag dispatching d'ailleurs. Note que même si j'adore ce que fait Alexandrescu je préconiserais plutôt une approche à base de mpl::vector (ou mpl::list ou autre selon les accés) qui sont quand même des solutions bien plus poussées . (notamment sur les instantiations de templates)

[Flob90]

Oui, n'importe quel bibliothèque de méta-prog (du moins bibliothèque qui propose des Typelist) fera l'affaire. (j'ai utilisé Loki parce que je suis en train de finir de lire MC++D.
A noter que dans le code que j'ai fait la Typelist sert pas à grand chose, mais je pense qu'elle devient utile si tu veus faire quelque chose de plus générique (ie s'en avoir à gérer les indice à la main). Notament récuperer le nombre d'event en utilisant la longueur de la liste et vérifier si un event existe bel et bien.

[Goten]

Oui, n'importe quel bibliothèque de méta-prog (du moins bibliothèque qui propose des Typelist) fera l'affaire.

Nan justement c'est bien ce que je dis :'). Si tu tiens à tes temps de compilation et à avoir un peu plus d'algorithmes et une plus grande uniformité (et simplicité de déclaration), y'a pas a tortiller c'est mpl :p.

[Flob90]

Faudra que je regarde de plus près mpl. Mais bon mpl loki ou autre, le principe change pas (pour résoudre le problème de l'op), ca sera juste plus rapide à la compilation :p

[Goten]

Si un peu quand même car mpl expose une interface beaucoup plus STL-like que loki::tp .

Mais je chipote :p.

[Emmanuel Deloget]

Que je comprenne : le but est, pour une classe dérivée, d'ajouter des types d'évènements qui ne sont pas compris par la classe de base, et donc de permettre plus de comportements dans la classe dérivée - quitte à ce que ces comportements ne soient plus compatibles avec ceux définis dans la classe de base ?

Je ne veux pas me mêler de ce qui ne me regarde pas en fin de compte, mais ça me semble être assez dangereux au niveau design.

Est-ce que tu pourrais expliciter ce que tu souhaites faire vraiment et donner un exemple concret ? Il y a peut-être une autre solution moins... enfin, plus propre.

[Flob90]

Si j'ai bien compris, son problème était d'ajouter des evenements possible pour une classe fille, mais techniquement ca lui demandais de redéfinir l'enum des événements possible dans chaque classe dérivé et ceci dans le bon ordre pour que le masquage n'interfère pas.

Niveau design ca ne me semble pas mal, après tout ajouter des événements ne fait qu'étendre la classe fille (ce qui est bien un but de l'héritage privé et répond bien aux principes OO), le problème était plus technique : éviter le masquage.

[NoIdea]

désolé pour le retard

Flob90, tu as parfaitement cerné mon problème :
Mon objectif est que l'enum est étendu dans la classe fille et non masqué.
J'ai toutefois trouvé une solution (bien qu'elle me satisfait moins) : un std::map.
Je vous montre le nouveau code (plus de chose ont changé ; utilisation de lambda (je suis en c++0x), ...)

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
 
#include <functional>
#include <unordered_map>
#include <iostream>
#include <string>
#include <vector>
class Evenement
{
    public :
        Evenement(){}
        std::string even;
        std::string show(){std::cout<<even; return even;}//Ne sert qu'a titre d'exemple
};
 
 
class Callback
{
    private :
        std::function<void(Evenement*)> function;
    public :
        Callback(std::function<void(Evenement*)> fc)
        {
            function=fc;
        }
        void operator()(Evenement*even)
        {
                function(even);
        }
 
};
 
using namespace std;
 
class Object
{
    private :
        std::unordered_map<std::string,std::vector<Callback>>Callbacks;
        bool has_key(std::string key)
        {
            if(Callbacks.find(key)==Callbacks.end())
                return false;
            return true;
        }
        void handle_event(std::string key, Evenement*even)
        {
            std::vector<Callback>&vect=Callbacks[key];
            for(unsigned int i=0;i<vect.size();i++)
                vect[i](even);
        }
    public :
        void emit(std::string key, Evenement* even=NULL)
        {
            if(even)
                   even->even=key;
            handle_event(key,even);
        }
        bool add_event(std::string key, Callback fc)
        {
            if(has_key(key))
            {
                std::vector<Callback>& vect=Callbacks[key];
                vect.push_back(fc);
                return false;
            }
            else
            {
                std::vector<Callback> vect(1,fc);
                Callbacks.insert(pair<std::string,std::vector<Callback>>(key,vect));
                return true;
            }
        }
        #define make_callback(a,...) Callback([__VA_ARGS__](Evenement*even){a})
        #define REF(a) &a
};
 
 
 
int main()
{
    Object a;
    std::string tmp="truc";
    Evenement even;
    a.add_event("show",make_callback
    (even->show();tmp="chose";,REF(tmp)));
    a.emit("show",&even);
    std::cout<<"\n"<<tmp;
    return 0;
}}

Toutefois l'utilisation de std::string dans un std::map est plus longue que l'utilisation d'un enum et totalement non_nécéssaire. Existe-il un autre moyen ?

Que je comprenne : le but est, pour une classe dérivée, d'ajouter des types d'évènements qui ne sont pas compris par la classe de base, et donc de permettre plus de comportements dans la classe dérivée

Oui !

quitte à ce que ces comportements ne soient plus compatibles avec ceux définis dans la classe de base ?

Non !!


De plus, pour ceux qui veulent un peu plus comprendre les évolutions du système de signaux/event, je vous conseille de regarder les différentes discussion que j'ai lancées :

http://www.developpez.net/forums/d95...bre-parametre/

http://www.developpez.net/forums/d94...nest-fonction/

[INFORMATIONS] Devrais-je poster toutes ces questions dans un même post dédié à mon GUI ou dans divers post ?
Devrais-je les poster directement dans le forum c++ au lieu de Débuter ?

[NoIdea]

En résumer, quelqu'un sait-il comment étendre un enum dans une classe fille au lieu de le masquer ?

[3DArchi]

Salut,

Devrais-je poster toutes ces questions dans un même post dédié à mon GUI ou dans divers post ?

A chaque problème, sa discussion même s'il concerne le même sujet. Tu peux faire un lien vers une ou des discussions pour contextualiser. Mais si tu poses différentes questions dans le même fil, ça va le rendre assez illisible.

Devrais-je les poster directement dans le forum c++ au lieu de Débuter ?

Tout dépend du niveau et du sujet de la question. Débuter pour les questions simples relevant d'un apprentissage du langage, Langage pour celle concernant le langage et ses constructions, C++ pour les questions ne relevant pas de ces cas, plus les forum des bibliothèques (boost, stl, Qt, etc), et enfin thread pour ce qui concerne la programmation concurrente.

En résumer, quelqu'un sait-il comment étendre un enum dans une classe fille au lieu de le masquer ?

Je ne vois pas comment c'est possible

[NoIdea]

Bon merci, je pense que je vais clore ce sujet si personne n'a de réponse.
Toutefois, 3dArchi, par "devrais-je continuer a poster dans débuter ou dans un autre forum" je voulais dire :
Penses-tu que le niveau des discussions posées relève d'un niveau débutant ?
Y a t-il une solution prévue à mon problème dans C++0x ? ou un moyen de le contourner ? (car il permet de comparer des int au lieu de std::string)

[koala01]

Bon merci, je pense que je vais clore ce sujet si personne n'a de réponse.
Toutefois, 3dArchi, par "devrais-je continuer a poster dans débuter ou dans un autre forum" je voulais dire :
Penses-tu que le niveau des discussions posées relève d'un niveau débutant ?

Tu peux de toutes façons compter sur l'équipe de modération pour déplacer une discussion qui serait vraiment mal placée