How to pass a function with missing arguments?

Question

I have a procedure which takes double (*function)(double t, double y) as an argument. Now I have a function like double fce (double t, double y, int a) and I want to pass it to my procedure with one filled argument, something like fce (, , 5) to make it double fce (double t, double y) but I cannot find a way to do it in C or C++.

Answer 1

或许，编写一个可变参数函数 ，可以让你能够传递不同数量的值。

Answer 2

In c++ (because you asked C or C++), you can do this with std::bind .

Check this answer for more details.

using namespace std::placeholders;  // for _1, _2, _3...
// Fix first argument as 10
auto fce_third_arg_is_5 = bind(fce, 5, _3);
/* foo(function); */
foo(fce_third_arg_is_5);

---

In c , you can do this by writing a new converter function

/* Can be used only in global scope */
#define GEN_FUNC(X) double templated_fn_##X(double t, double y) {return fce(t, y, X);}

GEN_FUNC(5);
...
/* foo(function); */
foo(templated_fn_5);

Or a generic solution:

static int a_val_g;

static double wrapper(double t, double y)
{
  return fce(t, y, a_val_g);
}

function make_func(int a) {
  /* Warning: Not thread safe. Subsequent call will invalidate previously returned function */
  /* fn(make_func(i), make_func(42); is bad */
  /* Using make_func in a multithreaded application is unsafe unless synchronized properly */
  a_val_g = a;
  return wrapper;
}
...
/* foo(function); */
foo(make_func(5));

Answer 3

C and C++ are very different languages in that aspect.

You probably want a closure (or if -like in C or old C++98- you don't have them, have a callback mechanism so pass both a function pointer and some additional data)

In C++, you need to use the C++11 standard (eg with g++ -std=c++11 ) atr least, which provides anonymous lambda functions -there are closures - and std::function template

BTW, closures (and anonymous functions) are extremely convenient, and functional programming languages sort-of need a garbage collector to handle them conveniently. Such things are much easier to code in eg Ocaml, Clojure, Common Lisp, Haskell, etc....