Wie implementiert man generische C-Rückrufe mithilfe von Klassenmitgliedern und „std::function'?

C-Rückruf unter Verwendung von Klassenmitgliedern mit generischer Implementierung

Die ursprüngliche Frage zielte darauf ab, einen generischen Ereignisbehandlungsmechanismus zu erstellen, der über verschiedene Klassen hinweg konsistent funktioniert. Anstatt sich auf statische Methoden zu verlassen und Klasseninstanzzeiger weiterzugeben, kann ein modernerer C-Ansatz mit std::function und std::bind verwendet werden.

Ereignishandler mit std::function

Die Event-Handler-Klasse akzeptiert jetzt ein std::function-Objekt als Argument. Ein Funktionsobjekt stellt eine aufrufbare Entität dar, die wie ein normaler Funktionszeiger weitergegeben werden kann. Die Event-Handler-Methode addHandler akzeptiert eine std::function als Argument, wobei die übergebene Funktion keinen Rückgabewert hat und eine Ganzzahl als Argument akzeptiert.

class EventHandler
{
public:
    void addHandler(std::function<void(int)> callback)
    {
        cout << "Handler added..." << endl;
        // Let's pretend an event just occured
        callback(1);
    }
};

Binden spezifischer Funktionen

Um eine bestimmte Klassenmethode an den Event-Handler zu binden, std ::bind wird verwendet. std::bind gibt den Zeiger this und die Funktion an, die aufgerufen werden soll, wenn das Ereignis ausgelöst wird.

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 << x + private_x << endl;
}

Freistehende Funktionen und Lambda-Funktionen

Wenn der Rückruf freistehend ist Funktion ohne Klassenkontext, std::bind ist nicht erforderlich.

void freeStandingCallback(int x)
{
    // ...
}

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

Für anonyme Rückrufe können Lambda-Funktionen mit dem Ereignis verwendet werden Handler.

handler->addHandler([](int x) { std::cout << "x is " << x << '\n'; });

Auf diese Weise bietet die Verwendung von std::function und std::bind eine flexible und generische Lösung für Rückrufe, die auf verschiedene Klassen und Funktionen angewendet werden können.

Das obige ist der detaillierte Inhalt vonWie implementiert man generische C-Rückrufe mithilfe von Klassenmitgliedern und „std::function'?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!