Folgendes Problem:

Ich hab' eine Klasse und möchte

#include <iostream>
#include <vector>

class foo {

    public:

        typedef void ( *event_handler_fp )( foo *foo_instance );

    private:

        static std::vector< event_handler_fp > event_handler_map;
        unsigned int num_event_handlers;

    public:

        foo( ) : num_event_handlers( 0 ) {
        }

        void add_event_handler( event_handler_fp event_handler ) {
            event_handler_map.push_back( menu_handler );
            ++num_event_handlers;           
        }

        void bar( ) {
            std::cout << "foo::bar( )" << std::endl;
        }

        static void event_loop( ) {
            unsigned int event;
            do {
                event = wait_event( );
                event_handler_map.at( event )( /* hier */ );
            } while( event );
        }
};

sinngemäß einen this-Zeiger übergeben, welcher jedoch logischerweise in einer static-Methode nicht existiert, um in den

void bar_event( foo *foo_instance )  // event-Handlern
{
    cout << "bar_event( )" << endl;
    foo_instance->bar( );            // foo::bar( )
}

aufrufen zu können.

Hat jemand 'ne Idee, wie man soetwas lösen könnte?

Greetz, Swordfish

Swordfish schrieb:

Ich hab' eine Klasse und möchte hier sinngemäß einen this-Zeiger übergeben, welcher jedoch logischerweise in einer static-Methode nicht existiert, um in den event-Handlern foo::bar( ) aufrufen zu können.

Hat jemand 'ne Idee, wie man soetwas lösen könnte?

Greetz, Swordfish

Hab' mir aber folgendes überlegt:

#include <iostream>
#include <vector>

class foo {

    public:

        typedef void ( *event_handler_fp )( foo *foo_instance );

    private:
// hier >--
        struct event_handler_data {
            foo *foo_instance;
            event_handler_fp event_handler;
        };  
// --------
//      static std::vector< event_handler_fp > event_handler_map;

// hier >--
        static std::vector< /* !! */ event_handler_data /* !! */ > event_handler_map;
// --------

        unsigned int num_event_handlers;

    public:

        foo( ) : num_event_handlers( 0 ) {
        }

        void add_event_handler( event_handler_fp event_handler ) {
// hier >--
            event_handler_data ehd;
            ehd.foo = this;
            ehd.event_handler = event_handler;
            event_handler_map.push_back( ehd );
// --------
            ++num_event_handlers;          
        }

        void bar( ) {
            std::cout << "foo::bar( )" << std::endl;
        }

        static void event_loop( ) {
            unsigned int event;
            do {
                event = wait_event( );
// hier >--
                event_handler_map.at( event ).event_handler( 
                    event_handler_map.at( event ).foo
                );
// --------
            } while( event );
        }
};

Fällt jemandem eine elegantere Lösung ein?

Greetz, Swordfish