A positive lambda: ‘+[]{}’ – What sorcery is this? [duplicate]

by

Yes, the code is standard conforming. The + triggers a conversion to a plain old function pointer for the lambda.

What happens is this:

The compiler sees the first lambda ([]{}) and generates a closure object according to §5.1.2. As the lambda is a non-capturing lambda, the following applies:

5.1.2 Lambda expressions [expr.prim.lambda]

6 The closure type for a lambda-expression with no lambda-capture has a public non-virtual non-explicit const conversion function to pointer to function having the same parameter and return types as the closure type’s function call operator. The value returned by this conversion function shall be the address of a function that, when invoked, has the same effect as invoking the closure type’s function call operator.

This is important as the unary operator + has a set of built-in overloads, specifically this one:

13.6 Built-in operators [over.built]

8 For every type T there exist candidate operator functions of the form

    T* operator+(T*);

And with this, it’s quite clear what happens: When operator + is applied to the closure object, the set of overloaded built-in candidates contains a conversion-to-any-pointer and the closure type contains exactly one candidate: The conversion to the function pointer of the lambda.

The type of test in auto test = +[]{}; is therefore deduced to void(*)(). Now the second line is easy: For the second lambda/closure object, an assignment to the function pointer triggers the same conversion as in the first line. Even though the second lambda has a different closure type, the resulting function pointer is, of course, compatible and can be assigned.

More Related Contents:

  1. Capturing a reference by reference in a C++11 lambda
  2. Lambda capture and parameter with same name – who shadows the other? (clang vs gcc)
  3. Can using a lambda in header files violate the ODR?
  4. Optimizing away a “while(1);” in C++0x
  5. Passing capturing lambda as function pointer
  6. How is std::function implemented?
  7. How to code a modulo (%) operator in C/C++/Obj-C that handles negative numbers
  8. Bind Vs Lambda?
  9. C++0x lambda capture by value always const?
  10. Is a moved-from vector always empty?
  11. c++ access static members using null pointer
  12. How can I reliably get an object’s address when operator& is overloaded?
  13. C++11 lambda implementation and memory model
  14. Can lambda functions be templated?
  15. Why is modifying a string through a retrieved pointer to its data not allowed?
  16. Get pointer to object from pointer to some member
  17. Is it legal to declare a constexpr initializer_list object?
  18. Are notes and examples in the core language specification of the C++ Standard non-normative?
  19. Does this code from “The C++ Programming Language” 4th edition section 36.3.6 have well-defined behavior?
  20. Why can’t I capture this by-reference (‘&this’) in lambda?
  21. Are int8_t and uint8_t intended to be char types?
  22. How to immediately invoke a C++ lambda?
  23. What is the purpose of a declaration like int (x); or int (x) = 10;
  24. Lambdas and capture by reference local variables : Accessing after the scope
  25. Does C++11 allow dollar signs in identifiers?
  26. How can I pass a C++ lambda to a C-callback that expects a function pointer and a context?
  27. What expressions create xvalues?
  28. Why does the template-id in “A=0” not compile without space because of the greater-or-equal-than operator “>=”?
  29. Can the ‘type’ of a lambda expression be expressed?
  30. When can we omit the return type in a C++11 lambda?

Leave a Comment