Hmm. Je ne comprends pas vraiment ce que tu veux faire avec ça -- mais
je suppose que je ne suis pas censé comprendre :-)
Tu veux utiliser un nom avant de l'avoir déclarer. Pour moi, cela
indique un problème dans la conception.
Hmm. Je ne comprends pas vraiment ce que tu veux faire avec ça -- mais
je suppose que je ne suis pas censé comprendre :-)
Tu veux utiliser un nom avant de l'avoir déclarer. Pour moi, cela
indique un problème dans la conception.
Hmm. Je ne comprends pas vraiment ce que tu veux faire avec ça -- mais
je suppose que je ne suis pas censé comprendre :-)
Tu veux utiliser un nom avant de l'avoir déclarer. Pour moi, cela
indique un problème dans la conception.
Vincent Richard wrote
in news:3f25121c$0$1783$:Je suis confronté à un petit problème de syntaxe avec mon code :
template <class T>
class O
{
// ...
};
class A : public O <A::event>
{
public:
class event
{
// ...
};
};
Mais évidemment, le code ne compile pas ("A::event non déclaré"). Et
je ne peux pas utiliser la solution habituelle qui est de déclarer un
"class XXX" avant l'utilisation. Dans mon cas, ça serait :
Quelqu'un a-t-il une idée de comment faire, sachant que je souhaite
garder "event" comme une classe imbriquée dans A (pour des raisons de
facilité d'utilisation et de lisibilité ("event" concerne A)) ?
Ce n'est pas forcément ce que tu attends, mais cela t'en rapprochera un
peu.
class couche
{
class event {...};
public:
class A : public O<event> {...};
};
using couche::A;
_____
Vincent Richard <chere-loque.MARRE-DE-LA-PUB@wanadoo.fr.invalid> wrote
in news:3f25121c$0$1783$626a54ce@news.free.fr:
Je suis confronté à un petit problème de syntaxe avec mon code :
template <class T>
class O
{
// ...
};
class A : public O <A::event>
{
public:
class event
{
// ...
};
};
Mais évidemment, le code ne compile pas ("A::event non déclaré"). Et
je ne peux pas utiliser la solution habituelle qui est de déclarer un
"class XXX" avant l'utilisation. Dans mon cas, ça serait :
Quelqu'un a-t-il une idée de comment faire, sachant que je souhaite
garder "event" comme une classe imbriquée dans A (pour des raisons de
facilité d'utilisation et de lisibilité ("event" concerne A)) ?
Ce n'est pas forcément ce que tu attends, mais cela t'en rapprochera un
peu.
class couche
{
class event {...};
public:
class A : public O<event> {...};
};
using couche::A;
_____
Vincent Richard wrote
in news:3f25121c$0$1783$:Je suis confronté à un petit problème de syntaxe avec mon code :
template <class T>
class O
{
// ...
};
class A : public O <A::event>
{
public:
class event
{
// ...
};
};
Mais évidemment, le code ne compile pas ("A::event non déclaré"). Et
je ne peux pas utiliser la solution habituelle qui est de déclarer un
"class XXX" avant l'utilisation. Dans mon cas, ça serait :
Quelqu'un a-t-il une idée de comment faire, sachant que je souhaite
garder "event" comme une classe imbriquée dans A (pour des raisons de
facilité d'utilisation et de lisibilité ("event" concerne A)) ?
Ce n'est pas forcément ce que tu attends, mais cela t'en rapprochera un
peu.
class couche
{
class event {...};
public:
class A : public O<event> {...};
};
using couche::A;
_____
| Ce n'est pas forcément ce que tu attends, mais cela t'en rapprochera
| un peu.
|
| class couche {
| class event {...}; public:
| class A : public O<event> {...}; }; using couche::A;
L'as-tu essayé ?
| Ce n'est pas forcément ce que tu attends, mais cela t'en rapprochera
| un peu.
|
| class couche {
| class event {...}; public:
| class A : public O<event> {...}; }; using couche::A;
L'as-tu essayé ?
| Ce n'est pas forcément ce que tu attends, mais cela t'en rapprochera
| un peu.
|
| class couche {
| class event {...}; public:
| class A : public O<event> {...}; }; using couche::A;
L'as-tu essayé ?
il est clair qu'il faut laisser la classe 'event' dans la classe
A puisqu'elle en est caractéristique, mais on ne peut pas s'en
sortir en laissant la classe 'observable' template (impossible
à compiler):
j'utiliserais plutôt le polymorphisme pour m'en sortir ici, ie:
declarer une classe baseEvent de laquelle dériveraient toutes
les classes internes 'event' des classes qui en declarent (A
pour l'exemple ci-dessus). Observable redevient une classe non-template
et 'notify' travaille simplement sur les membres communs des
'event[s]'.
Par contre étant donné que je ne vois pas trop ce
que fait notify sur son argument, je ne peux pas préciser...
il est clair qu'il faut laisser la classe 'event' dans la classe
A puisqu'elle en est caractéristique, mais on ne peut pas s'en
sortir en laissant la classe 'observable' template (impossible
à compiler):
j'utiliserais plutôt le polymorphisme pour m'en sortir ici, ie:
declarer une classe baseEvent de laquelle dériveraient toutes
les classes internes 'event' des classes qui en declarent (A
pour l'exemple ci-dessus). Observable redevient une classe non-template
et 'notify' travaille simplement sur les membres communs des
'event[s]'.
Par contre étant donné que je ne vois pas trop ce
que fait notify sur son argument, je ne peux pas préciser...
il est clair qu'il faut laisser la classe 'event' dans la classe
A puisqu'elle en est caractéristique, mais on ne peut pas s'en
sortir en laissant la classe 'observable' template (impossible
à compiler):
j'utiliserais plutôt le polymorphisme pour m'en sortir ici, ie:
declarer une classe baseEvent de laquelle dériveraient toutes
les classes internes 'event' des classes qui en declarent (A
pour l'exemple ci-dessus). Observable redevient une classe non-template
et 'notify' travaille simplement sur les membres communs des
'event[s]'.
Par contre étant donné que je ne vois pas trop ce
que fait notify sur son argument, je ne peux pas préciser...
[PRECISION]
L'objet "observable" est censée envoyer des évènements, tandis que
l'objet "observer" les reçoit (classique) :
template <class EVENT_TYPE>
class observer
{
virtual ~observer() { }
virtual void update(const observable <EVENT_TYPE>* o,
const EVENT_TYPE& e);
};
[/PRECISION]il est clair qu'il faut laisser la classe 'event' dans la classe
A puisqu'elle en est caractéristique, mais on ne peut pas s'en
sortir en laissant la classe 'observable' template (impossible
à compiler):
j'utiliserais plutôt le polymorphisme pour m'en sortir ici, ie:
declarer une classe baseEvent de laquelle dériveraient toutes
les classes internes 'event' des classes qui en declarent (A
pour l'exemple ci-dessus). Observable redevient une classe non-template
et 'notify' travaille simplement sur les membres communs des
'event[s]'.
Oui, mais cela empêche d'implémenter "observer" pour plusieurs objets
différents. Tout du moins, cela nécessite de tout regrouper dans
une seule fonction et de tester le type d'évènement (pas très élégant,
à mon goût).
Méthode "template" :
class test : public observer <A::event>, public observer <B::event>
{
void update(const observable <A::event>* o, const A::event& e)
{
// traitement des évènements de A
}
void update(const observable <B::event>* o, const B::event& e)
{
// traitement des évènements de B
}
};
Méthode "non-template" :
class test : public observer
{
// ...
void update(const observable* o, const event& e)
{
if (typeid(e) == typeid(A::event))
{ /* traitement A */ }
else if (typeid(e) == typeid(B::event))
{ /* traitement B */ }
}
};Par contre étant donné que je ne vois pas trop ce
que fait notify sur son argument, je ne peux pas préciser...
"notify" permet aux classes qui héritent de "observable" d'envoyer
un évènement (l'argument) à chacun des observateurs enregistrés auprès
de l'observé (classe "observer" et std::vector <observer*> dans
l'objet "observable" non présents ici, j'avais simplifié).
Vincent
[PRECISION]
L'objet "observable" est censée envoyer des évènements, tandis que
l'objet "observer" les reçoit (classique) :
template <class EVENT_TYPE>
class observer
{
virtual ~observer() { }
virtual void update(const observable <EVENT_TYPE>* o,
const EVENT_TYPE& e);
};
[/PRECISION]
il est clair qu'il faut laisser la classe 'event' dans la classe
A puisqu'elle en est caractéristique, mais on ne peut pas s'en
sortir en laissant la classe 'observable' template (impossible
à compiler):
j'utiliserais plutôt le polymorphisme pour m'en sortir ici, ie:
declarer une classe baseEvent de laquelle dériveraient toutes
les classes internes 'event' des classes qui en declarent (A
pour l'exemple ci-dessus). Observable redevient une classe non-template
et 'notify' travaille simplement sur les membres communs des
'event[s]'.
Oui, mais cela empêche d'implémenter "observer" pour plusieurs objets
différents. Tout du moins, cela nécessite de tout regrouper dans
une seule fonction et de tester le type d'évènement (pas très élégant,
à mon goût).
Méthode "template" :
class test : public observer <A::event>, public observer <B::event>
{
void update(const observable <A::event>* o, const A::event& e)
{
// traitement des évènements de A
}
void update(const observable <B::event>* o, const B::event& e)
{
// traitement des évènements de B
}
};
Méthode "non-template" :
class test : public observer
{
// ...
void update(const observable* o, const event& e)
{
if (typeid(e) == typeid(A::event))
{ /* traitement A */ }
else if (typeid(e) == typeid(B::event))
{ /* traitement B */ }
}
};
Par contre étant donné que je ne vois pas trop ce
que fait notify sur son argument, je ne peux pas préciser...
"notify" permet aux classes qui héritent de "observable" d'envoyer
un évènement (l'argument) à chacun des observateurs enregistrés auprès
de l'observé (classe "observer" et std::vector <observer*> dans
l'objet "observable" non présents ici, j'avais simplifié).
Vincent
[PRECISION]
L'objet "observable" est censée envoyer des évènements, tandis que
l'objet "observer" les reçoit (classique) :
template <class EVENT_TYPE>
class observer
{
virtual ~observer() { }
virtual void update(const observable <EVENT_TYPE>* o,
const EVENT_TYPE& e);
};
[/PRECISION]il est clair qu'il faut laisser la classe 'event' dans la classe
A puisqu'elle en est caractéristique, mais on ne peut pas s'en
sortir en laissant la classe 'observable' template (impossible
à compiler):
j'utiliserais plutôt le polymorphisme pour m'en sortir ici, ie:
declarer une classe baseEvent de laquelle dériveraient toutes
les classes internes 'event' des classes qui en declarent (A
pour l'exemple ci-dessus). Observable redevient une classe non-template
et 'notify' travaille simplement sur les membres communs des
'event[s]'.
Oui, mais cela empêche d'implémenter "observer" pour plusieurs objets
différents. Tout du moins, cela nécessite de tout regrouper dans
une seule fonction et de tester le type d'évènement (pas très élégant,
à mon goût).
Méthode "template" :
class test : public observer <A::event>, public observer <B::event>
{
void update(const observable <A::event>* o, const A::event& e)
{
// traitement des évènements de A
}
void update(const observable <B::event>* o, const B::event& e)
{
// traitement des évènements de B
}
};
Méthode "non-template" :
class test : public observer
{
// ...
void update(const observable* o, const event& e)
{
if (typeid(e) == typeid(A::event))
{ /* traitement A */ }
else if (typeid(e) == typeid(B::event))
{ /* traitement B */ }
}
};Par contre étant donné que je ne vois pas trop ce
que fait notify sur son argument, je ne peux pas préciser...
"notify" permet aux classes qui héritent de "observable" d'envoyer
un évènement (l'argument) à chacun des observateurs enregistrés auprès
de l'observé (classe "observer" et std::vector <observer*> dans
l'objet "observable" non présents ici, j'avais simplifié).
Vincent
[...]
}
</CODE>
(comme tu l'as deviné, tu obtiens 'got it! :)' lors de l'exécution)
Mais, il est impossible qu'il ait un truc qui m'échappe dans
ce que tu veux faire...
[...]
}
</CODE>
(comme tu l'as deviné, tu obtiens 'got it! :)' lors de l'exécution)
Mais, il est impossible qu'il ait un truc qui m'échappe dans
ce que tu veux faire...
[...]
}
</CODE>
(comme tu l'as deviné, tu obtiens 'got it! :)' lors de l'exécution)
Mais, il est impossible qu'il ait un truc qui m'échappe dans
ce que tu veux faire...
J'ai trouvé une solution(?) qui ne t'empêche pas d'avoir un code
qui reste 'propre' mais ça rajoute un objet 'bidon' pour chacune de tes
classes observables, ie:
au lien de faire:
class A:public Observable<A::Event>{...}
qui reste définitivement incompilable, tu peut faire:
class A{
//la classe A normale...
};
class AObservable:public A,public Observable<A::Event>{};
qui rajoute évidemment une classe 'bidon', quoique le tout reste assez
cohérent. (on ne peut pas tout avoir!)
J'ai trouvé une solution(?) qui ne t'empêche pas d'avoir un code
qui reste 'propre' mais ça rajoute un objet 'bidon' pour chacune de tes
classes observables, ie:
au lien de faire:
class A:public Observable<A::Event>{...}
qui reste définitivement incompilable, tu peut faire:
class A{
//la classe A normale...
};
class AObservable:public A,public Observable<A::Event>{};
qui rajoute évidemment une classe 'bidon', quoique le tout reste assez
cohérent. (on ne peut pas tout avoir!)
J'ai trouvé une solution(?) qui ne t'empêche pas d'avoir un code
qui reste 'propre' mais ça rajoute un objet 'bidon' pour chacune de tes
classes observables, ie:
au lien de faire:
class A:public Observable<A::Event>{...}
qui reste définitivement incompilable, tu peut faire:
class A{
//la classe A normale...
};
class AObservable:public A,public Observable<A::Event>{};
qui rajoute évidemment une classe 'bidon', quoique le tout reste assez
cohérent. (on ne peut pas tout avoir!)