Resolving ambiguous overload on function pointer and std::function for a lambda using + (unary plus)

by

The + in the expression +[](){} is the unary + operator. It is defined as follows in
[expr.unary.op]/7:

The operand of the unary + operator shall have arithmetic, unscoped enumeration, or pointer type and the result is the value of the argument.

The lambda is not of arithmetic type etc., but it can be converted:

[expr.prim.lambda]/3

The type of the lambda-expression […] is a unique, unnamed non-union class type — called the closure type — whose properties are described below.

[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.

Therefore, the unary + forces the conversion to the function pointer type, which is for this lambda void (*)(). Therefore, the type of the expression +[](){} is this function pointer type void (*)().

The second overload void foo(void (*f)()) becomes an Exact Match in the ranking for overload resolution and is therefore chosen unambiguously (as the first overload is NOT an Exact Match).

The lambda [](){} can be converted to std::function<void()> via the non-explicit template ctor of std::function, which takes any type that fulfils the Callable and CopyConstructible requirements.

The lambda can also be converted to void (*)() via the conversion function of the closure type (see above).

Both are user-defined conversion sequences, and of the same rank. That’s why overload resolution fails in the first example due to ambiguity.

According to Cassio Neri, backed up by an argument by Daniel Krügler, this unary + trick should be specified behaviour, i.e. you can rely on it (see discussion in the comments).

Still, I’d recommend using an explicit cast to the function pointer type if you want to avoid the ambiguity: you don’t need to ask on SO what is does and why it works 😉

More Related Contents:

  1. Overload resolution with std::function
  2. C++ lambda with captures as a function pointer
  3. Move capture in lambda
  4. Why does C++11’s lambda require “mutable” keyword for capture-by-value, by default?
  5. How to capture a unique_ptr into a lambda expression?
  6. Why can lambdas be better optimized by the compiler than plain functions?
  7. Is constexpr supported with lambda functions / expressions?
  8. The simplest and neatest c++11 ScopeGuard
  9. constexpr overloading
  10. When is overloading pass by reference (l-value and r-value) preferred to pass-by-value?
  11. Why are lambda expressions not allowed in an unevaluated operands but allowed in the unevaluated portions of constant expressions?
  12. Error: variable “cannot be implicitly captured because no default capture mode has been specified”
  13. Lambda capture and parameter with same name – who shadows the other? (clang vs gcc)
  14. why do lambda functions in c++11 not have function types?
  15. Why can’t I create a vector of lambdas (of the same type) in C++11?
  16. C++11 “overloaded lambda” with variadic template and variable capture
  17. Lambda expressions as class template parameters
  18. Do c++11 lambdas capture variables they don’t use?
  19. What is the lifetime of a C++ lambda expression?
  20. Passing a lambda into a function template
  21. Are lambdas inlined like functions in C++?
  22. C++11 Change `auto` Lambda to a different Lambda?
  23. how to specify vc11 lambda calling convention
  24. STL algorithms: Why no additional interface for containers (additional to iterator pairs)?
  25. Proper way to receive a lambda as parameter by reference
  26. Can the ‘type’ of a lambda expression be expressed?
  27. When to use functors over lambdas
  28. Why can’t C++11 move a noncopyable functor to a std::function?
  29. Using Boost adaptors with C++11 lambdas
  30. When can we omit the return type in a C++11 lambda?

Leave a Comment