Pointers to functions with multiple arguments as function arguments

Question

I use a function from an optimization toolbox that numerically calculates derivatives of functions. It accepts a pointer to a function with one argument, but what if I need to pass a pointer to a function with multiple arguments to it and expect the additional, less important parameters to just be passed through?

//Function from toolbox
double num_differentation(double (func(const double)), double x)
{
//makes various calls to func, but with only one parameter
func(x);
}

Now assume I have a function I'd like to pass to the above but which has additional arguments not directly related to the optimization problem, but that are nevertheless required to arrive at a meaningful result for the function.

double my_func_to_be_input(double a, double b, double c) {
return a+b*c;
}

Is there a way to rewrite num_differentiation so that at the time of calling func it passes through all three parameters? I tried the following but it did not work:

double num_differentation(double (func(const double arg1, const double arg2, const double arg3)), double x)
{
//makes various calls to func, but with only one parameter
func(x, arg2, arg3);
}

And if we wanted to be even more fancy, would it be possible for num_differentiation to accept a function with varying numbers of parameters with the irrelevant ones just being passed through?

In any case, I would not like to have to resort to global variables to route these additional parameters.

I'm using Visual Studio 2013 and would welcome any helpful suggestions, especially with concrete code examples.

UPDATE: This is how I solved it.

//Rewritten function from toolbox
double rewritten_num_differentation(std::function<double(double)> func, double x)
{
func(x);
}

In my main code:

using namespace std::placeholders;    
auto my_func_to_be_input_with_forwarded_arguments= std::bind(my_func_to_be_input, _1, second_argument_to_be_forwarded, third_argument_to_be_forwarded);

return rewritten_num_differentiation(my_func_to_be_input_with_forwarded_arguments, x_arg);

This is akin to CrazyEdie's suggested first solution. Perhaps there are still more elegant ways that do not involve rewriting the toolbox function, but it seems to be awfully complicated to convert the std::function type to a C-style function pointer (like they try here http://www.cplusplus.com/forum/general/63552/).

Answer 1

double num_differentials(std::function<double(double)> fun, double x)
{
    return fun(x);
}

auto n = num_differentials(std::bind(&fun, _1, arg1, arg2), x);

alternatively:

auto n = num_differentials([arg1,arg2](double x) { return fun(x,arg1,arg2); }, x);

I believe both should work in VC2013.

Edit in response to update:

It's not all that hard to wrap up a std::function for calling through a C callback system.

Assuming:

void register_callback(double (*fun)(double,void*), void* client_data);

Write this:

double wrap_legacy(double d, void* client_data)
{
    auto fun = static_cast<std::function<double(double)>*>(client_data);
    return (*fun)(d);
}

Or if you want to add some security, this:

double wrap_legacy(double d, void* client_data)
{
    auto any = static_cast<boost::any*>(client_data);
    auto fun = boost::any_cast<std::function<double(double)>>(*any);
    return fun(d);
}

Here you just use boost::any as a standard type for any and all such constructs. Always cast to any and always wrap in any. Then if someone screws up and sends the wrong kind of data you'll get exceptions rather than undefined behavior.

Use like this:

auto fun = std::function<double(double)>{[](double d) { return d; }};
register_callback(&wrap_legacy, &fun);

Or the safe version: auto any = boost::any{std::function{[](double d){ return d; }}}; register_callback(&wrap_legacy, &fun);

Of course, generally speaking the client_data lifetime requirements point to heap allocation so you'll need to deal with that. There's also further wrapping you can do and such--like wrapping up register_callback--that can increase safety.

Answer 2

A well designed C style toolbox would have the prototype be:

//Function from toolbox
double num_differentation(double (func(const double, void*)), 
                          double x, 
                          void * user_data)
{
 //makes various calls to func, but with only one parameter
 func(x, user_data);
}

And then expect the user to write

typedef struct my_data { int p; } my_data
double func(double x, void * user_data) {
   my_data * data = (my_data*)user_data;
   return pow(x, data->p);
}

And you'd use the library like this:

my_data data;
data.p = 7;
num_differentiation(&func, 3.0, &data);

However its sounds like you're stuck with a nasty toolbox, and the "standard" was to use that is to use a global, instead of passing the user-data.

my_data g_data;
double func(double x) {
   return pow(x, g_data.p);
}

Then use it like

g_data.p=7;
num_differentiation(&func, 3.0);