C回调-可选参数？

Question

Hey I have implemented some callbacks in my C program.

typedef void (*server_end_callback_t)(void *callbackArg);

then I have variable inside structure to store this callback

server->server_end_callback = on_sever_end; 

What I have noticed it that I can pass in on_server_end callback function implementation that skips void *callbackArg and the code works correctly (no errors).

Is it correct to skip some arguments like void * implementing callback functions which prototypes takes such arguments?

void on_server_end(void) { 
 // some code goes here
}

Answer 1

I believe it is an undefined behavior from the C point of view, but it works because of the calling convention you are using.

For example, AMD64 ABI states that the first six arguments get passed to the calling function using CPU registers, not stack. So neither caller nor callee need no clean-up for the first six arguments and it works fine.

For more info please refer the Wikipedia.

Answer 2

The code works correctly because of the convention of passing arguments. Caller knows that callee expects some arguments - exactly one. So, it prepares the argument(s) (either in register or on stack - depending on ABI on your platform). Then callee uses those parameters or not. After return from callee, caller cleans up the stack if necessary. That's the mistery.

However, you shall not abuse this specific behaviour by passing incompatible function. It is a good practice to always compile your code with options -W -Wall -Werror (clang/gcc and compatible). Enabling such option would provide you a compilation error.

Answer 3

C allows a certain amount of playing fast and loose with function arguments. So

void (*fptr) ();

means "a pointer to a function which takes zero or more arguments". However this is for backwards compatibility, it's not wise to use it in new C code. The other way round

void (*fptr)(void *ptr)
{
   /* don't use the void */
}

/* in another scope */
 (*fptr)(); /* call with no arguments */

also works, as long as you don't use the void *, and I believe it is guaranteed to work though I'm not completely sure about that (on a modern machine the calling convention is to pass the first arguments in registers, so you just get a garbage register, and it will work). Again, it is a very bad idea to rely on it.

You can pass a void *, which you then cast to a structure of appropriate type containing as many arguments as you wish. That is a good idea and a sensible use of C's flexibility.

Answer 4

Is it correct to skip some arguments like void * implementing callback functions which prototypes takes such arguments?

No it is not. Any function with a given function declaration is not compatile with a function of a different function declaration. This rule applies for pointers to functions too.

So if you have a function such as pthread_create(..., my_callback, ...); and it expects you to pass a function pointer of type void* (*) (void*) , then you cannot pass a function pointer of a different format. This invokes undefined behavior and compilers may generate incorrect code.

That being said, function pointer compatibility is a common non-standard extension on many systems. If the calling convention of the system is specified in a way that the function format doesn't matter, and the specific compiler port supports it, then such code might work just fine.

Such code is however not portable and not standard. It is best to avoid it whenever possible.