How to store class function to vector of pointers?

[Putarda]

For now, I made this:

	void f(sf::Event* event) {

		std::cout << event->mouseMove.x << std::endl;

	}

        engine.registerListener(sf::Event::EventType::KeyPressed, f);

--------------------------------------------------------------

	typedef void(*listenerFunction)(sf::Event*);

	class EventManager {

		friend class Engine;

	private:

		std::map<sf::Event::EventType, std::vector<listenerFunction>> listeners;

		void triggerEvent(sf::Event* event);

	public:

		void registerListener(sf::Event::EventType event_type, listenerFunction listener);

	};

And it worked fine. Then I tried with class function and there was an problem. So I searched the internet for a solution and I found I need to make static functin. It worked. My question is how can I store different class function pointers without making function static?

[JLBorges]

Use the polymorphic call wrapper std::function<> to wrap the call, and std::bind() to bind the this pointer.

Something like this:

#include <iostream>
#include <map>
#include <functional>
#include <vector>

namespace sf {

    struct Event {

        enum class EventType { KeyPressed /* ... */ } ;

        EventType type ;

        // ...
    };
}

struct EventManager {

    // http://en.cppreference.com/w/cpp/utility/functional/function
    // listener function is wrapped in a polymorphic call wrapper
    using listenerFunction = std::function< void(sf::Event) > ;

    // resister generic callable object
    void registerListener( sf::Event::EventType event_type, listenerFunction listener ) {

        listeners[event_type].push_back( std::move(listener) ) ;
    }

    template < typename CLASS, typename MEMFN > // register member function of class 'CLASS'
    void registerListener( sf::Event::EventType event_type, CLASS* object, MEMFN memfn ) {

        // http://en.cppreference.com/w/cpp/utility/functional/bind
        // generate a forwarding call wrapper after binding the first argument
        // (which becomes the this pointer)
        listeners[event_type].push_back( std::bind( memfn, object, std::placeholders::_1 ) ) ;
    }

    void triggerEvent( sf::Event event ) {

        const auto iter = listeners.find( event.type ) ;
        if( iter != listeners.end() ) for( const auto& fn : iter->second ) fn(event) ;
    }

    private: std::map< sf::Event::EventType, std::vector<listenerFunction> > listeners;

};


int main() {

    struct A {

        void member_handle_event( sf::Event ) {

            std::cout << "handle event in member function of main::A\n" ;
        }
    };
    A object_a;

    const auto non_member_handle_event = [] ( sf::Event ) {

            std::cout << "handle event in non-member function\n" ;
    };

    EventManager mgr ;

    // register member function of A
    mgr.registerListener( sf::Event::EventType::KeyPressed, std::addressof(object_a), &A::member_handle_event ) ;

    // register non-member function
    mgr.registerListener( sf::Event::EventType::KeyPressed, non_member_handle_event ) ;

    mgr.triggerEvent( { sf::Event::EventType::KeyPressed } ) ;
}

http://coliru.stacked-crooked.com/a/9a13ef62c1d2797b
http://rextester.com/RAGJM22198

[gunnerfunner]

You might consider making class EventManager a friend of the class (Engine?) that has the functions it needs to point to

[Putarda]

It's not working :/
http://i.imgur.com/9tvzFf4.png

[raschupkin]

Example by JBorges worked for me. Make sure that you have C++11 enabled. If you use gcc or clang++, add -std=c++11 option to command line.
Without C++11 you can use function pointers to call class member function:
for class

class A {
public:
    int member_function(int arg);
};

pointer to A::member_function can be declared and called:

int main()
{
    int (A::*pointer)(int arg) = &A::member_function; 
    A a;
    (a.*pointer)(1);
}

alternatively with typedef:

typedef int (A::*fpointer)(int arg);
int main()
{
    A a;
    fpointer pointer = &A::member_func;
    (a.*pointer)(1);
}