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.