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 cambiosC++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 lambdaLas 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.
Desafío
FácilVamos 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 claseEventDispatcherque gestione las funciones de retorno de eventos.Tu despachador debe almacenar las funciones de retorno usando un
std::vectordestd::function<void()>. Incluye estos métodos:addCallback(std::function<void()> callback): agrega una función de retorno a la listafireAll(): invoca todas las funciones de retorno almacenadas en ordenclear(): elimina todas las funciones de retorno
Deberás incluir
<functional>y<vector>.EventDispatcher.cpp: Implementa los métodos de tu despachador. El métodofireAll()debe recorrer todas las funciones de retorno e invocar cada una.main.cpp: Lee dos entradas:- Un número base (entero)
- Un multiplicador (entero)
Crea un
EventDispatchery demuestra diferentes técnicas de captura de lambdas agregando tres funciones de retorno:- Una lambda que capture el número base por valor e imprima:
Base value: [base] - Una lambda que capture el multiplicador por referencia, lo incremente en 1 y después imprima:
Multiplier after increment: [multiplier] - 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 afireAll(), 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: 7Con 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: 2Observa 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;
}
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
1Fundamentos de la POO
Archivos externosCompilación y construcción en C++Archivos de cabecera y archivos fuenteEspacios de nombres y ámbitoIntroducción a la POO en C++Clases y objetosEl puntero 'this'Métodos (funciones miembro)Atributos (miembros de datos)Fundamentos de constructores y destructoresRepaso: calculadora sencilla4Propiedades de clase
Miembros de instancia vs. estáticosGetters y settersFunciones miembro constPalabra clave mutableMétodos y variables estáticosFunciones y clases friendRepaso: gestor de cuentas bancarias7Herencia
Herencia básicaNiveles de acceso en la herenciaOrden de llamada de constructores y destructoresSobrescritura de métodosFunciones virtuales y VTableHerencia múltipleHerencia virtualRepaso: jerarquía de empleados2Gestión de memoria
Memoria de pila vs. heapPunteros y referenciasMemoria dinámica (new/delete)Punteros inteligentes en C++RAII en C++Repaso: gestor de arreglos dinámicos5Encapsulación
Especificadores de acceso en C++Especificadores de acceso en profundidadOcultación de informaciónStruct vs. classClases anidadas e internasRepaso: sistema de registros de estudiantes8Polimorfismo
Polimorfismo en compilación y en tiempo de ejecuciónSobrecarga de funcionesRepaso de las funciones virtualesFunciones virtuales purasClases abstractasDiseño de interfaces en C++Conversión dinámica y RTTIRepaso: calculadora de formas11Conceptos avanzados de POO
Composición frente a herenciaMixins mediante CRTPIdiom PimplBorrado de tiposClases enum y tipado fuerteManejo de excepciones en POOJerarquías de excepciones personalizadas14Patrones de diseño, parte 2
Patrón CommandPatrón AdapterPatrón DecoratorPatrón Template MethodPatrón StatePatrón CompositeRAII como patrón3Constructores y destructores
Constructor predeterminadoConstructor con parámetrosConstructor de copiaConstructor de movimientoListas de inicialización del constructorConstructores delegadosAnálisis detallado del destructorRegla de tres / cinco / ceroRepaso: clase String6Sobrecarga de operadores
Introducción a la sobrecarga de operadoresSobrecarga de operadores aritméticosSobrecarga de operadores de comparaciónOperadores de flujoSobrecarga del operador de asignaciónSobrecarga de los operadores [] y ()Operadores de conversión de tipoRepaso: clase Matrix9Plantillas
Plantillas de funcionesPlantillas de clasesEspecialización de plantillasPlantillas variádicasFundamentos de SFINAE y rasgos de tiposRepaso: contenedor genérico12Características modernas de C++
Semántica de movimiento y rvaluesReenvío perfectoExpresiones lambda en profundidadstd::function y std::bindconstexpr y constevalDescomposición estructuradaoptional, variant, anyPractica por tu cuenta: Compilador de C++ online