Por que Lambdas permitem otimização aprimorada do compilador em comparação com funções simples

A C Standard Library (segunda edição) de Nicolai Josuttis afirma que lambdas podem ser otimizado de forma mais eficaz pelos compiladores em comparação com funções simples. Essa vantagem decorre da natureza dos lambdas como objetos de função.

Quando um lambda é passado para um modelo de função, ele é instanciado como uma nova função especificamente adaptada para esse objeto. Isso permite que o compilador incorpore facilmente a chamada lambda. Por outro lado, com funções simples, um ponteiro de função é passado para o modelo de função. Tradicionalmente, os compiladores enfrentam dificuldades em incorporar chamadas feitas por meio de ponteiros de função.

Para ilustrar esse conceito, considere o seguinte modelo de função:

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

Invocando esta função com um lambda:

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

resulta em uma instanciação criada pelo compilador:

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

Nesse caso, o compilador tem acesso a _some_lambda_type::operator() e pode fazer chamadas integradas para ele. Cada lambda tem um tipo distinto, portanto, usar um lambda diferente com map() produziria uma nova instanciação.

No entanto, se um ponteiro de função fosse usado:

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

O compilador não seria capaz de fazer chamadas embutidas para f até que a chamada abrangente para map() também fosse embutida, permitindo que ele identificasse uma função específica. Isso destaca a vantagem dos lambdas sobre funções simples em termos de otimização do compilador.