How to make function XYZ able to call ANY arbitrary function ABC?

[allodi42]

XYZ would have TWO input parameters:
a pointer to the function ABC (int * _p_abc)(...);
and a one-dimensional array of arguments to invoke ABC
(int * _abc_arguments)
The XYZ would look like:
void xyz( *_p_abc, *_abc_arguments) {}

The trick is in making XYZ able to call ABC with ANY number
of input arguments.

The problem is in this.
Say, for ABC with TWO arguments like int ABC(int, int), the
call would be (int * _p_abc) (2, 3);

For THREE arguments int ABC(int,int,int) the call would be
(int * _abc)(3,4,5).

How do I make XYZ, again, to call ABC with ANY number of arguments?

One very clumsy way to do that would be to use simple SWITCH:

switch:

case 1: (int * _p_abc) (x1);
case 2: (int * _p_abc) (x1,x2);
...
case 5: (int * _p_abc) (x1,x2,x3,x4,x5);

But it's TOO clumsy. I need a more elegant way to do that.
And, of course, the above is a simplified version in that ALL
arguments are integers. I will have to make it ultimately versatile so that it would take arguments of ANY type.

[weaknessforcats]

You could imitate what printf does.

The first argument is a char* which points to your format string. printf uses a % followed by an indicator that says what the type is. Like d means int and f means float.

You parse the string and the number of % is the number of arguments in the function you will call.

So, %d,%d,%f would let you call a function:

void ABC(int, int, float);

You need a function pointer to the function you call. Maybe the user passes in a void* as an argument which could then be typecast into a function pointer that takes int, int, float and returns void:

(*fp)(int, int, float)

making the call in this example:

(*fp)(int, int, float)(argint1, argint2, argfloat1);

You will need a case for all forms you are allowed to call. I know you are supposed to call using any number of function arguments but start with a reasonable number of cases to prove the concept.

[donbock]

What about the *_abc_arguments tells you how many arguments were passed?
What is the smallest number of arguments that can be passed?

You can declare the *_p_abc argument as a pointer to a function that takes "..." arguments, but you couldn't call xyz passing a function that takes a fixed number of arguments unless you cast the function pointer in the xyz call.

By the way, you shouldn't define any variables (including formal arguments) with leading underscore - those are reserved names for future versions of the C Standard.

[donbock]

This looks like an attempt to mimic object-oriented programming in C. I would assume you achieve your ultimate goal more easily with C++ (@weaknessforcats can help you with that).

whether you can elegantly achieve your goal in C depends on how flexible xyz has to be with the function pointer argument. If there are only a few possible function then the stdarg approach suggested above can work; but if xyz has to support an arbitrary or unpredictable number of unique function pointer argument values then I can't think of a way to avoid lots of casts or the argument switch that you show in the OP.