xterminhate Si vis pacem, para bellum. | Je souhaiterais faire une classe de base callback optimisée utilisable dans tout programme présentant la particularité de lier evennements et traitements de manière statique (définie à la commpilation). Les classes callback et slot que je trouve sur le net sont toutes "dynamiques" (callback modifiable pendant l'exécution). Sauf erreur de ma part, ces solutions sont sans doute lourdes à l'excution si l'on n'a pas besoin de l'aspect dynamique.
Dans le code, voila l'idée : le calbback est paramétré à la compilation avec l'objet de traitement, la fonction membre de traitement et l'ensemble des types adequates.
Code :
- template< class t_callback_class,
- typename t_return,
- typename t_argument,
- t_return (t_callback_class::*fm)( t_argument ) >
- struct C
- {
- // constructeur
- C( t_callback_class& c ) :
- _callback_class( c )
- {
- }
- // fonction callback
- inline t_return operator()( t_argument arg )
- {
- (_callback_class.*fm)( arg );
- };
- private:
- t_callback_class& _callback_class;
- };
|
A l'utilisation, cela donne quelquechose du genre :
Code :
- struct A
- {
- A( const string& m ) :
- _message( m )
- {
- }
- void traitement( const string& s )
- {
- cout << _message << "traitement(" << s << " )" << endl;
- }
- private:
- string _message;
- };
- struct X : C< A, void, const string&, &A::traitement >
- {
- X() :
- C< A, void, const string&, &A::traitement >( a ),
- a( "Instance de X :" )
- {
- }
- void event()
- {
- (*this)( "event depuis X!" );
- }
- private:
- A a;
- };
- struct Y
- {
- Y() :
- a( "Instance de Y :" ),
- c( a )
- {
- }
- void event()
- {
- c( "event depuis Y!" );
- }
- private:
- A a;
- C< A, void, const string&, &A::traitement > c;
- };
- struct Z
- {
- Z( A& a ) :
- c( a )
- {
- }
- void event()
- {
- c( "event depuis Z!" );
- }
- private:
- C< A, void, const string&, &A::traitement > c;
- };
- int main()
- {
- X x;
- Y y;
- A a( "Instance globale :" );
- Z z1( a ), z2( a );
- x.event();
- y.event();
- z1.event();
- z2.event();
- }
|
Pensez vous que cela apporte réellement une optimisation par rapport à un callback "dynamique" ?
Toutes remarques sont les bienvenues aussi bien sur la démarche que l'implémentation.
-edit : L'objet de traitement est passé à la classe de base callback par référence (copie possible). L'idée est de laisser construire l'objet de traitement par l'utilisateur de la classe callback..
Message édité par xterminhate le 26-12-2004 à 14:59:03
---------------
Cordialement, Xterm-in'Hate...
|
