C++11 closure shared_ptr

Question

What is the syntax to create heap allocated closure manage by shared_ptr. I want to pass closures to functions and be able to pass nullptr. Seems like using a shared_ptr< ::std::function<void()> but I cannot figure the syntax to initialize that from a lambda expresion

Answer 1

It should be something like

auto lambda = []() { /* do something usefull */ };
auto p = std::make_shared<std::function<void()>>(lambda);

But actually you may no need shared_ptr, since function can be constructed from nullptr.

std::function<void()> fnc(nullptr);

Answer 2

Generally speaking, you want to create a shared_ptr<X> via make_shared, initializing the X object with some Y object. Then generally the code to do that is

auto ptr = make_shared<X>(someY);

In your case, X is the std::function type, and the someY is your lambda. Once you have that, it's pretty straight forward:

auto funPtr = std::make_shared<function<void()>>( [](){ std::cout << "Hello World!\n"; } );
(*funPtr)();

Answer 3

You can do it in two ways:

std::function<void()> lambda = [](){};
auto heapPtr = std::make_shared<std::function<void()>>(lambda);
auto heapPtr2 = new std::function<void()>(lambda);

You might also find the following questions useful:

• C++11 lambda implementation and memory model
• In C++11 lambda syntax, heap-allocated closures?

Answer 4

I prefer putting shared_ptr inside the function object.

auto o = make_shared<MyData>();
return [o] ()
{
    ...
};

So, the data for the closure is on the heap and ref-counted while the handle can be copied and passed around. The data is cleaned up when the last handle is destroyed.