Maison > développement back-end > C++ > Pourquoi les Lambdas sont-elles plus optimisables que les fonctions simples en C ?

Pourquoi les Lambdas sont-elles plus optimisables que les fonctions simples en C ?

Susan Sarandon
Libérer: 2024-11-24 06:00:19
original
707 Les gens l'ont consulté

Why are Lambdas More Optimizable than Plain Functions in C  ?

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 à intégrer les appels effectués via des pointeurs de fonction.

Pour illustrer ce concept, 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);
}
Copier après la connexion

Invoquer cette fonction avec un lambda :

int a[] = { 1, 2, 3, 4 };
map(begin(a), end(a), [](int n) { return n * 2; });
Copier après la connexion

aboutit à une 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);
}
Copier après la connexion

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*, int (*)(int)>(int* begin, int* end, int (*f)(int)) {
    for (; begin != end; ++begin)
        *begin = f(*begin);
}
Copier après la connexion

Le compilateur être incapable d'incorporer les appels à f jusqu'à ce que l'appel global à map() soit également intégré, ce qui lui permet 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.

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!

Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers articles par auteur
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal