Introducidas en C++11, las funciones lambda permiten definir funciones anónimas, cortas y locales directamente dentro del código. Facilitan la escritura de lógica simple, mejoran la legibilidad y aportan un estilo más funcional. En este artículo se explica la estructura, el funcionamiento y los principales casos de uso de las expresiones lambda en C++.


1) ¿Qué es una función lambda?

Una función lambda es una función anónima que suele utilizarse para operaciones simples y rápidas. Es ideal para encapsular pequeñas tareas sin definir una función con nombre.

Sintaxis básica:


[capture] (parametros) mutable noexcept -> tipo_retorno {
    // cuerpo
};

Forma simplificada:


[](int x) { return x * 2; };

2) Ejemplo simple de lambda


auto hola = []() {
    cout << "¡Hola!" << endl;
};

hola();

3) Lambda con parámetros


auto sumar = [](int a, int b) {
    return a + b;
};

cout << sumar(3, 4);

4) Especificar el tipo de retorno


auto dividir = [](double a, double b) -> double {
    return a / b;
};

5) Captura de variables (Capture)

Las lambdas pueden acceder a variables del ámbito exterior. A este mecanismo se le llama captura.

Captura por valor:


int x = 10;
auto f = [x]() {
    cout << x;
};

Captura por referencia:


int x = 10;
auto f = [&x]() {
    x += 5;
};

Capturar todas las variables por valor:


auto f = [=]() { /* ... */ };

Capturar todas las variables por referencia:


auto f = [&]() { /* ... */ };

6) Uso de mutable

Por defecto, una lambda no puede modificar las variables capturadas por valor. La palabra clave mutable permite modificarlas localmente.


int x = 10;
auto f = [x]() mutable {
    x += 5; // permitido
    return x;
};

7) Uso de lambdas con algoritmos STL

Uno de los usos más poderosos de las lambdas es combinarlas con algoritmos de la STL.

Con sort:


vector<int> v = {40, 10, 30, 20};

sort(v.begin(), v.end(), [](int a, int b) {
    return a > b; // ordenar de mayor a menor
});

Con count_if:


vector<int> numeros = {1, 2, 3, 4, 5, 6};

int c = count_if(numeros.begin(), numeros.end(), [](int x) {
    return x % 2 == 0; // números pares
});

8) Uso de lambdas como callbacks

Las lambdas se utilizan con frecuencia como funciones callback, especialmente en programación orientada a eventos.


void procesar(int x, function<void(int)> callback) {
    callback(x * 2);
}

int main() {
    procesar(5, [](int resultado) {
        cout << "Resultado: " << resultado;
    });
}

9) Lambdas como objetos funcionales

Una lambda puede pasarse como parámetro, devolverse desde una función o guardarse en contenedores.


vector<function<int(int)>> operaciones;

operaciones.push_back([](int x) { return x + 1; });
operaciones.push_back([](int x) { return x * 2; });

10) Ventajas de usar lambdas

  • Código más corto y legible
  • Perfectas para lógica pequeña y local
  • Gran integración con algoritmos STL
  • Captura flexible (por valor o referencia)
  • Favorecen un estilo de programación funcional

11) TL;DR

  • Lambda → función anónima en línea
  • Capture → acceso a variables externas
  • mutable → permite modificar variables capturadas por valor
  • Perfectas para sort, count_if y otros algoritmos STL
  • Muy útiles como funciones callback
  • Compatibles con Visual Studio 2022, GCC y Clang