Pourquoi les compilateurs optimisent-ils mieux les Lambdas que les fonctions simples ?

Optimisation des fonctions Lambda

Nicolai Josuttis affirme dans "The C Standard Library" que les compilateurs optimisent mieux les lambdas que les fonctions simples. Cela soulève la question de savoir pourquoi c'est le cas.

Optimisation en ligne

On pourrait supposer que l'optimisation en ligne ne ferait pas de différence entre les lambdas et les fonctions simples. Cependant, la principale différence réside dans la nature des lambdas en tant qu'objets de fonction.

Objets de fonction et pointeurs de fonction

Lorsqu'un lambda est transmis à un modèle de fonction, il crée une nouvelle fonction spécifiquement pour cet objet, ce qui entraîne un appel de fonction trivialement inlinable. En revanche, les fonctions simples transmettent des pointeurs de fonction, ce qui pose généralement des problèmes d'optimisation en ligne. Les compilateurs peuvent théoriquement intégrer de tels appels, mais seulement si la fonction environnante est également intégrée.

Exemple

Considérez une carte de modèle de fonction qui prend un itérateur et un objet de fonction comme paramètres :

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

Invoquer ce modèle avec un lambda :

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

Crée une nouvelle instanciation de la fonction :

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 peut facilement intégrer des appels à l'opérateur() du lambda.

Cependant, lorsque à l'aide d'un pointeur de fonction :

int a[] = { 1, 2, 3, 4 };
map(begin(a), end(a), &my_function);

L'instanciation résultante devient :

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

Ici, f pointe vers une adresse différente pour chaque appel à map, interdisant l'optimisation en ligne à moins que l'appel à map environnant ne soit également intégré.

Ainsi, l'avantage d'optimisation de lambdas découle de leur capacité à créer des objets de fonction qui permettent des fonctionnalités en ligne triviales.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!