Pourquoi les Lambdas permettent une optimisation améliorée du compilateur par rapport aux fonctions simples

La bibliothèque standard C (deuxième édition) de Nicolai Josuttis affirme que les lambdas peuvent être optimisé plus efficacement par les compilateurs par rapport aux fonctions simples. Cet avantage découle de la nature des lambdas en tant qu'objets de fonction.

Lorsqu'un lambda est transmis à un modèle de fonction, il est instancié en tant que nouvelle fonction spécifiquement adaptée à cet objet. Cela permet au compilateur d'intégrer sans effort l'appel lambda. À l’inverse, avec les fonctions simples, un pointeur de fonction est transmis au modèle de fonction. Traditionnellement, les compilateurs ont rencontré des difficultés pour intégrer les appels effectués via des pointeurs de fonction.

Pour illustrer ce concept, considérons le modèle de fonction suivant :

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

Invocation de cette fonction avec un lambda :

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

aboutit à une instanciation créée par le compilateur :

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

Dans ce cas, le compilateur a accès à _some_lambda_type::operator() et peut y intégrer de manière transparente des appels. Chaque lambda a un type distinct, donc utiliser un lambda différent avec map() produirait une nouvelle instanciation.

Cependant, si un pointeur de fonction était utilisé à la place :

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

Le compilateur ne pourrait pas intégrer les appels à f jusqu'à ce que l'appel englobant à map() soit également intégré, ce qui lui permettrait d'identifier une fonction spécifique. Cela met en évidence l'avantage des lambdas par rapport aux fonctions simples en termes d'optimisation du compilateur.