Foncteurs et expressions lambda

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy — leçon 74 sur 104.

De nombreux algorithmes de la STL acceptent un objet appelable (callable) qui personnalise leur comportement. Vous avez déjà vu des lambdas utilisées avec std::transform. Explorons à la fois les foncteurs et les expressions lambda - deux façons de créer des objets appelables en C++.

Un foncteur (objet fonction) est une classe qui surcharge l'operator(), permettant aux instances d'être appelées comme des fonctions :

#include <algorithm>
#include <vector>
#include <iostream>

struct MultiplyBy {
    int factor;
    MultiplyBy(int f) : factor(f) {}
    
    int operator()(int x) const {
        return x * factor;
    }
};

int main() {
    std::vector<int> nums = {1, 2, 3, 4};
    std::vector<int> result(nums.size());
    
    std::transform(nums.begin(), nums.end(), result.begin(), MultiplyBy(3));
    // résultat : {3, 6, 9, 12}
}

Les foncteurs peuvent maintenir un état entre les appels, ce que les fonctions classiques ne peuvent pas faire. Cependant, définir une classe pour des opérations simples est verbeux. Les expressions lambda offrent une alternative concise :

int factor = 3;
std::transform(nums.begin(), nums.end(), result.begin(),
               [factor](int x) { return x * factor; });

La syntaxe d'une lambda est [capture](parameters) { body }. La clause de capture spécifie les variables externes auxquelles la lambda peut accéder. Utilisez [=] pour tout capturer par valeur, [&] pour tout capturer par référence, ou listez des variables spécifiques comme [factor] ou [&factor].

Les lambdas sont particulièrement utiles pour des opérations ponctuelles avec des algorithmes tels que le tri selon des critères personnalisés :

std::vector<int> nums = {5, -2, 8, -1};
std::sort(nums.begin(), nums.end(), 
          [](int a, int b) { return std::abs(a) < std::abs(b); });
// Trié par valeur absolue : {-1, -2, 5, 8}

Défi

Facile

Construisons un calculateur de prix qui illustre à la fois les foncteurs et les expressions lambda pour appliquer différentes stratégies de remise aux prix des produits.

Vous organiserez votre code sur deux fichiers :

Discounts.h : Définissez vos foncteurs de remise et vos fonctions utilitaires ici.
Créez un foncteur appelé PercentageDiscount qui stocke un pourcentage de remise (sous forme d'entier). Son operator() doit prendre un prix de type double et retourner le prix remisé. Par exemple, une remise de 20 % sur 100 $ devrait retourner 80 $.

Créez un autre foncteur appelé FixedDiscount qui stocke un montant fixe à soustraire (sous forme de double). Son operator() doit prendre un prix et retourner le prix moins le montant fixe (mais jamais en dessous de 0).

Créez une fonction appelée printPrices qui prend un const std::vector<double>& et affiche tous les prix séparés par des espaces, suivis d'un saut de ligne. Formatez chaque prix avec deux décimales.
main.cpp : Lisez cinq entrées (chacune sur une ligne séparée) :
1. Prix du premier produit (double)
2. Prix du deuxième produit (double)
3. Prix du troisième produit (double)
4. Pourcentage de remise à appliquer (entier, ex: 20 pour 20 %)
5. Montant de la remise fixe (double)
Créez un vecteur avec les trois prix et démontrez les deux approches :
1. Affichez Original prices: suivi des prix
2. Utilisez std::transform avec votre foncteur PercentageDiscount pour créer un nouveau vecteur de prix remisés. Affichez After percentage discount: suivi des résultats
3. Utilisez std::transform avec votre foncteur FixedDiscount sur les prix originaux pour créer un autre vecteur. Affichez After fixed discount: suivi des résultats
4. Utilisez std::transform avec une expression lambda qui double chaque prix original. Affichez Premium prices (doubled): suivi des résultats
5. Utilisez std::sort avec une lambda pour trier les prix originaux par ordre décroissant. Affichez Sorted (high to low): suivi des prix triés

Par exemple, avec les entrées 100.00, 50.00, 75.00, 20, et 15.00 :

Original prices: 100.00 50.00 75.00 
After percentage discount: 80.00 40.00 60.00 
After fixed discount: 85.00 35.00 60.00 
Premium prices (doubled): 200.00 100.00 150.00 
Sorted (high to low): 100.00 75.00 50.00

Ce défi vous permet de comparer les foncteurs (qui maintiennent un état comme le montant de la remise) avec les lambdas (qui capturent des variables pour des opérations rapides en ligne). Les deux approches fonctionnent parfaitement avec les algorithmes de la STL comme std::transform et std::sort.

Aide-mémoire

Les algorithmes de la STL acceptent des objets appelables pour personnaliser leur comportement. Deux approches courantes sont les foncteurs (functors) et les expressions lambda.

Un foncteur est une classe qui surcharge l'operator(), permettant aux instances d'être appelées comme des fonctions :

struct MultiplyBy {
    int factor;
    MultiplyBy(int f) : factor(f) {}
    
    int operator()(int x) const {
        return x * factor;
    }
};

std::transform(nums.begin(), nums.end(), result.begin(), MultiplyBy(3));

Les foncteurs peuvent maintenir un état entre les appels, mais nécessitent des définitions de classe verbeuses.

Les expressions lambda offrent une alternative concise avec la syntaxe [capture](parameters) { body } :

int factor = 3;
std::transform(nums.begin(), nums.end(), result.begin(),
               [factor](int x) { return x * factor; });

La clause de capture spécifie quelles variables externes la lambda peut accéder :

[=] - capturer tout par valeur
[&] - capturer tout par référence
[factor] - capturer une variable spécifique par valeur
[&factor] - capturer une variable spécifique par référence

Les lambdas fonctionnent bien avec des algorithmes comme std::sort pour des critères de tri personnalisés :

std::sort(nums.begin(), nums.end(), 
          [](int a, int b) { return std::abs(a) < std::abs(b); });

Essayez vous-même

#include <iostream>
#include <vector>
#include <algorithm>
#include "Discounts.h"

int main() {
    // Lire les entrées
    double price1, price2, price3;
    int percentageDiscount;
    double fixedDiscount;
    
    std::cin >> price1;
    std::cin >> price2;
    std::cin >> price3;
    std::cin >> percentageDiscount;
    std::cin >> fixedDiscount;
    
    // Créer un vector avec les trois prix
    std::vector<double> prices = {price1, price2, price3};
    
    // TODO: Afficher "Original prices:" suivi des prix en utilisant printPrices
    
    // TODO: Utiliser std::transform avec le foncteur PercentageDiscount
    // Créer un nouveau vector pour les résultats
    // Afficher "After percentage discount:" suivi des résultats
    
    // TODO: Utiliser std::transform avec le foncteur FixedDiscount sur les prix originaux
    // Créer un nouveau vector pour les résultats
    // Afficher "After fixed discount:" suivi des résultats
    
    // TODO: Utiliser std::transform avec une lambda qui double chaque prix original
    // Créer un nouveau vector pour les résultats
    // Afficher "Premium prices (doubled):" suivi des résultats
    
    // TODO: Utiliser std::sort avec une lambda pour trier les prix originaux par ordre décroissant
    // Afficher "Sorted (high to low):" suivi des prix triés
    
    return 0;
}