right way to define pointer to the function

Question

hello, everyone, I have this piece of the code:

void foo(int var, int var1)
{
 printf("%d\n", var);
 printf("%d\n", var1);
}

void foo_for_foo( void (*some_function)(int, int))
{
 int x = 5;
 some_function(x, x);
}

int main()
{
 void (*ptr_foo);  // <- look here
 ptr_foo = &foo;
 foo_for_foo(ptr_foo);

 return 0;
}

does it matter how do I define pointer to function:

1) void (*ptr_foo);
2) void (*ptr_foo)(int, int);

my compiler receives both versions

thanks in advance for the explanations of the difference

Answer 1

The two forms are not equivalent.

void (*ptr_foo) is not a function pointer at all. It's a normal, non-function void pointer. The parentheses are superfluous and misleading. It's exactly as if you had written void* ptr_foo.

void (*ptr_foo)(int, int) is the proper way to declare a function pointer to a function taking two ints and returning void.

The only reason that this works is because in C, void pointers are implicitly convertible to any other type of pointer. That is, you can assign any other pointer to a void*, and you can assign a void* to any other pointer.

But the fact that this works in this example is essentially an accident of syntax. You cannot in general replace void (*foo)(int, int) with void (*foo).

If you try doing that with some_function in the argument list to foo_for_foo, your compiler will complain when you try to invoke some_function because it is not a function pointer.

Similarly, if your foo function happened to return an int instead of void, you would notice the problem right away. Declaring ptr_foo as int (*ptr_foo) would have resulted in an error on the statement ptr_foo = &foo because unlike void pointers, int pointers are not implicitly convertible to other pointer types.

In short, always use the second form. It is the only one that is correct in general, despite this fluky case.

Answer 2

The statement void (*ptr_foo); declares a variable of type void *. The function pointer is cast to this type in the statement ptr_foo = &foo; and back to a pointer to the proper function pointer type in the call to foo_for_foo. If you compile with gcc -Wall (or whatever extra paranoid settings your compiler supports) you should see a warning about this conversion.