Comment implémenter des rappels C génériques à l'aide de membres de classe et de « std :: function » ?

Rappel C utilisant un membre de classe avec une implémentation générique

La question initiale visait à créer un mécanisme générique de gestion des événements qui fonctionnerait de manière cohérente dans les différentes classes. Au lieu de s'appuyer sur des méthodes statiques et de transmettre des pointeurs d'instance de classe, une approche C plus moderne peut être utilisée en utilisant std::function et std::bind.

Gestionnaire d'événements avec std::function

La classe du gestionnaire d'événements accepte désormais un objet std::function comme argument. Un objet fonction représente une entité appelable qui peut être transmise comme un pointeur de fonction ordinaire. La méthode du gestionnaire d'événements addHandler prend un std::function comme argument, où la fonction passée n'a pas de valeur de retour et prend un entier comme argument.

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

Liaison de fonctions spécifiques

Pour lier une méthode de classe spécifique au gestionnaire d'événements, std ::bind est utilisé. std::bind spécifie le pointeur this et la fonction à appeler lorsque l'événement est déclenché.

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;
}

Fonctions autonomes et fonctions Lambda

Si le rappel est autonome fonction sans contexte de classe, std::bind n'est pas requis.

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

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

Pour les rappels anonymes, les fonctions lambda peuvent être utilisées avec le gestionnaire d'événements.

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

De cette façon, l'utilisation de std::function et std::bind fournit une solution flexible et générique pour les rappels qui peuvent être appliqués à différentes classes et fonctions.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!