c Rückruf mit Klassenmitglied mit generischer Implementierung

Die ursprüngliche Frage, die darauf abzielte, einen generischen Ereignishandling-Mechanismus zu erstellen, der konsequent über verschiedene Klassen hinweg funktioniert. Anstatt sich auf statische Methoden zu verlassen und Klasseninstanzzeiger umzugeben, kann ein modernerer C -Ansatz mit std :: function und std :: bind verwendet werden.

Ereignishandler mit std :: function

Die Ereignishandlerklasse akzeptiert jetzt eine STD :: Funktionsobjekt als Argument. Ein Funktionsobjekt repräsentiert eine aufrufbare Entität, die wie ein regulärer Funktionszeiger weitergegeben werden kann. Die Ereignishandler -Methode addHandler nimmt eine std :: function als argument, wobei die bestandene Funktion keinen Rückgabewert hat und eine Ganzzahl als Argument nimmt. { öffentlich: void addHandler (STD :: function Rückruf) { cout

class EventHandler
{
public:
    void addHandler(std::function callback)
    {
        cout  
, um eine bestimmte Klassenmethode an den Ereignishandler zu binden, wird std :: bind verwendet. Std :: Bind gibt den Zeiger und die Funktion an, die aufgerufen werden muss, wenn das Ereignis ausgelöst wird. 
 
 Klasse Myclass
{
öffentlich:
    Myclass ();

    // Hinweis: Nicht mehr mit "statisch" gekennzeichnet und nur das tatsächliche Argument nimmt
    void Callback (int x);
Privat:
    int private_x;
};

Myclass :: MyClass ()
{
    Verwenden von Namespace STD :: Platzhalter; // für `_1`

    private_x = 5;
    Handler-> addHandler (std :: bind (& myclass :: callback, this, _1));
}

void myclass :: callback (int x)
{
    // braucht kein explizites "Instanz" Argument mehr,
    // als "das" ist richtig eingerichtet
    cout  
class MyClass
{
public:
    MyClass();

    // Note: No longer marked `static`, and only takes the actual argument
    void Callback(int x);
private:
    int private_x;
};

MyClass::MyClass()
{
    using namespace std::placeholders; // for `_1`

    private_x = 5;
    handler->addHandler(std::bind(&MyClass::Callback, this, _1));
}

void MyClass::Callback(int x)
{
    // No longer needs an explicit `instance` argument,
    // as `this` is set up properly
    cout  
 Wenn der Rückruf eine freistehende Funktion ohne Klassenkontext ist, ist std :: bind nicht erforderlich. 
 
 void freestingcallback (int x)
{
    // ...
}

int main ()
{
    // ...
    Handler-> addHandler (freistehende Callback);
} 
 
void freeStandingCallback(int x)
{
    // ...
}

int main()
{
    // ...
    handler->addHandler(freeStandingCallback);
}