Pourquoi les lambdas peuvent-elles être mieux optimisées par le compilateur que les fonctions simples?

Dans son livre, The C++ Standard Library (Second Edition)Nicolai Josuttis déclare que les lambdas peuvent être mieux optimisées par le compilateur que les fonctions simples.

De plus, les compilateurs C ++ optimisent les lambdas mieux que les fonctions ordinaires. (Page 213)

Pourquoi donc?

Je pensais qu'en matière d'inlining, il ne devrait plus y avoir de différence. La seule raison à laquelle je pourrais penser est que les compilateurs pourraient avoir un meilleur contexte local avec les lambdas et que ceux-ci peuvent faire plus d'hypothèses et effectuer plus d'optimisations.

La raison en est que les lambdas sont des objets de fonction, donc les transmettre à un modèle de fonction instanciera une nouvelle fonction spécifiquement pour cet objet. Le compilateur peut ainsi intégrer de manière triviale l'appel lambda.

Pour les fonctions, en revanche, l'ancienne mise en garde s'applique: un pointeur de fonction est passé au modèle de fonction, et les compilateurs ont traditionnellement beaucoup de problèmes pour insérer des appels via des pointeurs de fonction. Ils peuvent théoriquement être insérés, mais uniquement si la fonction environnante est également incorporée.

À titre d'exemple, considérons le modèle de fonction suivant:

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

Appelez-le avec un lambda comme ceci:

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

Résultats dans cette instanciation (créée par le compilateur):

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

… Le compilateur sait _some_lambda_type::operator ()et peut les appeler en ligne de manière triviale. (Et appeler la fonction mapavec n'importe quel autre lambda créerait une nouvelle instanciation de mappuisque chaque lambda a un type distinct.)

Mais lorsqu'elle est appelée avec un pointeur de fonction, l'instanciation se présente comme suit:

template <>
void map<int*, int (*)(int)>(int* begin, int* end, int (*f)(int)) {
    for (; begin != end; ++begin)
        *begin = f(*begin);
}

… Et fpointe ici vers une adresse différente pour chaque appel à mapet donc le compilateur ne peut pas appeler en ligne à fmoins que l'appel environnant à mapn'ait également été inséré afin que le compilateur puisse résoudre fune fonction spécifique.

Parce que lorsque vous passez une "fonction" à un algorithme, vous passez en fait un pointeur vers la fonction, il doit donc faire un appel indirect via le pointeur vers la fonction. Lorsque vous utilisez un lambda, vous passez un objet à une instance de modèle spécialement instanciée pour ce type et l'appel à la fonction lambda est un appel direct, pas un appel via un pointeur de fonction, il est donc beaucoup plus probable qu'il soit en ligne.