Problematische static Methode

Swordfish

Hi Volks!

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

Mathias

Ich glaube da kann man was wesentliches nicht lesen... (ein Satz versteckt sich da)

Swordfish

Ne, meine Kommentare sind Bestandteil des Satzes:

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

LordJaxom

Übergib doch den Zeiger den Du dem Event-Handler übergeben willst auch der Funktion event_loop?

Swordfish

@LordJaxtom: Danke, daß du beim Rätseln behilflich bist! So einfach isses aber nicht, da ich die Signatur von event_loop() nicht verändern kann und sie auch nicht selbst aufrufe.

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