C++11 lambdas to Function Pointer

Question

I'm starting to develop applications using C++11 lambdas, and need to convert some types to function pointers. This works perfectly in GCC 4.6.0:

void (* test)() = []()
{
    puts("Test!");
};

test();

My problem is when I need to use function or method local variables within the lambda:

const char * text = "test!";

void (* test)() = [&]()
{
    puts(text);
};

test();

G++ 4.6.0 gives the cast error code:

main.cpp: In function 'void init(int)':
main.cpp:10:2: error: cannot convert 'main(int argc, char ** argv)::<lambda()>' to 'void (*)()' in initialization

If use auto , it works ok:

const char * text = "Test!";

auto test = [&]()
{
    puts(text);
};

test();

My question is: how can I create a type for a lambda with [&] ? In my case, I can not use the STL std::function (because my program does not use C++ RTTI and EXCEPTIONS runtime), and It has a simple implementation of function to solve this problem?

Answer 1

I can not use the STL std::function (because my program does not use C++ RTTI and EXCEPTIONS runtime)

Then you may need to write your own equivalent to std::function .

The usual implementation of type erasure for std::function doesn't need RTTI for most of its functionality; it works through regular virtual function calls. So writing your own version is doable.

Indeed, the only things in std::function that need RTTI are the target_type and target functions, which are not the most useful functions in the world. You might be able to just use std::function without calling these functions, assuming that the implementation you're using doesn't need RTTI for its usual business.

Typically, when you disable exception handling, the program simply shuts down and errors out when encountering a throw statement. And since most of the exceptions that a std::function would emit aren't the kind of thing you would be able to recover from (calling an empty function , running out of memory, etc), you can probably just use std::function as is.

Answer 2

Only lambdas with no capture can be converted to a function pointer. This is an extension of lambdas for only this particular case [*]. In general, lambdas are function objects, and you cannot convert a function object to a function.

The alternative for lambdas that have state (capture) is to use std::function rather than a plain function pointer.

---

[*]: If the lambda that holds state could be converted to function pointer, where would the state be maintained? (Note that there might be multiple instances of this particular lambda, each one with it's own state that needs to be maintained separately)

Answer 3

As has been mentioned, only lambdas that capture nothing can be converted to function pointers.

If you don't want to use or write something like std::function then another alternative is to pass as parameters the things you would otherwise capture. You can even create a struct to hold them.

#include <iostream>

struct captures { int x; };
int (*func)(captures *c) = [](captures *c){ return c->x; };

int main() {
    captures c = {10};

    std::cout << func(&c) << '\n';
}

Another alternative is to use global/static/thread_local/constexpr variables which do not require capturing.

Answer 4

You can use std::function , it doesn't need any "runtime". Otherwise, look here for a sketch how to implement std::function yourself .