Discussion :

[Thiby]

Bonjour � tous,

Une fois encore merci de vous int�resser � mon probl�me.

Celui-ci n'est pas tr�s compliqu�, c'est juste que mes connaissances en Template sont assez vite limit�es.

J'ai d�clar� dans une classe le typedef suivant :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
	typedef struct T_Events
	{
		template<class T>T	*	action;
		CString				comment;
		struct T_Events		*	next;
	};

Ceci compile sans probl�me.

Mon probl�me est � l'initialisation de l'attribut "action" du typedef.
J'ai essay� plusieurs possibilit�s comme :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
 
T_Events *test = new T_Events();
test->action<MyClass1> = new MyClass1()

mais rien y fait.

Peut �tre que l'un d'entre vous peut me dire si au moins c'est possible de faire quelque chose dans ce genre et comment faire ou bien je me rabat sur autre chose...

Merci d'avance pour votre aide

[thoratou]

Bah d�j� c'est du C++ donc le typedef ici ne te sert � rien, ainsi que le struct � l'int�rieur de ta structure.

Pourquoi ne pas simplement faire une interface Action :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
struct T_Events
{
	Action* action;
	CString comment;
	T_Events* next;
};

Ensuite tu cr�er tes classes qui h�ritent de Action et le tour est jou�

[Thiby]

Merci Thoratou d'avoir r�pondu.

En effet je ne l'avais pas vu ainsi. J'�tais tellement � fond dans les templates que j'en ai oubli� le reste.
Je vais test� �� de suite.

[3DArchi]

Salut,
Si tu veux rester dans une approche g�n�rique, alors ce serait quelque chose comme �a :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
template<class T>
struct T_Events
{
	T* action;
	CString comment;
	T_Events<T>* next;
};

L'utilisation �tant simplement :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
	T_Events<MyClasse> evt;
	evt.action = new MyClasse;

Cependant :
1/ Pourquoi ne pas utiliser des pointeurs intelligents ?
2/ Pourquoi ne pas utiliser std::list ?

[Thiby]

Merci pour cette pr�cision. Toutefois dans l'exemple que tu fournis, il y a un probl�me dans mon cas. Le fait est que je n'ai pas forc�ment le m�me type d'un �l�ment � l'autre de ma liste cha�n�e. Du coup n'y a t'il pas un probl�me quand je dois d�clar� le pointeur *next ?

Le probl�me se pose aussi pour le std::list du coup... :s

Pour les pointeurs intelligents, j'avoue ne pas ma�triser du tout. Je me h�te de d�pouiller le tutoriel que tu m'as envoy� qui cela dit en passant a l'air tr�s bien fait.

Merci encore pour ta r�ponse.


Sinon j'ai mis en place la solution deThoratou, et j'avoue que c'est tellement simple et pratique que j'en ai honte de ne pas y avoir penser plus t�t... Bref!

[Goten]

Tu cherches une list h�t�rog�ne? Ca existe pas nativement..
Si t'en a quand m�me besoin faut te tourner vers du boost::any ou boost::variant selon le nombre de type diff�rent que tu as.

[3DArchi]

Salut

Le fait est que je n'ai pas forc�ment le m�me type d'un �l�ment � l'autre de ma liste cha�n�e. Du coup n'y a t'il pas un probl�me quand je dois d�clar� le pointeur *next ?

Le probl�me se pose aussi pour le std::list du coup... :s

Pour le probl�me syntaxique, tu peux utiliser le Type Erasure pr�sent� dans cet article. L'id�e �tant d'utiliser un peu d'h�ritage pour encapsul� un type variable :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
struct I_Events_Base
{
virtual ~I_Events_Base()=0;
};
template<class T>
struct T_Events : public I_Events_Base
{
	T action;
	CString comment;
};
 
std::list<I_Events_Base*>...

C�t� conception : � priori l'utilisation de l'h�ritage semble �tre li� � une impl�mentation telle quelle du pattern commande. L'approche g�n�rique permet d'utiliser non plus une interface d�finie par un 'ActionBase' mais n'importe quel objet 'foncteur' :

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
#include <iostream>
#include <string>
#include <queue>
#include <functional>
#ifdef _MSC_VER
#include <memory>
#else
#include <tr1/memory>
#endif
 
struct I_Events_Base
{
	virtual ~I_Events_Base()=0;
 
	void execute() const
	{
		do_execute();
	}
private:
	virtual void do_execute() const=0;
};
I_Events_Base::~I_Events_Base(){}
 
template<class T>
struct T_Events : public I_Events_Base
{
	T_Events(T action_,std::string comment_)
		:action(action_),comment(comment_)
	{}
 
private:
	void do_execute () const
	{
		std::cout<<"executing "<<comment<<std::endl;
		action();
	}
 
	T action;
	std::string comment;
};
 
template<class T> 
std::tr1::shared_ptr<T_Events<T> >
make_event(T action_, std::string comment_)
{
	return std::tr1::shared_ptr<T_Events<T> >(new T_Events<T>(action_,comment_));
}
 
struct Mouse_Event
{
	Mouse_Event(std::string event_, int x_pos_, int y_pos_)
		:m_event(event_),m_x_pos(x_pos_),m_y_pos(y_pos_)
	{}
	void operator()()const
	{
		std::cout<<"Mouse Event : "<<m_event<<" ( "<<m_x_pos<<" , "<<m_y_pos<<" )"<<std::endl;
	}
 
private:
	std::string m_event;
	int m_x_pos;
	int m_y_pos;
};
 
struct Key_Event
{
	Key_Event(std::string key_)
		:m_key(key_)
	{}
	void operator()()const
	{
		std::cout<<"Key Event : "<<m_key<<std::endl;
	}
 
private:
	std::string m_key;
};
 
 
void event_dummy()
{
	std::cout<<"dummy event "<<std::endl;
}
 
int main()
{
	std::queue<std::tr1::shared_ptr<I_Events_Base> >event_queue;
 
	event_queue.push(
		make_event(
			Mouse_Event("left_button",10,10),
			"mouse event"
		)
	);
 
	event_queue.push(
		make_event(
			Key_Event("l"),
			"key event"
		)
	);
 
	event_queue.push(
		make_event(
			event_dummy,
			"dummy event"
		)
	);
 
	while(!event_queue.empty())
	{
		event_queue.front()->execute();
		event_queue.pop();
	}
 
	return 0;
}

Pour les pointeurs intelligents, j'avoue ne pas ma�triser du tout. Je me h�te de d�pouiller le tutoriel que tu m'as envoy� qui cela dit en passant a l'air tr�s bien fait.

Raison de plus pour les utiliser. Si tu d�butes ou que tu as encore peu d'exp�rience, les pointeurs posent des probl�mes sont � l'origine de bon nombre de probl�mes. Les pointeurs intelligents permettent de s'en abstraire.