Utilisation de std::function＜…＞

std::function est une classe de modèle dans la bibliothèque standard C++ utilisée pour encapsuler une interface commune pour les objets appelables (fonctions, pointeurs de fonction, objets de fonction, expressions Lambda, etc.). Il peut être utilisé pour implémenter l’effacement de type et le polymorphisme d’exécution des fonctions.

Les étapes générales d'utilisation de std::function sont les suivantes :

Inclure les fichiers d'en-tête :

#include <functional>

Définir l'objet std::function :

std::function<return_type(arg_types)> func;

Ici, return_type est le type de retour de la fonction et arg_types est le type de paramètre de la fonction.

Attribuez un objet appelable à l'objet std::function :

func = some_function;

Ou utilisez une expression Lambda :

func = [](int x) {
    
     return x * 2; };

Appelez l'objet std::function :

return_type result = func(args);

Les arguments ici sont les paramètres transmis à la fonction lors de l'appel.

Voici un exemple de code complet montrant comment utiliser std::function :

#include <iostream>
#include <functional>

int add(int a, int b) {
    
    
    return a + b;
}

int main() {
    
    
    std::function<int(int, int)> func;
    func = add;

    int result = func(3, 4);
    std::cout << "Result: " << result << std::endl;

    func = [](int x, int y) {
    
     return x * y; };
    result = func(3, 4);
    std::cout << "Result: " << result << std::endl;

    return 0;
}

Dans l'exemple ci-dessus, nous attribuons d'abord func à la fonction add, puis appelons func(3, 4) pour afficher le résultat 7. Ensuite, nous attribuons func à une expression Lambda et appelons à nouveau func(3, 4) pour afficher le résultat 12.

Pour résumer, std::function fournit un moyen pratique de stocker et d'appeler différents types d'objets appelables pour obtenir une flexibilité et un polymorphisme d'exécution.

std :: liaison ()

En C++, vous pouvez utiliser la fonction std::bind pour créer un nouvel objet appelable via une application partielle ou une liaison de paramètres.

std::bind lie un objet appelable à ses arguments et renvoie un nouvel objet appelable. Ce nouvel objet appelable peut retarder l'exécution de l'objet appelable d'origine, modifier l'ordre des paramètres ou lier des paramètres supplémentaires.

L'utilisation de std::bind nécessite d'inclure le fichier d'en-tête.

L'usage général est le suivant :

#include <iostream>
#include <functional>

void printSum(int a, int b) {
    
    
    std::cout << a + b << std::endl;
}

int main() {
    
    
    auto addFiveToValue = std::bind(printSum, 5, std::placeholders::_1);
    addFiveToValue(10);  // 输出 15

    return 0;
}

Dans l'exemple ci-dessus, nous avons défini une fonction printSum qui prend deux entiers et imprime leur somme. Ensuite, un nouvel objet appelable addFiveToValue est créé à l'aide de la fonction std::bind, qui lie la fonction printSum et la constante 5 comme premier paramètre. Nous utilisons std::placeholders::_1 pour représenter le deuxième paramètre à transmettre.

Lorsque nous appelons addFiveToValue(10), printSum(5, 10) est réellement appelé et le résultat de sortie est 15.

Voici quelques scénarios d'utilisation courants pour std::bind :

Application partielle : liez des paramètres partiels pour créer un objet appelable qui accepte moins de paramètres.
Réorganisation des paramètres : ajustez l’ordre des paramètres de l’objet appelable d’origine.
Lier la fonction membre : liez la fonction membre en tant qu’objet appelable et spécifiez un pointeur ou une référence à l’objet comme premier paramètre.
En résumé, std::bind vous permet de créer un nouvel objet appelable via une application partielle ou une liaison de paramètres. Ceci est utile dans les situations où vous devez retarder l'exécution d'une fonction, modifier l'ordre des arguments ou corriger certains arguments.

Utilisation de std::function＜…＞

std :: liaison ()

Guess you like