3

関数 handleMessage() のオーバーロード方法に基づいて、「Messageable」から派生したクラスがメッセージを受信できるメッセージング システムを作成しようとしています。例えば：

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

簡単に言えば、特定のメッセージの RTTI 値に基づいて、適切なバージョンの handleMessage を呼び出す必要があります。

モノリシックな switch/case ステートメントを使用せずに、これを実装するにはどうすればよいでしょうか。

4

4 に答える 4

4

Double Dispatch パターンを調べる必要があります。こちらの情報を参照してください。

次のようなクラスとして VisualMessage を実装できるはずです。

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

そして、次のように呼び出します。

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

次に、TestMessageable::handleMessage(VisualMessage & visualMessage) を呼び出します。

これは、Message::dispatch が VisualMessage タイプに基づくためです。次に、VisualMessage::dispatch が inMessageable.handleMessage(*this) を呼び出すと、*this ポインターの型が Message ではなく VisualMessage であるため、適切な handleMessage が呼び出されます。

于 2009-12-01T08:56:45.383 に答える
1

コードを修正するには:

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

これらの static_casts は、「追加の安全性」のために dynamic_casts にすることができます (仮想関数が動き回っていると仮定します)。しかし、この設計は、self が S へのポインターでなければならないことを知っていることを意味します。そうしないと、この関数が登録されず、m が T を参照しなければならないことがわかります。したがって、クラスが正しく使用されていれば、キャストの失敗は発生しません。発生した場合にできることはデバッグだけです。

実際には、 bindFunction もテンプレートにすることで、言い回しをもう少し減らすことができると思います。

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

次に、次のように呼び出します。

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

それでも、Steve Rowe のダブル ディスパッチ コードが通常好まれる理由がわかります...

于 2009-12-01T12:59:10.617 に答える
0

これは古い質問ですが、NUClearライブラリは、この質問の本来の意図と同様に、高速で型安全なメッセージの受け渡しを提供するように設計されています。

完全開示: 私は NUClear の共同開発者の 1 人です。

この場合、TestMessageableクラスは次のNUClear::Reactorように実装されます。

#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.
    });
}
于 2013-11-21T03:35:26.000 に答える
-1

Scott Meyers の More Effective C++にそのような種類の実装があり、 アイテム - 31 はあなたが望むものであり、うまく説明されています。

于 2009-12-01T10:47:41.150 に答える