Expresiones lambda en C++: ¿cuándo realmente aceleran el código?

Expresiones lambda en C++: ¿cuándo realmente aceleran el código?

¡Hola, colega! Si alguna vez has mirado en Stack Overflow, seguramente has visto la pregunta que ha acumulado miles de visitas: "What is a lambda expression, and when should I use one?". Y no es casualidad. Las lambdas en C++ son un tema que a la vez simplifica la vida y genera muchos debates sobre optimización y rendimiento.

Hoy no solo daremos una definición seca. Analizaremos cómo funcionan las expresiones lambda bajo el capó, cuándo su uso hace que el código sea más rápido y cuándo, por el contrario, crea problemas ocultos. ¡Allá vamos!

¿Qué es una expresión lambda? Una mirada interna

Formalmente, una expresión lambda es una función anónima que se puede definir directamente en el lugar de la llamada. Pero si profundizamos, el compilador convierte cada lambda en un objeto funcional único (functor). Aquí hay un ejemplo:

// Lambda\nauto add = [](int a, int b) { return a + b; };\n\n// En lo que se convierte (simplificado)\nclass __lambda_1 {\npublic:\n    auto operator()(int a, int b) const { return a + b; }\n};\n__lambda_1 add;

Punto clave: cada lambda tiene su propio tipo único. Esto significa que el compilador puede aplicar una agresiva inserción en línea (inlining) de las llamadas, a diferencia de los punteros a funciones o std::function.

Rendimiento: ¿dónde ganan las lambdas?

Vamos al grano. Aquí hay tres escenarios donde las lambdas proporcionan un aumento notable de rendimiento:

1. Inserción en línea y ausencia de llamadas indirectas

Cuando pasas una lambda a una función plantilla (por ejemplo, std::sort), el compilador conoce el tipo exacto. Esto le permite insertar el código de la lambda directamente en la función llamante. Compara:

// Opción 1: puntero a función (más lento)\nbool compare(int a, int b) { return a < b; }\nstd::sort(vec.begin(), vec.end(), compare);\n\n// Opción 2: lambda (más rápido)\nstd::sort(vec.begin(), vec.end(), [](int a, int b) { return a < b; });

En el primer caso, hay una llamada indirecta a través de un puntero. En el segundo, es una inserción en línea directa. En grandes volúmenes de datos (millones de elementos), la diferencia puede alcanzar 20-30% en tiempo.

2. Captura de variables sin copias innecesarias

Las lambdas permiten un control flexible de la captura. La elección correcta entre [=], [&] y variables específicas afecta directamente al rendimiento:

std::vector<std::string> data;\nstd::string prefix = "prefix_";\n\n// Mal: copiamos una cadena pesada\nstd::for_each(data.begin(), data.end(), \n    [=](std::string& s) { s = prefix + s; });\n\n// Bien: captura por referencia\nstd::for_each(data.begin(), data.end(), \n    [&](std::string& s) { s = prefix + s; });

La captura por valor ([=]) crea una copia de prefix dentro del functor. Para std::string, esto puede ser costoso. La captura por referencia ([&]) es ligera.

3. Lambdas en algoritmos de la STL

Los algoritmos modernos de la STL (C++17/20) utilizan activamente lambdas para cálculos paralelos. Por ejemplo, std::transform con la política de ejecución std::par:

std::vector<int> input(1000000);\nstd::vector<int> output(input.size());\n\n// Procesamiento paralelo\nstd::transform(std::execution::par, \n    input.begin(), input.end(), output.begin(),\n    [](int x) { return x * x + 2 * x + 1; });

La lambda aquí es un candidato ideal para la paralelización, ya que no tiene efectos secundarios (función pura). El compilador y la biblioteca pueden ejecutarla de forma segura en varios hilos.

¿Cuándo pueden las lambdas perjudicar el rendimiento?

No sería justo hablar solo de las ventajas. Hay situaciones donde las lambdas no son la mejor opción:

1. Captura pesada por valor

Si capturas