Menu
CoddyTech

Expressions lambda en profondeur

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

Les expressions lambda, introduites dans C++11, sont des fonctions anonymes que tu peux définir directement. Même si tu as déjà vu des expressions lambda simples avec les algorithmes STL, comprendre leur syntaxe complète te permet de capturer des variables et de contrôler leur mode d’accès.

La syntaxe complète d’une lambda est : [capture](parameters) mutable -> return_type { body }. La clause de capture détermine quelles variables externes la lambda peut accéder et comment :

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    
    auto byValue = [x]() { return x * 2; };        // Copie de x
    auto byRef = [&y]() { y += 5; };               // Référence à y
    auto allByValue = [=]() { return x + y; };     // Copie de tout
    auto allByRef = [&]() { x++; y++; };           // Référence à tout
    auto mixed = [x, &y]() { y += x; };            // Mélange des deux
    
    byRef();
    std::cout << y << "\n";  // 25
}

Par défaut, les variables capturées par valeur sont const dans la lambda. Le mot-clé mutable permet de modifier ces copies :

int counter = 0;
auto increment = [counter]() mutable {
    return ++counter;  // Modifie la copie de la lambda
};

std::cout << increment() << "\n";  // 1
std::cout << increment() << "\n";  // 2
std::cout << counter << "\n";      // 0 - original inchangé

C++14 a ajouté les captures avec initialisation, qui vous permettent de créer de nouvelles variables ou de déplacer des objets dans la lambda :

auto ptr = std::make_unique<int>(42);
auto lambda = [p = std::move(ptr)]() {
    return *p;
};  // La propriété a été transférée à lambda

Les expressions lambda sont particulièrement utiles en POO lorsque tu dois transmettre un comportement en tant que paramètre — pour des fonctions de rappel, des comparateurs personnalisés ou des gestionnaires d’événements — sans définir d’objets fonction distincts.

challenge icon

Défi

Facile

Construisons un système de gestionnaire d’événements qui met en valeur la puissance des expressions lambda avec différents modes de capture. Tu vas créer un répartiteur d’événements simple qui stocke et invoque des fonctions de rappel, afin de montrer comment les lambdas peuvent capturer un état externe de différentes façons.

Tu vas répartir ton code dans trois fichiers :

  • EventDispatcher.h : définis une classe EventDispatcher qui gère les fonctions de rappel des événements.

    Ton répartiteur doit stocker les fonctions de rappel dans un std::vector de std::function<void()>. Ajoute les méthodes suivantes :

    • addCallback(std::function<void()> callback) : ajoute une fonction de rappel à la liste
    • fireAll() : invoque toutes les fonctions de rappel stockées, dans l’ordre
    • clear() : supprime toutes les fonctions de rappel

    Tu devras inclure <functional> et <vector>.

  • EventDispatcher.cpp : implémente les méthodes de ton répartiteur. La méthode fireAll() doit simplement parcourir toutes les fonctions de rappel et invoquer chacune d’elles.
  • main.cpp : lis deux valeurs :
    1. Un nombre de base (entier)
    2. Un multiplicateur (entier)

    Crée un EventDispatcher et présente différentes techniques de capture de lambdas en ajoutant trois fonctions de rappel :

    1. Une lambda qui capture le nombre de base par valeur et affiche : Base value: [base]
    2. Une lambda qui capture le multiplicateur par référence, l’incrémente de 1, puis affiche : Multiplier after increment: [multiplier]
    3. Une lambda mutable qui capture une variable de compteur (initialisée à 0) par valeur, l’incrémente à chaque appel et affiche : Call count: [counter]

    Après avoir ajouté toutes les fonctions de rappel, appelle fireAll() deux fois pour observer le comportement des différents modes de capture lors de plusieurs appels. Entre les deux appels à fireAll(), affiche --- comme séparateur.

    Enfin, après les deux séries d’appels, affiche la valeur finale de la variable de multiplicateur dans main pour montrer l’effet de la capture par référence : Final multiplier: [multiplier]

Par exemple, avec les valeurs d’entrée 10 et 5 :

Base value: 10
Multiplier after increment: 6
Call count: 1
---
Base value: 10
Multiplier after increment: 7
Call count: 1
Final multiplier: 7

Avec les valeurs d’entrée 42 et 0 :

Base value: 42
Multiplier after increment: 1
Call count: 1
---
Base value: 42
Multiplier after increment: 2
Call count: 1
Final multiplier: 2

Remarque les comportements clés : la capture par valeur conserve le nombre de base d’origine, la capture par référence modifie la véritable variable de multiplicateur dans main (qui augmente à chaque appel), et le compteur de la lambda mutable affiche 1 à chaque série d’appels. En effet, fireAll() parcourt ses fonctions de rappel par valeur : à chaque série d’appels, une nouvelle copie de la std::function stockée est invoquée. Le compteur capturé dans cette copie part de 0 et passe à 1 ; l’état propre de la fonction de rappel stockée ne progresse donc jamais.

Essayez vous-même

#include <iostream>
#include "EventDispatcher.h"

using namespace std;

int main() {
    int base;
    int multiplier;
    cin >> base;
    cin >> multiplier;
    
    EventDispatcher dispatcher;
    
    // TODO: Ajoute une lambda qui capture base PAR VALEUR
    // Elle doit afficher : "Base value: [base]"
    
    // TODO: Ajoute une lambda qui capture multiplier PAR RÉFÉRENCE
    // Elle doit incrémenter multiplier de 1, puis afficher : "Multiplier after increment: [multiplier]"
    
    // TODO: Ajoute une lambda MUTABLE qui capture par valeur un compteur (initialisé à 0)
    // Elle doit incrémenter le compteur et afficher : "Call count: [counter]"
    
    // TODO: Appelle fireAll() pour invoquer tous les callbacks
    
    // TODO: Affiche "---" comme séparateur
    
    // TODO: Appelle de nouveau fireAll()
    
    // TODO: Affiche la valeur finale de multiplier : "Final multiplier: [multiplier]"
    
    return 0;
}
quiz iconTestez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Programmation Orientée Objet

Entraînez-vous par vous-même : Compilateur C++ en ligne