Pass lambda to numerical library - c++

Question

I am trying to use a numerical integration library that requires me to pass it a double (*f)(double,void*) as an argument. How can I pass it a lambda I create in the same scope? I tried
auto myLambda = [&](double d, void* data) { ... }
but the type of the lambda cannot be converted to the type required by the library. Is there an workaround?
Thank you for your time!

Answer 1

template<class T>using type=T;
template<class F>
struct callback_t {
F data;
void* pdata(){return &data;}
template<class R, class...Args>
operator type<R(*)(Args...,void*)>()const{
return [](Args...args,void*pdata)->R{
F* data=static_cast<F*>(pdata);
return (*f)(std::forward<Args>(args)...);
};
}
};
template<class F>
callback_t<F> callback(F f){
return{std::move(f)};
}
use:
int scale=3;
auto cb = callback([&](double d){return d*scale;});
then pass cb in place of the function pointer, and cb.pdata() for the void* parameter.

Answer 2

Presumably this library also lets you pass in the data argument with which the supplied function will be called. In that case, you can define a wrapper that treats that argument as a pointer to the actual object you want to call and forwards the call to that object, maybe something like this:
template <class F>
double function_for_library(double d, void* data) {
F& f = *static_cast<F*>(data);
return f(d);
}
Now if you have some arbitrary function object f of type F you can invoke the library like this:
invoke_library(function_for_library<F>, &f); // implicit conversion to void*
For a lambda you'll have to use decltype but it's no big deal.
auto myLambda = /* ... */;
invoke_library(function_for_library<decltype(myLambda)>, &myLambda);
Or you can write another wrapper that deduces the type.

Answer 3

Only lambda without capture may decay to function pointer
I suspect that void* is the way to pass user data.
so you have to create a struct
struct Functor
{
explicit Functor(capture_t&);
void operator()(double d)
{
// Your stuff
}
static void call(double d, void* userdata)
{
(*reinterpret_cast<Functor*>(userdata))(d)
}
private:
capture_t m_capture
};
And then call
Functor func(capture);
library_function(&Functor::call, &func);