Problème de template avec une queue

**Davidbrcz** · 21/08/2007, 18h36

Bonjour à tous.
J'essaie de créer un système de file d'évenement pour envoyer des messages entres des classes .
Voici le code que j'ai crée (c'est du test , donc c'est moche et ca pue

)

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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
#include <iostream>
#include <queue>
 
using namespace std;
 
class Event;
template <class T> class Module;
class GUI;
class Game;
template <class Type> class RealEvent;
 
template<typename T> class CSingleton
{
    public:
 
    static T* GetInstance(queue<Event*>& queue)
    {
        if(singleton==0)
        {
            singleton = new T(queue);     
        }
        return singleton;
    }
 
    static T* GetInstance(void)
    {
        if(singleton==0)
        {
            throw;    
        }
        return singleton;
    }
 
    static void Kill()
    {
        if(singleton!=0)
        {
            delete singleton ;
 
        }
    }
    protected:
 
 
    CSingleton() 
    {
        cout<<"Singleton crée"<<endl;
    }
 
    virtual ~CSingleton()
    {
        cout<<"Singleton détruit"<<endl;
    }
 
    static T *singleton;  
};
 
template <typename T> T* CSingleton<T>::singleton = 0;
 
class Event 
{
public:
    virtual void ProcessEvent(void) = 0 ;
    virtual ~Event(){}
};
 
template <class Type> class  RealEvent : public Event  
{
public:
    virtual void ProcessEvent(void)
    {
	Type::GetInstance()->TraiterEvent(this);
    }
 
    string GetCommande(void){return m_commande;}
 
    RealEvent(string commande)
	{
	    m_commande=commande;
	}
    virtual ~RealEvent(){}
 
 
 private:
	string m_commande;
};
 
template <class T> class Module
{
protected:
    queue<Event*>& m_queueevent;
 
public:
 
    virtual void TraiterEvent(RealEvent<T>* event)=0;
    virtual void Test()=0;
 
    Module(queue<Event*>& queue):m_queueevent(queue){}
    virtual ~Module(){}
 
};
 
class Game : public Module<Game>,public CSingleton<Game>
{
 
friend class CSingleton<Game>;
 
public:
 
    virtual void TraiterEvent(RealEvent<Game>* event)
    {
	cout<<"Commande Game"<<event->GetCommande();
	//delete event;
    }
 
    Game(queue<Event*>& queuep):Module<Game>(queuep){}
    virtual ~Game(){}
 
    virtual void Test()
    {
	RealEvent<GUI>* evt=new RealEvent<GUI>("test 0");
	m_queueevent.push(evt);
    }
};
 
class GUI : public Module<GUI>,public CSingleton<GUI>
{
 
friend class CSingleton<GUI>;
 
public:
 
    virtual void TraiterEvent(RealEvent<GUI>* event)
    {
	cout<<"Commande GUI"<<event->GetCommande();
	//	delete event;
    }
 
    virtual ~GUI(){}
    GUI(queue<Event*>& queuep):Module<GUI>(queuep){}
    virtual void Test()
    {
	RealEvent<Game>* evt=new RealEvent<Game>("test 1");
	m_queueevent.push(evt);
    }
 
};
 
int main (int argc,char* argv[])
{
    queue<Event*> queueevt;
 
    Game::GetInstance(queueevt)->Test();
    GUI::GetInstance(queueevt)->Test();
    const int size = queueevt.size();
 
    cout<<size<<endl;
    Event* e;
    for(int i=0;i<size;i++)
	{
	 e=queueevt.front();
	    queueevt.pop();
	    e->ProcessEvent();
	    delete e;
	}
 
    Game::Kill();
    GUI::Kill();
 
    return 0;
}

Et voici les erreurs :

