How does generic lambda work in C++14?

by

Generic lambdas were introduced in C++14.

Simply, the closure type defined by the lambda expression will have a templated call operator rather than the regular, non-template call operator of C++11‘s lambdas (of course, when auto appears at least once in the parameter list).

So your example:

auto glambda = [] (auto a) { return a; };

Will make glambda an instance of this type:

class /* unnamed */
{
public:
    template<typename T>
    T operator () (T a) const { return a; }
};

Paragraph 5.1.2/5 of the C++14 Standard Draft n3690 specifies how the call operator of the closure type of a given lambda expression is defined:

The closure type for a non-generic lambda-expression has a public inline function call operator (13.5.4)
whose parameters and return type are described by the lambda-expression’s parameter-declaration-clause
and trailing-return-type respectively. For a generic lambda, the closure type has a public inline function call
operator member template (14.5.2) whose template-parameter-list consists of one invented type template-parameter
for each occurrence of auto in the lambda’s parameter-declaration-clause, in order of appearance.
The invented type template-parameter is a parameter pack if the corresponding parameter-declaration declares
a function parameter pack (8.3.5). The return type and function parameters of the function call
operator template are derived from the lambda-expression’s trailing-return-type and parameter-declarationclause
by replacing each occurrence of auto in the decl-specifiers of the parameter-declaration-clause with
the name of the corresponding invented template-parameter.

Finally:

Is it similar to templates where for each different argument type compiler generates functions with the same body but changed types or is it more similar to Java’s generics?

As the above paragraph explains, generic lambdas are just syntactic sugar for unique, unnamed functors with a templated call operator. That should answer your question 🙂

More Related Contents:

  1. Why do lambda functions drop deduced return type reference by default?
  2. Purpose of perfect forwarding for Callable argument in invocation expression?
  3. How to create an std::function from a move-capturing lambda expression?
  4. What are some uses of decltype(auto)?
  5. Why use std::bind over lambdas in C++14?
  6. What is the type of lambda when deduced with “auto” in C++11?
  7. Is auto as a parameter in a regular function a GCC 4.9 extension?
  8. Why are lambda expressions not allowed in an unevaluated operands but allowed in the unevaluated portions of constant expressions?
  9. c++ lambdas how to capture variadic parameter pack from the upper scope
  10. Capturing perfectly-forwarded variable in lambda
  11. Lambda capture as const reference?
  12. How to immediately invoke a C++ lambda?
  13. Use of ‘auto func(int)’ before deduction of ‘auto’ in C++14
  14. C++11 Change `auto` Lambda to a different Lambda?
  15. Bind Vs Lambda?
  16. Overload resolution between object, rvalue reference, const reference
  17. C++11 auto: what if it gets a constant reference?
  18. When should I use C++14 automatic return type deduction?
  19. Can lambda functions be templated?
  20. Are compound literals Standard C++?
  21. Understanding the example on lvalue-to-rvalue conversion
  22. Self-initialization of a static constexpr variable, is it well-formed?
  23. Are notes and examples in the core language specification of the C++ Standard non-normative?
  24. Should I copy an std::function or can I always take a reference to it?
  25. Optimization of raw new[]/delete[] vs std::vector
  26. Why can’t I capture this by-reference (‘&this’) in lambda?
  27. error::make_unique is not a member of ‘std’
  28. Can I legally reinterpret_cast between layout-compatible standard-layout types?
  29. Proper way to receive a lambda as parameter by reference
  30. When to use functors over lambdas

Leave a Comment