Attribut template d'un typedef struct

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:

---

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:

---

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

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:

---

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é

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.

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

Code:

---

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:

---

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 ?

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!

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.

Salut

Citation:

---

Envoyé par Thiby

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:

---

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:

---

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; }

---

Citation:

---

Envoyé par Thiby

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.