Flexible funtion calling with void* and void** - c++

Question

I wish to write a function, which uses the return value of a double function but/and I want to choose this double function during the function call. My idea is:
#include <iostream>
double linea(double a, double b, double x);
double parabola(double a, double b, double c, double x);
void konjgrad(double (*function)(void** params), void** params);
double linea(double a, double b, double x){
return a*x+b;
}
double parabola(double a, double b, double c, double x){
return a*x*x+b*x+c;
}
void konjgrad(double (*function)(void** params), void** params){
double d;
d=function(params);
std::cout<<d<<std::endl;
}
int main(){
konjgrad(linea(1.6,5.1,2.6));
konjgrad(parabola(2.4,3.1,4,2.6));
return 0;
}
But I stuck in the maze of the pointers. Has anyone an idea, how to solve the problem?

Answer 1

You can use variadic templates and perfect-forwarding to introduce the flexibility you require without any additional run-time overhead:
template <typename TF, typename... TArgs>
void konjgrad(TF&& f, TArgs&&... args)
{
double d;
d = std::forward<TF>(f)(std::forward<TArgs>(args)...);
std::cout<<d<<std::endl;
}
konjgrad can then be called as follows:
konjgrad(linea, 1.6, 5.1, 2.6);
konjgrad(parabola, 2.4, 3.1, 4, 2.6);
wandbox example
Alternatively, you could use lambda expressions and put the burden of binding the arguments on the caller:
template <typename TF>
void konjgrad(TF&& f)
{
double d;
d = std::forward<TF>(f)();
std::cout<<d<<std::endl;
}
konjgrad can then be called as follows:
konjgrad([]{ return linea(1.6, 5.1, 2.6); });
konjgrad([]{ return parabola(2.4, 3.1, 4, 2.6); });
wandbox example

Answer 2

Edited
Based upon Vittorio Romeo review, updated to pass vectors as const reference and added necessary assertion inside the linea and parabola APIs.
Here is little naive approach if you want to avoid variadic functions. As your function interface is clearly defined you can pass in vector or array of double type parameters in your linea and parabola functions.
#include <vector>
using namespace std;
double linea(const std::vector<double>& params)
{
assert(params.size() == 3 /*Linear 3 parameters required*/);
return params[0] * params[1] + params[2];
}
double parabola(const std::vector<double>& params)
{
assert(params.size() == 4 /*Parabola 4 parameters required*/);
return params[0] * params[3] * params[3] +
params[1] * params[3] +
params[2];
}
Little bit modified version of your konjgrad function, it is now returning the double value from the underlying call through function pointer. Please notice that first parameter clearly defines the function interface. Second parameter is the vector of doubles.
double konjgrad(double(*function)(const std::vector<double>&), const std::vector<double>& params)
{
return function(params);//returning value from here
}
Finally here's how you should invoke above defined APIs.
int main(int argc, wchar_t* argv[])
{
std::vector<double> vals;
vals.push_back(1.6);
vals.push_back(5.1);
vals.push_back(2.6);
double v1 = konjgrad(linea, vals);
std::vector<double> parab;
parab.push_back(2.4);
parab.push_back(3.1);
parab.push_back(4.0);
parab.push_back(2.6);
double v2 = konjgrad(parabola, parab);
return 0;
}
Hope this would help.