Comment C peut-il obtenir des mécanismes de rappel flexibles sans s'appuyer sur les fonctions membres de la classe ?

Mécanismes de rappel en C sans fonctions membres de classe

Les fonctions de rappel fournissent un moyen d'enregistrer une fonction à invoquer lorsqu'un événement spécifique se produit. Bien que l'utilisation de méthodes statiques et la transmission d'instances de classe en tant que paramètres soient une approche courante, cela limite la flexibilité d'utilisation des rappels entre différentes classes.

std::function et std::bind en C 11 et au-delà

C 11 a introduit std::function, un wrapper de type sécurisé pour les pointeurs de fonction. Cela permet aux rappels d'être stockés en tant qu'objets, indépendamment de la classe à laquelle ils font référence. De plus, std::bind est utilisé pour lier une fonction à un objet spécifique et à ses arguments.

Considérons un exemple de classe de gestionnaire d'événements, EventHandler :

class EventHandler {
public:
    void addHandler(std::function<void(int)> callback) {
        cout << "Handler added..." << endl;
        callback(1); // trigger the event
    }
};

Maintenant, MyClass et YourClass peuvent tous deux utiliser ce gestionnaire d'événements en implémentant leurs propres fonctions de rappel et en les enregistrant à l'aide de std::bind:

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

    void Callback(int x) {
        cout << x + private_x << endl;
    }
};

class YourClass {
public:
    YourClass() {
        handler->addHandler(std::bind(&YourClass::Callback, this, _1));
    }
private:
    void Callback(int x) {
        // Do something with x
    }
};

Fonctions Lambda et EventHandler

De plus, C 11 a introduit les fonctions lambda, fournissant un moyen concis et simple de définir des fonctions anonymes. Ils peuvent être utilisés avec des gestionnaires d'événements pour créer des rappels hautement personnalisables :

handler->addHandler([](int x) {
    cout << "Lambda callback executed with x: " << x << endl;
});

Cela permet une plus grande flexibilité dans la définition des rappels et leur découplage des méthodes de classe spécifiques.

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!