Techniques de programmation fonctionnelle en C++

Il existe de nombreuses excellentes techniques de programmation dans le langage C++, parmi lesquelles la programmation fonctionnelle est une technologie très pratique. La programmation fonctionnelle met l'accent sur la réutilisabilité et la flexibilité des fonctions, ce qui peut rendre le code plus clair et maintenable. Dans cet article, nous présenterons les techniques de programmation fonctionnelle en C++.

1. Objet fonction

Un objet fonction est un objet appelable, qui peut être considéré comme une fonction. Les objets fonction en C++ peuvent être des objets de classe ou des pointeurs de fonction. Les objets fonction peuvent être utilisés dans les algorithmes STL et peuvent également être utilisés comme paramètres d'autres fonctions. Voici un exemple simple d'objet fonction :

class Add
{
public:
    int operator()(int x, int y) const
    {
        return x + y;
    }
};

int main()
{
    Add add;
    int result = add(1, 2);
    return 0;
}

La classe Add dans cet exemple surcharge l'opérateur (), de sorte que l'objet Add peut être appelé comme une fonction. L'utilisation d'objets fonction peut rendre votre code plus concis et flexible.

2. Expression Lambda

L'expression lambda est une nouvelle fonctionnalité de langage introduite dans C++11, qui peut facilement définir des fonctions anonymes. La syntaxe de base de l'expression lambda est la suivante :

[capture list] (parameter list) -> return type { function body }

où la liste de capture est la liste des variables que l'expression lambda doit capturer ; la liste des paramètres est la liste des paramètres de l'expression lambda ; le type de retour est le type de valeur de retour de l'expression lambda ; ; le corps de fonction est le corps de fonction de l'expression lambda.

Voici un exemple simple d'expression lambda :

auto add = [] (int x, int y) -> int { return x + y; };
int result = add(1, 2);

L'expression lambda dans cet exemple définit une fonction add qui accepte deux paramètres de type int et renvoie leur somme.

3. std::function

std::function est une classe de modèle d'objet fonction en C++11, qui peut stocker n'importe quel objet appelable. L'utilisation de std::function peut facilement transmettre des objets de fonction et des expressions lambda, et peut également être utilisée pour implémenter des fonctions de rappel et d'autres scénarios. Ce qui suit est un exemple simple de std::function :

std::function<int(int, int)> add = [] (int x, int y) -> int { return x + y; };
int result = add(1, 2);

Dans cet exemple, un objet std::function add est défini, qui peut accepter deux paramètres de type int et renvoyer leur somme. L'attribution d'expressions lambda aux objets std::function permet le stockage et le transfert d'objets fonction.

4. Currying

Currying est une technique qui convertit une fonction avec plusieurs paramètres en une séquence de fonctions qui accepte un seul paramètre. Le currying peut rendre les fonctions plus flexibles et peut être utilisé pour implémenter des fonctions telles que des fonctions d'application partielle. Pour implémenter le curry en C++, vous pouvez utiliser des objets fonction et des expressions lambda.

Ce qui suit est un exemple de curry d'un objet fonction :

class Add
{
public:
    int operator()(int x) const
    {
        return x + y;
    }

private:
    int y;
};

int main()
{
    Add add;
    add(1)(2); // 返回3
    return 0;
}

La classe Add dans cet exemple implémente le curry. Elle peut accepter un paramètre x puis renvoyer un objet fonction qui accepte un autre paramètre y. Le calcul des fonctions multiparamètres peut être réalisé grâce à des appels continus.

Ce qui suit est un exemple de curry d'une expression lambda :

auto add = [] (int x) {
    return [=] (int y) {
        return x + y;
    };
};

int main()
{
    int result = add(1)(2); // 返回3
    return 0;
}

L'expression lambda dans cet exemple renvoie un objet fonction qui accepte un paramètre y, puis renvoie la somme de x et y. Le curry peut être réalisé grâce à des expressions lambda.

Résumé

Cet article présente les techniques de programmation fonctionnelle en C++, notamment les objets fonction, les expressions lambda, std :: function et curry, etc. Ces techniques peuvent rendre le code plus flexible et plus lisible, et améliorer la maintenabilité et la réutilisation du code. Dans le développement réel d’un programme, une application raisonnable de ces techniques peut améliorer la qualité et l’efficacité du code.

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!