C++ function wrapper of a function with a template argument

Question

I am trying to make a function wrapper that takes a function with 1 template argument and use it in another header file. Basically the main program computes certain variables that defines my_function, which is used to define a "criteria.h" header in CGAL. Here is "sizing_fun.h" that contains the function and the function wrapper:

template <typename Point_vec>
double my_function(double x, double y, Point_vec list_of_points)
{
  //use list_of_points
  return 4.0+(x*x+y*y);
}

template <typename FT, typename Point_2, typename Point_vec>
class FT_to_point_function_wrapper : public std::binary_function<Point_2, Point_vec, FT>
{
  typedef FT (*Implicit_function)(FT, FT, FT);
  Implicit_function function;
 public:
  FT_to_point_function_wrapper(Implicit_function f) : function(f) {}
  FT operator()(Point_2 p, Point_vec list) const { return function(p.x(), p.y(), std::forward<Point_vec>(list)); } //error line
};

In the "criteria.h", I use my_func as the function wrapper defined above. pcc is the Point_2 argument, and my_list is the Point_vec argument.

double local_squared_size_bound = my_func(pcc,my_list);

I go error messages:

sizing_fun.h:17: error: cannot convert 'std::vector<CGAL::Point_2<CGAL::Epick>, std::allocator<CGAL::Point_2<CGAL::Epick> > >' to 'double' in argument passing

So it looks like the Point_vec type is not passed along correctly.

I realized this post: C++ function call wrapper with function as template argument But I think it is different because its functions do not have a template argument.

Answer 1

typedef FT (*Implicit_function)(FT, FT, FT);

You declared that the function accepts the same type for all 3 parameters, and also returns the very same type.

Should have been typedef FT (*Implicit_function)(FT, FT, Point_vec);

Fix the signature of Implicit_function, and your problem should be gone.

In case this is at least C++11, you should also be preferring std::function over raw function pointer so that functions or lambdas with bindings / captures can be accepted.

FT_to_point_function_wrapper::function should be declared const as it is only set by initializer list in constructor. If using C++11, you may then also declare FT_to_point_function_wrapper::FT_to_point_function_wrapper to be constexpr.

FT_to_point_function_wrapper::operator() should be declared to be const as well.