C函数指针-删除参数时会发生什么？

Question

all. I'm currently working with an old established code base for a new project which is basically undocumented (ie averages 1 one-line comment per file). I just ran into something which I haven't seen before and am not quite sure how to interpret.

Firstly, they define a function type and a function in the header file (.h) in the form:

typedef void (*SOME_FUNCTION)(void *data, EXECUTION_CONTEXT *ec);
void add_function(SOME_FUNCTION aFunction, void *data);

In the main source file (.c), there is a function defined:

void add_function(void (*f)(void *data), void *data) 
{
   (Some code here)
}

So okay, there's a function pointer... but what the heck happened to the second argument, ec? Why would someone use a code design like this? For reference, when the function add_function is used, it is used in this sort of form:

void passedFunction(void *data, EXECUTION_CONTEXT *ec) 
{
    (Stuff the function does.)
}

void CallingFunction()
{
    data = (some data stuff);
    add_function((SOME_FUNCTION)passedFunction, data);
}

So, as you can see, the passed functions use the correct form that fits the original SOME_FUNCTION argument signature, but the definition for the add_function arguments is short by one argument.

Answer 1

Formally, the results are undefined: you are only permitted to call a function via a function pointer if the types match.

As for what actually happens, it depends on the calling convention and what the function does with the arguments. Chances are, the results aren't going to be good.

Answer 2

To add on James' answer:

Since the default calling convention is most likely cdecl , the call site is responsible for cleaning up the stack after passedFunction returns. Since the call site knows that it passed just 1 argument to the callee, the compiler can clean up the stack normally (even though technically this is undefined behavior).

Change the calling convention on passedFunction to stdcall though, and you 're in for some fireworks.

Answer 3

From the example code below, it doesn't appear that the variable(s) that are defined in the function pointer matters during the check. The code below compiles without warning.

#include <stdio.h>

int temp(int (*m)());

int main(int argc, char *argv[]) {
        return temp(main);
}

int temp(int (*m)()) {
        return 1;
}

However, the code below throws an error.

#include <stdio.h>

int temp(void (*m)());

int main(int argc, char *argv[]) {
        return temp(main);
}

int temp(void (*m)()) {
        return 1;
}

Due to this; it seems that the compiler (at least in my case GCC) only cares what the return value of the function pointer will be. The interesting thing here is that you CAN send the parameters correctly but if you do NOT specify the parameter (in our example m()), then the variables in m() when called will be junk.