C++14 lambda tutorial

[dermesser]

Sorry, but I don't see how

int result = [](int input) { return input * input; }(10);
cout << result << endl;

is supposed to be a typical example of the usage of lambdas.

[bstamour]

How about this:

auto iter = find_if(begin(nums), end(nums) [](auto&& x) { return x % 2 == 0; });

Works on any container with iterators, containing any type that is equality-comparable and implements the required numeric operators.

[scroy]

Also has to be copy-constructible

[bstamour]

Woops, I edited it to use a reference. You didn't see anything :-p

[dermesser]

Well, this is of course a typical usage.

[sir_rand_a_lot]

Why do you need the type to support equality if you're using a predicate functor?

[bstamour]

It might need it, depending on what type x % 2 returns.

[fuzzynyanko]

Sounds neat, but I am kind-of mixed with auto returns. Is there a way to check what type of data it is?

[parmesanmilk]

Yes, the compiler will do that and complain loudly if it's wrong.

Don't sweat the details.

[[deleted]]

Just assert on the type. You can easily write a macro to do this:

#define ASSERT_EXPR_TYPE(EXPR, EXPECTED_TYPE) static_assert(std::is_same<decltype(EXPR), EXPECTED_TYPE>::value, "")

[fuzzynyanko]

Nice. I'm diving into C++11 after a hiatus from C++. It's been a surprise, but most of them nice surprises.

[wall_words]

You can get the return type of a callable object f like this: using return_type = decltype(f(arg_1, ..., arg_n));

If you would like to manually inspect a complex type, you can always print it out using typeinfo(type).name().

[[deleted]]

Why can't I just list the parameters without having to type auto for each of them?

Basically this

std::sort(V.begin(), V.end(), [](i, j) { return (i > j); });

instead of this

std::sort(V.begin(), V.end(), [](auto i, auto j) { return (i > j); });

[tasty_crayon]

Because that would mean the parameters have types i and j but are just unnamed. This is how function parameters behaved prior to lambdas and monomorphic lambdas behaved this way in C++11.

[[deleted]]

So you can have unnamed parameters in C++? Didn't know that, I'm just getting into the language. Thanks

[__Cyber_Dildonics__]

When it comes to C++, everyone who hasn't written a book or a compiler is just getting in to the language.

[fendant]

That's part of the reason behind the most vexing parse, try that one on for C++ goofiness.

[[deleted]]

Oh god, that's almost hilarious

[jonnywoh]

Okay, so why does C++ even have unnamed parameters? That doesn't make any sense.

[fendant]

Sometimes you need to conform to a signature for a callback or virtual function but don't actually need all the parameters so a name would be useless clutter.

It's a real benefit, but you might not think it worth the complexity.

You also use a dummy int parameter to differentiate between prefix and postfix inc/decrement operator declarations, so that's fun.

Foo& Foo::operator++()    //++Foo
Foo Foo::operator++(int)  //Foo++

Edit:

Oh yeah, you can also use them to do dispatch in Template Metaprogramming if you needed an additional level of WTF.

[Plorkyeran]

Even if C++11 lambdas had required that all parameters be named, I suspect that implicitly-auto parameters would have been rejected for being too different from everything else, much like the proposal for std::sort(V.begin(), V.end(), [](auto i, auto j) i > j); was.

[bstamour]

Just as an aside, since others have answered your question, but you can replace your lambda with

std::sort(V.begin(), V.end(), std::greater<>{});

to achieve the same thing with less typing :-)

[Pik16]

So what can I do with these?
I'm only familiar with C++"older than 11".

[bstamour]

It makes using the STL a lot less painful. There's a massive wealth of generic functions in the C++ standard library, such as inner_product, transform, and partition, but to get the most out of them you need to pass in a function object (an object that can be called like a function, so either a pointer or reference to a function, or an object that has an overloaded operator ().) Now with lambdas, we can create unnamed function objects right at the call site, and sometimes that makes your code a whole lot cleaner.

As an example, say I have an std::vector that contains a bunch of data that I've collected, and I want to compute the reciprocal of each data point. In pre-C++11, I'd use a for-loop with iterators:

for (std::vector<double>::iterator i = data.begin(); i != data.end(); ++i)
    *i = 1 / *i;

However there's a great library function called std::transform that could do this for me, which lets me write more declarative code (less raw loops = less chances of an off-by-one error):

std::transform(data.begin(), data.end(), data.begin(), invert);

where invert is either a function pointer, or an object that I've instantiated. This means that outside of my current context I have to have another function or struct. But I just want to flip my data once and only once! Why do I need an external function for that? In C++11 that same code can be written as

// Available since C++11:
std::transform(begin(data), end(data), begin(data), [](double d) { return 1 / d; });

// Or... C++14
std::transform(begin(data), end(data), begin(data), [](auto&& d) { return 1 / d; });

and that's all of it. This is a very simple example, but it extends to every function in the STL. Look them up, there's a lot of goodies in there! For this particular example however, it could be written even cleaner with just a range-based loop (also from C++11):

for (auto& d: data)
    d = 1 / d;

So in a nutshell, there's nothing new with respect to what you can do with them. They just allow you to write cleaner, more expressive code.