Why would one write a C++ lambda with a name so it can be called from somewhere?

Question

Why would one write a C++ lambda with a name so it can be called from somewhere? Would that not defeat the very purpose of a lambda? Is it better to write a function instead there? If not, why? Would a function instead have any disadvantages?

Answer 1

One use of this is to have a function access the enclosing scope.

In C++, we don't have nested functions as we do in some other languages. Having a named lambda solves this problem. An example:

#include <iostream>

int main ()
{
    int x;

    auto fun = [&] (int y) {
        return x + y;
    };

    std::cin >> x;

    int t;
    std::cin >> t;
    std::cout << fun (fun (t));
    return 0;
}

Here, the function fun is basically a nested function in main, able to access its local variables. We can format it so that it resembles a regular function, and use it more than once.

Answer 2

A good reason to use names is to express intent. Then one can check that the lambda does 'the right thing' and the reader can check the intent. Given:

std::string key;
std::map<std::string, int> v;

one can write the following:

std::find_if( v.begin(), v.end(), [&](auto const& elem){ return elem.first == key; } );

but it's hard to tell whether it does 'the right thing'. Whereas if we spell it out:

auto matches_key = [&](auto const& elem){ return elem.first == key; };

std::find_if( v.begin(), v.end(), matches_key );

it is clearer that we do want the equality comparison and the readability is improved.

Answer 3

I see three things to consider when choosing between a named lamdba and a free function:

1. Do you need variables from the surrouding scope? If yes, choose a lamdba and leverage its closure. Otherwise, go with a free function (because of 3.).
2. Could the closure state equally well be passed as a function parameter? If yes, consider preferring a free function (because of 3.).

3. Do you want to write a test for the callable and/or reuse it in multiple translation units? If yes, choose a free function, because you must declare it in a header file and capturing variables in a lamdba closure

   • is a bit confusing in a header file (though this is debatable, of course).

   • requires the types to be known. You can't therefore live with forward declarations of function parameters and return types to reduce compilation times.

Answer 4

When your lambda is a recursive function by itself you have no choice but to give it a name. Also, an auto keyword won't suffice and you would HAVE to declare it using an std::function with the return type and the argument list.

Below is the example for a function that returns the Nth Fibonacci number:

std::function<int(int)> fibonacci = [&](int n) {
    if (n == 0 || n == 1) {
        return 1;
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

You have to give it a name in order to capture it with &. And auto won't work since lambda needs its to know its types before calling itself.

Answer 5

This is basicly an opinion based question. It's up to you, whether you prefer functions or lambdas, they are equivalent. A lambda shines, when you need variables from the surrounding. You just can capture them instead of passing it as a parameter, that's neat.

But beside of that, there is no difference.

Answer 6

when tuning a C++ application, a named lambda is easier to tune/trace, as compared to an anonymous/unamed lambda

Answer 7

I always consider lamdas as a nicety - I did plenty of C++ coding without them before they were introduced. So in some ways, I don't consider that there are many shoulds or shouldn'ts surrounding them. They are there to use however they make your life easier.

One time I use named lamdas is to scope a function - i.e. the lamda is only going to be used within another function - perhaps it does something a little dangerous, that you don't want other functions to have access to or perhaps you don't want to pollute the namespace.

If your lamda is too long to be an easy one-liner, but you don't want it to be a available outside of your scope, then a named lamda is ideal way to produce tidy easy to read code.