I'm looking for a more elegant way to write my generic listener dispatcher class. I also hope that this might be useful to others.

The core of the problem is: I want the following code to work:

int main()
{
    Foo a, b;
    GenericDispatcher<Listener> dispatcher;
    dispatcher.addListener(&a, "a");
    dispatcher.addListener(&b, "b");
    dispatcher.dispatch<&Listener::doThing>(6, 7);  // #1
    return 0;
}

I want dispatcher.dispatch<>() (#1) to be able to deduce the arguments and return type of the member function being passed as a template argument without me having to explicitly specify it.

I've had the need to write a lot of code to do with listeners with my latest project, and found I was re-writing a lot of those functions that handle registering/unregistering listeners, and dispatching events to listeners, so I had a go at a more generic approach.

Here's an example which works, but I'm forced to specify the return type and member function arguments when instantiating the dispatcher, meaning that I will only ever be able to dispatch stuff to functions with the same signature.

#include <iostream>
#include <string>
#include <map>

struct Listener
{
    virtual void doThing(int, int) = 0;
    virtual void doAnotherThing(int) = 0;
};

struct Foo : public Listener
{
    virtual void doThing(int a, int b)
    {
        std::cout << a*b << std::endl;
    }
    virtual void doAnotherThing(int a)
    {
        std::cout << a << std::endl;
    }
};

template <class LISTENER_CLASS, class RET_TYPE, class... PARAMS>
class GenericDispatcher
{
public:
    void addListener(LISTENER_CLASS* listener, std::string name)
    {
        m_Listeners[name] = listener;
    }

    template <RET_TYPE (LISTENER_CLASS::*func)(PARAMS...)>
    void dispatch(PARAMS... params)
    {
        for(auto it = m_Listeners.begin(); it != m_Listeners.end(); ++it)
            (it->second->*func)(params...);
    }
private:
    std::map<std::string, LISTENER_CLASS*> m_Listeners;
};

int main()
{
    Foo a, b;
    GenericDispatcher<Listener, void, int, int> dispatcher;  // This here sucks
    dispatcher.addListener(&a, "a");
    dispatcher.addListener(&b, "b");
    dispatcher.dispatch<&Listener::doThing>(6, 7);
    return 0;
}

What if I wanted to do this, for example?

int main()
{
    Foo a, b;
    GenericDispatcher<Listener, void, int, int> dispatcher;
    dispatcher.addListener(&a, "a");
    dispatcher.addListener(&b, "b");
    dispatcher.dispatch<&Listener::doThing>(6, 7);
    dispatcher.dispatch<&Listener::doAnotherThing>(6); // I want this to work as well
    return 0;
}

What I need is to be able to turn this:

GenericDispatcher<Listener, void, int, int> dispatcher;

int this:

GenericDispatcher<Listener> dispatcher;

Hi Juliean,

Thanks for the help! You're definitely on the right track. Unfortunately, PARAMS does have to be declared before the function signature, and since PARAMS is of variable length, it must be declared at the very end.

I played around with it a little more now and I've found a solution (doesn't quite comply to the original requirements I had, but it's fine too).

The template parameters for the class now only contain the listener:

template <class LISTENER_CLASS>
class GenericDispatcher

And I modified the dispatcher function to be:

template <class RET_TYPE, class... PARAMS>
void dispatch(RET_TYPE (LISTENER_CLASS::*func)(PARAMS...), PARAMS... params)
{
    for(auto it = m_Listeners.begin(); it != m_Listeners.end(); ++it)
        (it->second->*func)(params...);
}

If you pass the member function pointer as an argument, it allows the compiler to deduce its signature.

The entire code:

#include <iostream>
#include <string>
#include <map>

struct Listener
{
    virtual void doThing(int, int) = 0;
    virtual void doAnotherThing(float) = 0;
};

struct Foo : public Listener
{
    virtual void doThing(int a, int b)
    {
        std::cout << a*b << std::endl;
    }
    virtual void doAnotherThing(float a)
    {
        std::cout << a << std::endl;
    }
};

template <class LISTENER_CLASS>
class GenericDispatcher
{
public:
    void addListener(LISTENER_CLASS* listener, std::string name)
    {
        m_Listeners[name] = listener;
    }

    template <class RET_TYPE, class... PARAMS>
    void dispatch(RET_TYPE (LISTENER_CLASS::*func)(PARAMS...), PARAMS... params)
    {
        for(auto it = m_Listeners.begin(); it != m_Listeners.end(); ++it)
            (it->second->*func)(params...);
    }

private:
    std::map<std::string, LISTENER_CLASS*> m_Listeners;
};

int main()
{
    Foo a, b;
    GenericDispatcher<Listener> dispatcher;
    dispatcher.addListener(&a, "a");
    dispatcher.addListener(&b, "b");
    dispatcher.dispatch(&Listener::doThing, 6, 7);
    dispatcher.dispatch(&Listener::doAnotherThing, 4.32f);
    return 0;
}

If you pass the member function pointer as an argument, it allows the compiler to deduce its signature.

A new problem has arisen, demonstrated by the following code:

#include <iostream>
#include <string>
#include <map>


struct Vec2
{
        float x;
        float y;
};


struct Listener
{
    virtual void printVec2(const Vec2& vec) = 0;
};


struct Foo : public Listener
{
    virtual void printVec2(const Vec2& vec)
    {
        std::cout << vec.x << "," << vec.y << std::endl;
    }
};


template <class LISTENER_CLASS>
class GenericDispatcher
{
public:
    void addListener(LISTENER_CLASS* listener, std::string name)
    {
        m_Listeners[name] = listener;
    }


    template <class RET_TYPE, class... PARAMS>
    void dispatch(RET_TYPE (LISTENER_CLASS::*func)(PARAMS...), PARAMS... params)
    {
        for(auto it = m_Listeners.begin(); it != m_Listeners.end(); ++it)
            (it->second->*func)(params...);
    }


private:
    std::map<std::string, LISTENER_CLASS*> m_Listeners;
};


int main()
{
    Foo a, b;
    Vec2 vec;
    vec.x = 6.4f; vec.y = 3.4f;
    GenericDispatcher<Listener> dispatcher;
    dispatcher.addListener(&a, "a");
    dispatcher.addListener(&b, "b");
    dispatcher.dispatch(&Listener::printVec2, vec);
    return 0;
}

Which gives me the following compilation error:

$ g++ -W -Wall -Wextra -std=c++0x -I. -o test main.cpp
main.cpp: In function ‘int main()’:
main.cpp:52:50: error: no matching function for call to ‘GenericDispatcher<Listener>::dispatch(void (Listener::*)(const Vec2&), Vec2&)’
main.cpp:52:50: note: candidate is:
main.cpp:34:10: note: template<class RET_TYPE, class ... PARAMS> void GenericDispatcher::dispatch(RET_TYPE (LISTENER_CLASS::*)(PARAMS ...), PARAMS ...) [with RET_TYPE = RET_TYPE, PARAMS = {PARAMS ...}, LISTENER_CLASS = Listener]

    template <class RET_TYPE, class... PARAMS>
    void dispatch(RET_TYPE (LISTENER_CLASS::*func)(const PARAMS&...), const PARAMS&... params)
    {
        for(auto it = m_Listeners.begin(); it != m_Listeners.end(); ++it)
            (it->second->*func)(params...);
    }

Update: Explicitly declaring the template parameters solves the issue, without having to modify the dispatcher class:

int main()
{
    Foo a, b;
    Vec2 vec;
    vec.x = 6.4f; vec.y = 3.4f;
    GenericDispatcher<Listener> dispatcher;
    dispatcher.addListener(&a, "a");
    dispatcher.addListener(&b, "b");
    dispatcher.dispatch<void, const Vec2&>(&Listener::printVec2, vec);
    return 0;
}

Is there some way to use the "explicit" keyword on member functions? That is probably what I'm after.

template <typename ...P, typename ...O, typename R, typename C>
void stuff(C* self, R(C::*method)(P...), O&&... params)
{
  (self->*method)(params...);
}

struct foo {
  void bar(int, float) {}
};

int main()
{
  foo f;
  stuff(&f, &foo::bar, 1, 3);
}