StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
text
Body
copied!<p>The most efficient way is to <code>voidify</code> the lambda directly.</p> <pre><code>#include <iostream> #include <tuple> #include <memory> template<typename... Args, typename Lambda> std::pair< void(*)(void*, Args...), std::unique_ptr<void, void(*)(void*)> > voidify( Lambda&& l ) { typedef typename std::decay<Lambda>::type Func; std::unique_ptr<void, void(*)(void*)> data( new Func(std::forward<Lambda>(l)), +[](void* ptr){ delete (Func*)ptr; } ); return { +[](void* v, Args... args)->void { Func* f = static_cast< Func* >(v); (*f)(std::forward<Args>(args)...); }, std::move(data) }; } void register_callback( void(*function)(void*), void * p ) { function(p); // to test } void test() { int x = 0; auto closure = [&]()->void { ++x; }; auto voidified = voidify(closure); register_callback( voidified.first, voidified.second.get() ); register_callback( voidified.first, voidified.second.get() ); std::cout << x << "\n"; } int main() { test(); } </code></pre> <p>here <code>voidify</code> takes a lambda and (optionally) a list of arguments, and generates a traditional C-style callback-<code>void*</code> pair. The <code>void*</code> is owned by a <code>unique_ptr</code> with a special deleter so its resources are properly cleaned up.</p> <p>The advantage of this over a <code>std::function</code> solution is efficiency -- I eliminated one level of run-time indirection. The lifetime that the callback is valid is also clear, in that it is in the <code>std::unique_ptr<void, void(*)(void*)></code> returned by <code>voidify</code>.</p> <p><code>unique_ptr<T,D></code>s can be <code>move</code>d into <code>shared_ptr<T></code> if you want a more complex lifetime.</p> <hr> <p>The above mixes lifetime with data, and type erasure with utility. We can split it:</p> <pre><code>template<typename... Args, typename Lambda> std::pair< void(*)(void*, Args...), std::decay_t<Lambda> > voidify( Lambda&& l ) { typedef typename std::decay<Lambda>::type Func; return { +[](void* v, Args... args)->void { Func* f = static_cast< Func* >(v); (*f)(std::forward<Args>(args)...); }, std::forward<Lambda>(l) }; } </code></pre> <p>Now <code>voidify</code> does not allocate. Simply store your voidify for the lifetime of the callback, passing a pointer-to-<code>second</code> as your <code>void*</code> along side the <code>first</code> function pointer.</p> <p>If you need to store this construct off the stack, converting the lambda to a <code>std::function</code> may help. Or use the first variant above.</p>

Querying!

Guidance

An individual column

Larger individual text columns get their own page to allow for proper reading.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload