Por qué Lambdas permite una optimización mejorada del compilador en comparación con funciones simples

La biblioteca estándar C (segunda edición) de Nicolai Josuttis afirma que las lambdas pueden Los compiladores pueden optimizarlos de manera más efectiva en comparación con las funciones simples. Esta ventaja surge de la naturaleza de las lambdas como objetos de función.

Cuando una lambda se pasa a una plantilla de función, se crea una instancia de ella como una nueva función diseñada específicamente para ese objeto. Esto permite que el compilador alinee sin esfuerzo la llamada lambda. Por el contrario, con funciones simples, se pasa un puntero de función a la plantilla de función. Tradicionalmente, los compiladores han enfrentado dificultades para insertar llamadas realizadas a través de punteros de función.

Para ilustrar este concepto, considere la siguiente plantilla de función:

template 
void map(Iter begin, Iter end, F f) {
    for (; begin != end;   begin)
        *begin = f(*begin);
}

Invocando esta función con una lambda:

int a[] = { 1, 2, 3, 4 };
map(begin(a), end(a), [](int n) { return n * 2; });

da como resultado una creación de instancias creada por el compilador:

template 
void map(int* begin, int* end, _some_lambda_type f) {
    for (; begin != end;   begin)
        *begin = f.operator()(*begin);
}

En este caso, el compilador tiene acceso a _some_lambda_type::operator() y puede integrar llamadas a él sin problemas. Cada lambda tiene un tipo distinto, por lo que usar una lambda diferente con map() produciría una nueva instanciación.

Sin embargo, si se usara un puntero de función en su lugar:

map(int* begin, int* end, int (*f)(int)) {
    for (; begin != end;   begin)
        *begin = f(*begin);
}

El compilador no podrá insertar llamadas a f hasta que la llamada global a map() también esté incorporada, lo que le permitirá identificar una función específica. Esto resalta la ventaja de las lambdas sobre las funciones simples en términos de optimización del compilador.