Comment puis-je créer une table de recherche basée sur le type afin de mettre en œuvre la répartition multiple en C++?

Question

Je tente de créer un système de messagerie dans lequel n'importe quelle classe dérivée de "Messageable" peut recevoir des messages basés sur la façon dont la fonction handleMessage() est surchargée. Par exemple:

class Messageable { 
    public: 
     void takeMessage(Message& message) { 
      this->dispatchMessage(message); 
     } 
    protected: 
     void bindFunction(std::type_info type, /* Need help here */ func) { 
      m_handlers[type] = func; 
     } 

     void dispatchMessage(Message& message) { 
      m_handlers[typeid(message)](message); 
     } 
    private: 
     std::map<std::type_info, /*Need help here*/ > m_handlers; 
    }; 

class TestMessageable : public Messageable { 
    public: 
     TestMessageable() { 
      this->bindFunction(
       typeid(VisualMessage), 
       void (TestMessageable::*handleMessage)(VisualMessage)); 

      this->bindFunction(
       typeid(DanceMessage), 
       void (TestMessageable::*handleMessage)(DanceMessage)); 
     } 
    protected: 
     void handleMessage(VisualMessage visualMessage) { 
      //Do something here with visualMessage 
     } 

     void handleMessage(DanceMessage danceMessage) { 
      //Do something here with danceMessage 
     } 
}; 

En un mot, je veux la version correcte de handleMessage à appeler en fonction de la valeur RTTI d'un message donné.

Comment est-ce que je peux l'implémenter de préférence sans une sorte de déclaration de commutateur/cas monolithique.

Answer 1

Vous devriez regarder dans le modèle Double Dispatch. Voir les informations here.

Vous devriez être en mesure de mettre en œuvre VisualMessage en tant que classe comme tel:

class VisualMessage : public Message 
{ 
    public: 
     virtual void dispatch(Messageable & inMessageable) 
     { 
      inMessageable.handleMessage(*this); 
     } 
}; 

puis l'appeler comme ceci:

Message & vMessage = VisualMessage(); 
Messageable & tMessageable = TestMessageable(); 
vMessage.dispatch(tMessageable); 

Il appellera ensuite TestMessageable :: handleMessage (VisualMessage & visualMessage

Cela est dû au fait que Message :: dispatch sera basé sur le type VisualMessage. Ensuite, lorsque VisualMessage :: dispatch appelle inMessageable.handleMessage (* this), il appellera le handleMessage droit, car le type * de ce pointeur est VisualMessage, pas Message.

Answer 2

Vous trouverez ce genre de mise en œuvre dans Scott Meyers plus efficace C++ et article - 31 est ce que vous voulez & bien expliqué.

Answer 3

Pour corriger votre code:

struct CompareTypeInfo 
    : std::binary_function<const std::type_info*, const std::type_info*, bool> 
{ 
    bool operator()(const std::type_info* a, const std::type_info* b) { 
     return a->before(*b); 
    } 
}; 

class Messageable 
{ 
protected: 
    typedef void (*handlefn)(Messageable *, Message &); 
    void bindFunction(const std::type_info& type, handlefn func) { 
     m_handlers[&type] = func; 
    } 

    void dispatchMessage(Message& message) { 
     m_handlers[&typeid(message)](this, message); 
    } 
    template <typename S, typename T> 
    static void handle(Messageable *self, Message &m) { 
     static_cast<S*>(self)->handleMessage(static_cast<T&>(m)); 
    } 
private: 
    std::map<const std::type_info*, handlefn, CompareTypeInfo> m_handlers; 
}; 

class TestMessageable : public Messageable 
{ 
public: 
    TestMessageable() 
     { 
     this->bindFunction(
      typeid(VisualMessage), &Messageable::handle<TestMessageable,VisualMessage>); 

     this->bindFunction(
      typeid(DanceMessage), &Messageable::handle<TestMessageable,DanceMessage>); 
     } 
public: 
    void handleMessage(VisualMessage visualMessage) 
     { 
     //Do something here with visualMessage 
     } 

    void handleMessage(DanceMessage danceMessage) 
     { 
     //Do something here with danceMessage 
     } 
    } 
}; 

Ces static_casts pourraient être dynamic_casts pour "sécurité supplémentaire" (en supposant qu'il ya des fonctions virtuelles) autour de coups de pieds. Mais la conception signifie que vous savez que self doit être un pointeur vers S, car sinon, cette fonction ne serait pas enregistrée, et vous savez que m doit faire référence à un T, car son ID de type a déjà été vérifié dans dispatchMessage. Donc, une distribution échouée ne peut pas arriver si la classe est utilisée correctement, et tout ce que vous pouvez faire si cela arrive est un débogage.

En fait, je pense que vous pouvez réduire le verbiage un peu plus en faisant bindFunction un modèle aussi:

template <typename S, typename T> 
void bindFunction(void) 
    { 
    m_handlers[&typeid(T)] = handle<S,T>; 
    } 

Ensuite, appelez avec:

this->bindFunction<TestMessageable,VisualMessage>(); 

Mais encore, vous pouvez voir pourquoi Steve Le code de double expédition de Rowe est généralement préféré ...

Answer 4

Ceci est une vieille question, mais la bibliothèque NUClear est conçue pour fournir un passage de message rapide et de type sécurisé dans une veine similaire à l'intention originale de cette question.

Full Disclosure: Je suis l'un des co-développeurs de NUCLÉAIRE

Dans ce cas, la classe TestMessageable est mis en œuvre en tant que NUClear::Reactor comme ceci:

#include <NUClear.h> 

// TestMessageable.h 
class TestMessageable : NUClear::Reactor { 
    public: 
     TestMessageable(NUClear::PowerPlant* powerPlant); 
    private: 
}; 

// TestMessageable.cpp 
#include "TestMessageable.h" 

TestMessageable::TestMessageable(NUClear::PowerPlant* powerPlant) 
: NUClear::Reactor(powerPlant) { 
    on<Trigger<VisualMessage>>([this](const VisualMessage& message) { 
     // Do something with VisualMessage here 
     // On can also take anything that is callable with a const& VisualMessage. 

     // Messages are sent using emit. 
     // If you don't have C++14 NUClear provides std::make_unique 
     auto classifiedData = std::make_unique<ClassifiedVision>(/* stuff */); 
     emit(std::move(classifieData)); 
    }); 

    on<Trigger<DanceMessage>>([this](const DanceMessage& message) { 
     // Do something with DanceMessage here. 
    }); 
}