Zeiger auf Memberfunktion



  • This post is deleted!


  • Memberfunktionszeiger sind nicht in gleicher Weise zu benutzen, wie Nicht-Memberfunktionszeiger.

    Lies dir das mal durch:
    http://www.newty.de/fpt/index.html



  • Memberpointer haben eine ganz andere Syntax und auch einen anderen Typ als Funktionszeiger. Du solltest dich nochmal zu dem Thema Zeiger auf Memberfunktionen einlesen.

    Ich empfehle dir aber boost.function:

    #include <boost/function.hpp>
    #include <boost/bind.hpp>
    
    using namespace boost;
    
    class neklasse
      {
      public:
        void bar();
      }
    
    void foo(function<void ()> funktionspointerersatz)
      {
      //irgendwas
      funktionspointerersatz();
      }
    
    int main()
      {
      neklasse k;
      function<void ()> funktionspointerersatz(bind(mem_fn(&neklasse::bar), &k));
      foo(funktionspointerersatz);
      }
    


  • Lurnon schrieb:

    Nun möchte ich eine Memberfunktion einer anderen Klasse (wxScrollBar->GetThumbPosition()) der Funktion uebermitteln übergeben, damit ich diese dann in der Klasse x aufrufen kann (per Funktionzeiger)

    Damit brauchst Du schonmal keinen Funktionszeiger sondern einen Zeiger auf eine Memberfunktion, sofern die Aufzurufende funktion nicht statisch ist.

    Lurnon schrieb:

    Wie muss ich vorgehen damit mein Anliegen klappt?

    Naja. Erstens brauchst Du wie gesagt den Richtigen Zeiger:

    class foo_t
    {
    	public:
    		int bar( )
    		{
    			return 0;
    		}
    };
    
    int main( )
    {
    	int ( foo_t::*method )( );
        // "method" ist ein Pointer auf eine Methode der Klasse foo_t,
        // die einen Integer zurückgibt.
    
    	method = &foo_t::bar;
        // wir weisen "method" die Adresse der Methode bar zu.
    
    	foo_t foo;
        // wir bauen ein foo_t "foo" um die Methode aufrufen zu können.
    
    	( foo.*method )( );
        // aufruf über den Pointer "method".
    }
    

    Wie Du siehst, benötigt man für den Aufruf einer Methode über einen Zeiger immer ein Objekt. Somit muss Deine aufrufende Klasse einen Zeiger auf ein Objekt des Typs des Zeigers enthalten und damit den Typ des Zielobjekts kennen:

    #include <iostream>
    
    class bar_t {
    
    	public:
    		int foo1( )
    		{
    			std::cout << "bar_t::foo1( )" << std::endl;
    			return 0;
    		}
    
    		int foo2( )
    		{
    			std::cout << "bar_t::foo2( )" << std::endl;
    			return 0;
    		}
    };
    
    template< typename T >
    class foo_t {
    
    	typedef int ( T::*method_t ) ( );
    
    	method_t method; 
    	T *target;
    
    	public:
    
    		foo_t( T *target )
    			: target( target ), method( 0 )
    		{
    		}
    
    		void set_handler( method_t handler )
    		{
    			method = handler;
    		}
    
    		int doit( )
    		{
    			if( target && method ) return target->*method )( );
    
    			std::cout << "handler not set!" << std::endl;
    			return 0;
    		}
    };
    
    int main( )
    {
    	bar_t bar;
    	foo_t< bar_t > foo( &bar );
    
    	foo.doit( );
    
    	foo.set_handler( &bar_t::foo1 );
    	foo.doit( );
    
    	foo.set_handler( &bar_t::foo2 );
    	foo.doit( );
    }
    

    cheers, Swordfish



  • This post is deleted!

Log in to reply