How can I call (not define) a function with a variable number of arguments in C?

Question

Is there any way to make this code shorter?

long call_f(int argc, long *argv) {
  switch (argc) {
    case 0:
      return f();
      break;
    case 1:
      return f(argv[0]);
      break;
    case 2:
      return f(argv[0], argv[1]);
      break;
    case 3:
      return f(argv[0], argv[1], argv[2]);
      break;
    case 4:
      return f(argv[0], argv[1], argv[2], argv[3]);
      break;
    // ...
  }
  return -1;
}

Answer 1

I don't know how you can make your code shorter but I saw this line in your code:

 return f();

From the next calls to f function, it seems that f is a function that takes variable number of arguments.

You can read in wikipedia that:

Variadic functions must have at least one named parameter, so, for instance,

char *wrong(...);

is not allowed in C.

Based on that, maybe the return f(); statement is causing you trouble?

Answer 2

You can check out my answer to:

Best Way to Store a va_list for Later Use in C/C++

Which seems to work, yet scare people. It's not guaranteed cross-platform or portable, but it seems to be workable on a couple of platforms, at least. ;)

Answer 3

Does f have to accept a variable number of pointers to long? Can you rewrite it to accept an array and a count?

Answer 4

No, there isn't any good way to do this. See here: http://c-faq.com/varargs/handoff.html

You can write a macro with token pasting to hide this behavior but that macro will be no simpler than this code, thus it's only worth writing if you have multiple functions like f() where you would otherwise have to duplicate this case statement.

Answer 5

There's actually a method to call a function at run-time if you know its calling convention and which parameters it receives. This however lies out of the standard C/C++ language scope.

For x86 assembler:

Assuming the following:

1. You know to prepare all the parameters for your function in a solid buffer, exactly in the manner they'd be packed on the stack.
2. Your function doesn't take/return C++ objects by value.

You may use then the following function:

int CallAnyFunc(PVOID pfn, PVOID pParams, size_t nSizeParams)
{
    // Reserve the space on the stack
    // This is equivalent (in some sense) to 'push' all the parameters into the stack.
    // NOTE: Don't just subtract the stack pointer, better to call _alloca, because it also takes
    // care of ensuring all the consumed memory pages are accessible
    _alloca(nSizeParams);

    // Obtain the stack top pointer
    char* pStack;
    _asm {
        mov pStack, esp
    };

    // Copy all the parameters into the stack
    // NOTE: Don't use the memcpy function. Because the call to it
    // will overwrite the stack (which we're currently building)
    for (size_t i = 0; i < nSizeParams; i++)
        pStack[i] = ((char*) pParams)[i];

    // Call your function
    int retVal;
    _asm {
        call pfn
        // Most of the calling conventions return the value of the function (if anything is returned)
        // in EAX register
        mov retVal, eax
    };

    return retVal;
}

You may need to adjust this function, depending on the calling convention used