15

Usually, a C++ lambda without a capture should be convertable to a c-style function pointer. Somehow, converting it using std::function::target does not work (i.e. returns a nullptr), also the target_type does not match the signature type even though it seems to be the same.

Tested on VC13 and GCC 5.3 / 5.2.0 / 4.8

Minimal testing example:

#include <functional>
#include <iostream>

void Maybe() {

}

void callMe(std::function<void()> callback) {
    typedef void (*ftype)();
    std::cout << (callback.target_type() == typeid(ftype)) << std::endl;
    std::cout << callback.target<ftype>() << std::endl;
}

int main() {
    callMe([] () {});
    callMe(Maybe);
}

expected output would be 

1
<address>
1
<address>

actual output

0
0
1
<address>

The question is: Why does the lambda's signature differ from the passed function?

Community
  • 1
  • 1
John Watson
  • 153
  • 8

1 Answers1

17

In your first call, std::function does not bother with decaying the lambda into a pointer, it just stores it, with its actual type (which is indeed not void()).

You can force the lambda to decay into a pointer before constructing the std::function with the latter by simply using a unary +:

callMe(+[](){});
//     ^
Quentin
  • 62,093
  • 7
  • 131
  • 191
  • 4
    +1, But: I *really* dislike this `+` hack for integral/pointer type coercion. It just obscures the intent too much. Better make it explicit by wrapping this into a dedicated function. – Konrad Rudolph Jan 13 '16 at 14:15
  • So we found a dupe of [this Q&A](http://stackoverflow.com/questions/18889028/a-positive-lambda-what-sorcery-is-this/18889029?s=1|0.0000#18889029)? – πάντα ῥεῖ Jan 13 '16 at 14:16
  • @πάνταῥεῖ They are not strictly duplicates (the other ones are about type deduction and overload resolution), but they are indeed quite strongly related. – Quentin Jan 13 '16 at 14:17
  • 1
    @KonradRudolph It's a matter of getting used to it, I guess. Hiding it behind, say, a `decay(T&&)` function wouldn't bother me either. – Quentin Jan 13 '16 at 14:19