Maison > développement back-end > C++ > Comment implémenter des rappels C génériques à l'aide de membres de classe et de « std :: function » ?

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

Patricia Arquette
Libérer: 2024-12-07 18:56:18
original
488 Les gens l'ont consulté

How to Implement Generic C   Callbacks Using Class Members and `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);
    }
};
Copier après la connexion

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;
}
Copier après la connexion

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);
}
Copier après la connexion

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'; });
Copier après la connexion

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!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers articles par auteur
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal