Les lambdas ne sont que des objets qui surchargent operator () . Vous pouvez les considérer conceptuellement comme équivalents à:

void (*fp)(int) = [](int){ /* ... */ };

Donc, ils ne sont pas plus chers qu'un appel de fonction similaire. std :: function n'est pas nécessaire pour utiliser des lambdas. Vous pouvez utiliser la déduction de type pour les stocker / les transmettre:

template <typename Func>
void foo(Func&& func) { /* ... */ }

Pour les lambdas sans capture, vous pouvez les convertir en pointeurs de fonction implicitement ou explicitement avec operator + code >:

class Lamba {
public:
    auto operator()(...) const { /* ... */ }
};

La raison pour laquelle il est difficile de répondre à votre question est que vous vous demandez si les lambdas sont chères. Mais, en comparaison avec quoi? Si vous voulez savoir s'ils sont suffisamment performants dans votre cas spécifique, vous devrez faire un profilage pour vous-même et le découvrir.

std :: function est bien, car il a une syntaxe simple (beaucoup plus facile que les pointeurs de fonction) et il auto-documente le type de fonction requis (par rapport aux modèles, qui nécessitent une documentation explicite) . Je suppose que les articles d'introduction sur les lambdas l'utiliseront, car le coût n'est pas visible tant que vous n'avez pas certaines restrictions.

Il existe deux autres façons d'accepter lambda comme paramètre: les pointeurs de fonction et les modèles.

Non capturant lambda peut être converti implicitement en pointeur de fonction:

struct FuncyClass
{   
    template<typename Func>
    unsigned func(Func&& fnx)
    {   return 2 * fnx(7);
    }
};

int main()
{   FuncyClass fc;
    int multiplier = 3;
    auto result = fc.func( [multiplier](auto x){return x*multiplier;} );
    
    printf("Result: %u\n", result);
    return 0;
}

Les lambdas de capture et de non capture peuvent être transmis à l'aide de modèles:

struct FuncyClass
{   unsigned func(int(*fnx)(int)) 
    {   return 2 * fnx(7);
    }
};

int main()
{   FuncyClass fc;
    auto result = fc.func( [](auto x){return x*3;} );
    
    printf("Result: %u\n", result);
    return 0;
}

"Les lambdas sont bon marché"

C'est une notion relative.

Et en pratique, cela dépend beaucoup de votre compilateur C ++.

Essayez d'utiliser un GCC récent (en 2020, utilisez GCC 10 ) et activer les avertissements et les optimisations, donc compilez votre code C ++ -sur la ligne de commande- avec g ++ -Wall -Wextra -O2 au moins.

Ensuite, comparez ou profile votre application

Sous Linux, consultez time (7) et envisagez d'utiliser gprof (1) ou perf (1) (bien sûr, une fois que vous avez débogué votre programme avec GDB ). Avec d'autres systèmes d'exploitation et compilateurs, trouvez un équivalent.

Ce brouillon de rapport peut vous suggérer ce que optimisations qu'un bon compilateur pourrait faire (et parfois pas, à cause de Théorème de Rice ). Il peut parfois arriver qu’une application lambda devienne intégrée .

Si vous aimez le paradigme de programmation fonctionnelle , envisagez également d'utiliser Ocaml , Common Lisp ( SBCL ) ou Haskell . Vous trouverez des cas où il pourrait être en pratique légèrement plus rapide que C ++ (avec GCC ou Clang ), en particulier sous Linux pour les programmes à un seul thread.

En règle générale, j'ai tendance à croire qu'un lambda C ++ est bon marché dès que son corps effectue un travail important, comme itérer (ou rechercher) dans une Conteneur C ++ . Si le corps lambda ne fait qu'une addition entière, la surcharge est significative (à moins que le compilateur ne soit assez intelligent pour l'intégrer). S'il effectue une find opération sur une std :: map avec des milliers d'entrées, ou en fait en utilisant l'allocation dynamique (donc certains nouveaux , souvent en utilisant malloc ), il n'est généralement pas significatif.