erreur: no matching function for call to ‘std::queue<Event*, std::deque<Event*, std::allocator<Event*> > >::push(RealEvent<GUI>&)’
/usr/lib/gcc/i386-redhat-linux/4.1.2/../../../../include/c++/4.1.2/bits/stl_queue.h:214: note: candidats sont: void std::queue<_Tp, _Sequence>::push(const typename _Sequence::value_type&) [with _Tp = Event*, _Sequence = std::deque<Event*, std::allocator<Event*> >]
test.cpp: In member function ‘virtual void GUI::Test()’:
test.cpp:137: erreur: no matching function for call to ‘std::queue<Event*, std::deque<Event*, std::allocator<Event*> > >::push(RealEvent<Game>&)’
/usr/lib/gcc/i386-redhat-linux/4.1.2/../../../../include/c++/4.1.2/bits/stl_queue.h:214: note: candidats sont: void std::queue<_Tp, _Sequence>::push(const typename _Sequence::value_type&) [with _Tp = Event*, _Sequence = std::deque<Event*, std::allocator<Event*> >]
test.cpp: In function ‘int main(int, char**)’:
test.cpp:161: erreur: valeur void n'a pas été ignorée comme elle aurait dû l'être

Les 2 premières sont lié au push dans Game::Test et dans GUI::Test.
Je ne vois pas pourquoi elle apparaisent.
Résolue

Enfin la 3eme (erreur: valeur void n'a pas été ignorée comme elle aurait dû l'être) je ne vois pas d'où elle sort.

Je tire mon chapeau très bas a celui qui me met sur la voie pour les résoudre
Merci.

Edit: désolé pour le code un peu long.

Edit2 : je croit avoir vu dans la signature de quelqu'un site qui traduit les erreurs incompréhensible de la STL en quelque chose de buvable.Quelqu'un aune URL ou j'ai rêvé ?

screetch · 21/08/2007, 18h42

je crois que tu as oublie de faire deriver RealEvent de Event

pour la troisieme tu peux montrer a quelle ligne ca correspond dans le source ? parce que la ligne 154 est assez esoterique lorsque tu as copie colle le code ici

**Davidbrcz** · 21/08/2007, 18h44

Que je peu être bigleux

Ca résoud 1 et 2.
Mais il me reste la 3eme erreur.

J'ai édite le code , refait une compile et l'erreur tombe comme avant sur e=queueevt.pop();

screetch · 21/08/2007, 18h47

pour la troisieme, la fontion pop() ne fait que popper, elle ne renvoie pas la valeur. tu dois la recuperer avant avec back() ou un truc du genre

screetch · 21/08/2007, 18h48

pense a inclure <string> pour ne pas poster l'erreur 4 =)

**Alp** · 21/08/2007, 18h48

Je n'ai plus le nom en tête. STLFit ? hmm je crois pas.

En attendant, montre nous la ligne qui pose problème pour la 3ème erreur.

**Davidbrcz** · 21/08/2007, 18h51

screetch >> C'est ca.
Je croyais que pop renvoyait la valeur et l'enlevait.

Maintenat tout ca compile.

Merci.

Edit : Au passage comment trouvez vous l'organisation du code ?
Merci.

**koala01** · 22/08/2007, 03h07

Salut,

Au passage, je te déconseillerais le using namespace dans ce fichier...
Cela t'oblige, certes, à rajouter un std:: à tout ce qui vient de cet espace de nommage, mais ça laissera le choix à l'utilisateur de travailler ou non avec la directive

J'enverrais plutôt une référence constante comme paramètre du constructeur RealEvent, quitte à rajouter le mot cle explicit si tu ne veux pas permettre la conversion automatique de type entre std::string et RealEvent

Code :

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

RealEvent(string commande){

devenant

Code :

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

RealEvent(const /*std::*/string& commande)

(j'ai mi le std:: en commentaire pour te laisser libre de suivre mon premier conseil... ou non

)

*A la limite*, essaye de choisir une bonne fois entre le français et l'anglais, histoire de créer une certaine "homogénéité"

**HanLee** · 22/08/2007, 04h46

Envoyé par Alp

Je n'ai plus le nom en tête. STLFit ? hmm je crois pas.

STLFilt

**Davidbrcz** · 22/08/2007, 10h20

Envoyé par koala01

Au passage, je te déconseillerais le using namespace dans ce fichier...
Cela t'oblige, certes, à rajouter un std:: à tout ce qui vient de cet espace de nommage, mais ça laissera le choix à l'utilisateur de travailler ou non avec la directive

J'ai tout mit dans un seul fichier avec un using au dépard car c'est du test.
En production , oui , je ferai ce que tu conseille.

Envoyé par koala01

J'enverrais plutôt une référence constante comme paramètre du constructeur RealEvent, quitte à rajouter le mot cle explicit si tu ne veux pas permettre la conversion automatique de type entre std::string et RealEvent

Oui , je note.

Envoyé par koala01

*A la limite*, essaye de choisir une bonne fois entre le français et l'anglais, histoire de créer une certaine "homogénéité"

TraiterEvent ca sonne bien ,non ?

**koala01** · 22/08/2007, 11h36

Envoyé par Davidbrcz

TraiterEvent ca sonne bien ,non ?

Ah, ce que j'en dis...

J'ai bien précisé "A la limite"

**Davidbrcz** · 22/08/2007, 12h20

J'en profite .
Une autre petite question.
Commnt initialiser ceci :

Code :

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

1
2
3
4
5
6
7
 
class X 
{
protected:
static queue<Event*> m_queueevent;
}
queue<Event*> X::m_queueevent= ?

Il faut mettre quoi a la place de ?

Merci.

**koala01** · 22/08/2007, 12h41

Heuu, à pouf, je mettrais

Code :

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

queue<Event*> X::m_queueevent= queue<Event*>

Ceci dit, plutôt que de rendre la variable statique et de la faire partager par toutes les instance de X, je créerais volontiers un niveau d'abstraction supplémentaire, vraisemblablement basée sur le pattern visiteur, factory, facade ou autre du genre, selon les besoins, non

**Davidbrcz** · 22/08/2007, 12h46

Code :

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

queue<Event*> X::m_queueevent= queue<Event*>;

Compile pas.
gcc me crache :

expected primary-expression before ‘;’ token

Ceci dit, plutôt que de rendre la variable statique et de la faire partager par toutes les instance de X, je créerais volontiers un niveau d'abstraction supplémentaire, vraisemblablement basée sur le pattern visiteur, factory, facade ou autre du genre, selon les besoins, non

Pas par toutes les instance , par toute les classes dérivés.
De plus , ceci n'est que la base , dérière ca , ya des classes qui définisent une interface pour envoyer des messages et et pour les traiter.

Edit trouvé :
C'est

Code :

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

queue<Event*> X::m_queueevent= queue<Event*>();

**koala01** · 22/08/2007, 12h57

Envoyé par Davidbrcz

Code :

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

queue<Event*> X::m_queueevent= queue<Event*>;

Compile pas.
gcc me crache :

J'avais dit que c'était "à pouf"

Envoyé par Davidbrcz

Pas par toutes les instance , par toute les classes dérivés.
De plus , ceci n'est que la base , dérière ca , ya des classes qui définisent une interface pour envoyer des messages et et pour les traiter.

J'aurais presque tendance à dire "raison de plus"...

Tu crée une classe "interface" qui va permettre de gérer les différents événement...

Mais, chaque classe dérivée ne va jamais gérer qu'un seul événement à la fois.

Et c'est donc ton pattern visiteur, par exemple, qui va prendre en charge le fait qu'il faut gérer la liste des événements en choisissant quelle est la meilleur classe dérivée à utiliser

**Davidbrcz** · 22/08/2007, 13h00

Pas besoin.
La fonction qui recoit les event est directement appelé par l'event.
C'est bien pour cela que la classe RealEvent est template.
Pour pouvoir appelé la fonction qui traite les events de la classe qui lui est passée en paramètre lors de sa construction.

**koala01** · 22/08/2007, 13h38

C'est bien possible... et même probable

Disons que mes réactions tiennent à ce que je peux croire avoir compris

**Davidbrcz** · 22/08/2007, 14h11

Quand j'aurais réorganisé le code proprement(plusieurs fichiés ...), je le posterai ici.

**Davidbrcz** · 22/08/2007, 15h04

Voila l'archive : http://prog.codeblog.powa.fr/fileevent.tar.gz

NB: je sais que du code dans les .h c'est moche mais j'avais la flème de mettre lles fonctions dans des *.tpl *.cpp selon la classe.

Problème de template avec une queue

Langage C++

Discussions similaires

Partager

Partager