Appel de la bonne fonction dans une hiérarchie de classe

Bonjour =E0 tous.

Je dispose d'une hi=E9rarchie de classe o=F9 chaque classe sait g=E9rer
certains types de messages provenant du r=E9seau. Bien s=FBr lorsque ces
messages me parviennent, je ne dispose que de pointeur sur la classe
de base.

Exemple fictif :

Base Messages g=E9r=E9s: evenement, identification
^
|
D=E9riv=E9e1 Messages g=E9r=E9s: informations_joueurs, quitte
^
|
D=E9riv=E9e2 Messages g=E9r=E9s: d=E9placement, tir, ...

Je suis donc =E0 la recherche d'une solution pour que la bonne fonction
soit appel=E9e quand j'=E9cris du code du genre :

Base *base =3D ....;
base->traite_message( type_message, message ) // (a)

Et ce en fonction du type de message.

Une premi=E8re solution est de rendre traite_message virtuelle. Chaque
classe de la hi=E9rarchie *doit* l'impl=E9menter ainsi :

void ClasseDerivee::traite_message( std::string const &type_message,
Msg
message ) {
if (/* cette classe sait g=E9rer ce type de message */) {
// gestion du message
} else {
ClasseParente::traite_message( type_message, message );
}
}

Ainsi, =E0 chaque appel de traite_message, on est s=FBr que l'on passera
forc=E9ment par la classe qui sait traiter ce message.

Je trouve cette solution un peu bof. Ce qui m'ennuie surtout c'est
qu'il va =EAtre tr=E8s facile de faire des erreurs dans le code, en se
trompant de classe parente par exemple, ou en oubliant de surchager
traite_message() dans une classe qui n'en traiterait aucun, ce qui
aurait quand m=EAme pour effet de casse les appels en cha=EEnes =E0
traite_message().

Du coup, j'ai cherch=E9 une solution =E0 base de map et de pointeurs de
fonction : La classe de base va g=E9rer une map associant std::string
(suppos=E9 =EAtre un type de message) et pointeurs sur fonctions membres.
La m=E9thode traite_message, non virtuelle, va utiliser cette map pour
appeler la bonne m=E9thode.

-------------------------- code source -----------------------------
#include <iostream>
#include <map>
#include <string>

class Base {
protected:
typedef void (Base::*msg_handler_t)( std::string const &type );
// M=E9thode appel=E9e par les classes de la hi=E9rarchie pour indiquer
// qu'elles savent g=E9rer un certain type de message
void RegisterHandler( std::string const &type,
msg_handler_t handler )
{
m_type_to_handlers[ type ] =3D handler;
}
private:
typedef std::map<std::string, msg_handler_t> map_handlers_t;
map_handlers_t m_type_to_handlers;
void func_base( std::string const &type ) {
std::cerr << "Base::func_base\n";
}
public:
Base() {
RegisterHandler( "func_base", &Base::func_base );
}
void traite_message( std::string const &type ) {
map_handlers_t::iterator it =3D m_type_to_handlers.find( type );
if (it !=3D m_type_to_handlers.end()) {
((*this).*(it->second))( type );
} else {
std::cerr << type << " not found.\n";
}
}
virtual ~Base() {}
};

class Derived1 : public Base {
void func_derived( std::string const &type ) {
std::cerr << "Derived1::func_derived\n";
}
public:
Derived1() {
// ****
RegisterHandler("func_derived",
(msg_handler_t)&Derived1::func_derived);
}
virtual ~Derived1() {}
};

class Derived2 : public Derived1 {
void func_derived2( std::string const &type ) {
std::cerr << "Derived2::func_derived2\n";
}
public:
Derived2() {
// *****
RegisterHandler("func_derived2",
(msg_handler_t)&Derived2::func_derived2);
}
virtual ~Derived2() {}
};

int main() {

Base *base1 =3D new Base();
Base *base2 =3D new Derived1();
Base *base3 =3D new Derived2();

base1->traite_message( "undefined" ); // not found
base1->traite_message( "func_base" ); // ok
base1->traite_message( "func_derived" ); // not found
base2->traite_message( "func_base" ); // ok
base2->traite_message( "func_derived" ); // ok
base2->traite_message( "func_derived2" );// not found
base3->traite_message( "func_derived2" );// ok

delete base1;
delete base2;
delete base3;
}

------------------------- fin code source --------------------------

Cette m=E9thode semble fonctionner, mais j'ai un doute, notamment =E0
cause de la conversion que je dois faire aux lignes indiqu=E9e par des
ast=E9risques. Cette conversion de void (*Derived::)(std::string const
&) =E0 void (*Base::)( std::string const &) est-elle l=E9gale ?



Plus g=E9n=E9ralement, que pensez vous de ces deux mani=E8res de faire ?
Avez vous une pr=E9f=E9rence entre les deux, voire pour une troisi=E8me
m=E9thode que je n'ai pas vue ?

Bonne lecture et bon week-end =E0 tous,
Alexis Guillaume.