generate function pointers at compile time - c++

Question

I have a library taking a callback of type
double *(double)
Now I want to pass a couple of callbacks which are parameterized on another parameter. More precisely I have a function with signature
double f(double, int)
Now I would like to write something like
for(int parameter: {...some values(known at compile time)...})
{
//register callback x mapsto f(x,parameter)
}
I cannot wrap the callback in a lambda because it would be capturing, so it is not convertible to a function pointer. Also as I understand it, bind objects cannot be converted to function pointers (although I am not really sure why) so I cannot bind the parameter.
Does anybody know how this can be done?
EDIT: I would like a solution using the compilers template engine to generate those functions for me.
Also if this is helpfull, I have c++17 and I would also be open to using libraries such as boost hana if necessary.

Answer 1

You need some for of storage to keep the bound value, a raw function pointer can't do that unless you create functions using macros at compile time. (or in a far future using reflection+meta classes) Doing this at run time won't work.
What you can use is std::bind and then for example store std::function instances.
#include <vector>
#include <functional>
double function(double, int);
void register_all() {
using namespace std::placeholders;
// values to bind
std::vector<int> v = { 1, 4, 6, 8 };
// our callback registry
std::vector<std::function<double(double)>> funcs;
// registration
for (auto i : v) {
funcs.emplace_back(std::bind(function, _1, i));
}
//call
for (auto &f : funcs) {
f(1.0);
}
}
If you can't change the callback type to std::function or something similar the only way is to register a single callback doing further calls. i.e.
double my_callback(double d) {
for (int i : whatever) {
f(d, i);
}
}
// ... somewhere else
register_callback(my_callback);
Side note:
A good C callback API would allow passing a void* through, which can be given for extra callback specific information, which could be used to carry the extra data. However the simple function pointer is too limited for anything else.
Edit:
If you know all your (potential) values at compile time you could use a template to wrap:
#include <vector>
double f(double d, int i);
template<int i>
double f_wrapper(double d) {
return f(d, i);
}
int main() {
std::vector<double(*)(double)> funcs;
funcs.push_back(&f_wrapper<0>);
funcs.push_back(&f_wrapper<1>);
funcs.push_back(&f_wrapper<2>);
//call
double r = .0;
for (auto &f : funcs) {
r += f(1.0);
}
}
With some more variadic template magic:
#include <vector>
double f(double d, int i);
template<int i>
double f_wrapper(double d) {
return f(d, i);
}
template<int... id>
void register_cbs(std::vector<double(*)(double)>& funcs) {
(funcs.push_back(&f_wrapper<id>), ...);
}
int main() {
// register
std::vector<double(*)(double)> funcs;
register_cbs<1,2,5,10>(funcs);
//call
double r = .0;
for (auto &f : funcs) {
r += f(1.0);
}
}
But again the values have to be known at compile time.