Menu
CoddyTech

Expresiones lambda en profundidad

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 85 de 104.

Las expresiones lambda, introducidas en C++11, son funciones anónimas que puedes definir en línea. Aunque ya has visto lambdas básicas con algoritmos de STL, comprender toda su sintaxis te permite aprovechar capacidades avanzadas para capturar variables y controlar cómo se accede a ellas.

La sintaxis completa de una lambda es: [capture](parameters) mutable -> return_type { body }. La cláusula de captura determina qué variables externas puede acceder la lambda y cómo:

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    
    auto byValue = [x]() { return x * 2; };        // Copia de x
    auto byRef = [&y]() { y += 5; };               // Referencia a y
    auto allByValue = [=]() { return x + y; };     // Copia todo
    auto allByRef = [&]() { x++; y++; };           // Referencia todo
    auto mixed = [x, &y]() { y += x; };            // Combina ambos
    
    byRef();
    std::cout << y << "\n";  // 25
}

De forma predeterminada, las variables capturadas por valor son const dentro de la lambda. La palabra clave mutable permite modificar estas copias:

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

std::cout << increment() << "\n";  // 1
std::cout << increment() << "\n";  // 2
std::cout << counter << "\n";      // 0 - el original permanece sin cambios

C++14 añadió las capturas de inicialización, que permiten crear nuevas variables o mover objetos a la lambda:

auto ptr = std::make_unique<int>(42);
auto lambda = [p = std::move(ptr)]() {
    return *p;
};  // La propiedad se transfirió a lambda

Las expresiones lambda son especialmente útiles en la programación orientada a objetos cuando necesitas pasar un comportamiento como parámetro, por ejemplo, para callbacks, comparadores personalizados o controladores de eventos, sin definir objetos de función por separado.

challenge icon

Desafío

Fácil

Vamos a crear un sistema de manejo de eventos que muestre el poder de las expresiones lambda con diferentes modos de captura. Crearás un despachador de eventos sencillo que almacena e invoca funciones de retorno, y así demostrarás cómo las lambdas pueden capturar el estado externo de varias maneras.

Organizarás tu código en tres archivos:

  • EventDispatcher.h: Define una clase EventDispatcher que gestione las funciones de retorno de eventos.

    Tu despachador debe almacenar las funciones de retorno usando un std::vector de std::function<void()>. Incluye estos métodos:

    • addCallback(std::function<void()> callback): agrega una función de retorno a la lista
    • fireAll(): invoca todas las funciones de retorno almacenadas en orden
    • clear(): elimina todas las funciones de retorno

    Deberás incluir <functional> y <vector>.

  • EventDispatcher.cpp: Implementa los métodos de tu despachador. El método fireAll() debe recorrer todas las funciones de retorno e invocar cada una.
  • main.cpp: Lee dos entradas:
    1. Un número base (entero)
    2. Un multiplicador (entero)

    Crea un EventDispatcher y demuestra diferentes técnicas de captura de lambdas agregando tres funciones de retorno:

    1. Una lambda que capture el número base por valor e imprima: Base value: [base]
    2. Una lambda que capture el multiplicador por referencia, lo incremente en 1 y después imprima: Multiplier after increment: [multiplier]
    3. Una lambda mutable que capture una variable contador (inicializada en 0) por valor, la incremente cada vez que se la invoque e imprima: Call count: [counter]

    Después de agregar todas las funciones de retorno, llama a fireAll() dos veces para ver cómo se comportan los diferentes modos de captura en varias invocaciones. Entre las dos llamadas a fireAll(), imprime --- como separador.

    Por último, después de ambas rondas, imprime el valor final de la variable multiplicador de main para mostrar cómo la captura por referencia la afectó: Final multiplier: [multiplier]

Por ejemplo, con las entradas 10 y 5:

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

Con las entradas 42 y 0:

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

Observa los comportamientos clave: la captura por valor mantiene intacto el valor original de base, la captura por referencia modifica la variable multiplicador real en main (acumulándose en cada llamada) y el contador de la lambda mutable muestra 1 en cada ronda. Esto se debe a que fireAll() recorre sus funciones de retorno por valor: en cada ronda invoca una copia nueva de std::function almacenada, cuyo contador capturado empieza en 0 y se incrementa a 1; por eso, el estado de la función de retorno almacenada nunca avanza.

Pruébalo tú mismo

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

using namespace std;

int main() {
    int base;
    int multiplier;
    cin >> base;
    cin >> multiplier;
    
    EventDispatcher dispatcher;
    
    // TODO: Añade una lambda que capture base POR VALOR
    // Debe imprimir: "Base value: [base]"
    
    // TODO: Añade una lambda que capture multiplier POR REFERENCIA
    // Debe incrementar multiplier en 1 y luego imprimir: "Multiplier after increment: [multiplier]"
    
    // TODO: Añade una lambda MUTABLE que capture por valor un contador (inicializado en 0)
    // Debe incrementar el contador e imprimir: "Call count: [counter]"
    
    // TODO: Llama a fireAll() para invocar todos los callbacks
    
    // TODO: Imprime "---" como separador
    
    // TODO: Llama a fireAll() de nuevo
    
    // TODO: Imprime el valor final de multiplier: "Final multiplier: [multiplier]"
    
    return 0;
}
quiz iconPonte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Programación Orientada a Objetos

Practica por tu cuenta: Compilador de C++ online