So definieren Sie einen allgemeinen Mitgliedsfunktionszeiger

Question

Ich habe eine Timer-Klasse erstellt, die eine Rückrufmethode aufrufen muss, wenn der Timer abgelaufen ist. Zur Zeit arbeite ich mit normalen Funktionszeigern (sie werden als void (*) (void) deklariert, wenn das Ereignis Elapsed auftritt, wird der Funktionszeiger aufgerufen.

Es ist möglich, dasselbe mit einer Mitgliedsfunktion zu tun, die das hat auch die Signatur void (AnyClass :: *) (void)

Dank mates

EDIT:?. Dieser Code hat unter Windows und auch auf einem Echtzeit-Betriebssystem (VxWorks) so nicht mit externen Bibliotheken arbeitet wäre großartig

EDIT2: Nur um sicher zu sein, was ich brauche, ist eine Timer-Klasse, die ein Argument am Konstruktor von nehmen tipe "AnyClass.AnyMethod" ohne Argumente und Rückgabe void. Ich muss dieses Argument und das Letztere in einem Punkt des Codes speichern und nur die Methode ausführen, auf die diese Variable zeigt. Die Hoffnung ist klar.

Answer 1

Abhängigkeiten, Abhängigkeiten ... ja, sicher Boost ist nett, so ist mem_fn, aber Sie brauchen sie nicht. Allerdings ist die Syntax-Elementfunktionen aufrufen übel, so ein wenig Vorlage Magie hilft:

class Callback 
    { 
    public: 
     void operator()() { call(); }; 
     virtual void call() = 0; 
    }; 

    class BasicCallback : public Callback 
    { 
     // pointer to member function 
     void (*function)(void); 
    public: 
     BasicCallback(void(*_function)(void)) 
      : function(_function) { }; 
     virtual void call() 
     { 
      (*function)(); 
     }; 
    }; 

    template <class AnyClass> 
    class ClassCallback : public Callback 
    { 
     // pointer to member function 
     void (AnyClass::*function)(void); 
     // pointer to object 
     AnyClass* object;   
    public: 
     ClassCallback(AnyClass* _object, void(AnyClass::*_function)(void)) 
      : object(_object), function(_function) { }; 
     virtual void call() 
     { 
      (*object.*function)(); 
     }; 
    }; 

Jetzt können Sie nur Rückruf verwenden als Rückrufspeichermechanismus so:

void set_callback(Callback* callback); 
set_callback(new ClassCallback<MyClass>(my_class, &MyClass::timer)); 

Und

Callback* callback = new ClassCallback<MyClass>(my_class, &MyClass::timer)); 

(*callback)(); 
// or... 
callback->call(); 

Answer 2

Die beste Lösung, die ich für den gleichen Zweck verwendet habe, waren boost::signal oder boost::function Bibliotheken (je nachdem, ob Sie einen einzelnen Rückruf wollten oder viele von ihnen) und boost::bind, um tatsächlich die Rückrufe zu registrieren.

class X { 
public: 
    void callback() {} 
    void with_parameter(std::string const & x) {} 
}; 
int main() 
{ 
    X x1, x2; 
    boost::function< void() > callback1; 

    callback1 = boost::bind(&X::callback, &x1); 
    callback1(); // will call x1.callback() 

    boost::signal< void() > multiple_callbacks; 
    multiple_callbacks.connect(boost::bind(&X::callback, &x1)); 
    multiple_callbacks.connect(boost::bind(&X::callback, &x2)); 
    // even inject parameters: 
    multiple_callbacks.connect(boost::bind(&X::with_parameter, &x1, "Hi")); 

    multiple_callbacks(); // will call x1.callback(), x2.callback and x1.with_parameter("Hi") in turn 
} 

Answer 3

boost::function sieht hier wie eine perfekte Passform aus.

Answer 4

Vielleicht ist der Standard bereits gut genug für das, was Sie wollen. Es ist Teil von STL.

Answer 5

ich bin eine Schnittstelle wie diese Annahme:

void Timer::register_callback(void(*callback)(void*user_data), void* user_data); 

template<typename AnyClass, (AnyClass::*Func_Value)(void)> 
void wrap_method_callback(void* class_pointer) 
{ 
    AnyClass*const self = reinterpret_cast<AnyClass*>(class_pointer); 
    (self->*Func_Value)(); 
} 

class A 
{ 
public: 
    void callback() 
    { std::cout << m_i << std::endl; } 
    int m_i; 
}; 

int main() 
{ 
    Timer t; 
    A a = { 10 }; 
    t.register_callback(&wrap_method_callback<A,&A::callback>, &a); 
} 

Ich denke, eine bessere Lösung wäre, Callback Callback auf boost :: function oder eine selbst erstellte Version (wie Kornels Antwort) zu aktualisieren. Dies erfordert jedoch echte C++ - Entwickler, um sich zu beteiligen, andernfalls werden Sie sehr wahrscheinlich Fehler einführen.

Der Vorteil meiner Lösung ist, dass es nur eine Template-Funktion ist. Nicht viel kann schief gehen. Ein Nachteil meiner Lösung ist, dass es Ihre Klasse mit Cast zu void* und zurück schneiden kann. Achten Sie darauf, dass nur AnyClass* Zeiger als void* an die Rückrufregistrierung übergeben werden.