Question

There are two pointers to different functions

typedef std::vector<double> TData;
double ( * p_test1 ) ( const TData> &arg);
double ( * p_test2 ) ( const TData> &ar1, char *arg2, char *arg3);

and a method which has as an argument a pointer to the function

double f (double ( * p_test1 ) ( const TData  &arg ))
{
    //Long and not trivial algorithm processing results of p_test
    for ( i = 0;... )
    {
       double res = p_test (arg);  //Some computations
    }
}

The f() method contains difficult calculations (here replaced by a for cycle).

Is it possible to templatize this argument (i.e., pointer to a function having different amount of parameters) to get a general function processing both types arguments

double f (double ( * p_test1 ) ( const TData  &arg ));
double f (double ( * p_test2 ) ( const TData> &ar1, char *arg2, char *arg3));

Or is there any way how to write such a function, for example to write a pointer to a pointer to the function?

I would like to avoid the partial specialization of f() function because of its complexity (repetitively overwritten of the long code is not efficient).

Thanks for your help…

Answer 1

A method that can take anything can, as a special case, also take function pointer. E.g.

template<typename Function>
double f (Function p_test)
{ ...
    // if p_test is a function pointer or has operator(), this will work
    double res = p_test (arg);
  ... }

The problem however gets down to the fact, that the two functions are taking different arguments. So the arguments either have to come somehow bundled to f, there need to be several different implementations anyway, or the arguments will always be the same.

To bundle the arguments, usual method is to use std::bind (C++11) or boost::bind. Say you have a function that needs 3 arguments (test2) and need to pass it to generic algorithm (f) that will only provide the first. And you know the other 2. So you do:

f(bind(&test2, _1, secondarg, thirdarg))

(In C++11 bind is std::bind and _1 is std::placeholders::_1, in Boost bind is boost::bind and _1 is in anonymous namespace provided by the header.) In this case f needs to take any argument, because the return type of bind is unspecified class type with appropriate operator().