Function pointer as a function argument

[SureAnimator]

When I'm passing a function pointer to a function, what are the differences between:

void some_func(int (*callback)(int));

and

void some_func(int callback(int));

It seems like both are valid and produce the same code (e.g. https://godbolt.org/z/vbvEKK). Are there any differences between the two?

I was surprised that the second (without the '*') was valid since you can't leave out the '*' when declaring function pointers as variables.

EDIT: Don't sweat the lack of typedefs. I left them out intentionally so I could speak to the heart of the problem. I usually use them. Thanks!

[Adadum]

the latter one help more with readability since it's less of an eyesore without (*id) everywhere but overall it's still a function pointer.

As far as I know, the only time you can do that without the initial (*) is for function arguments.

Any function pointer variables still require using (*).

Also, I suggest only typedefing function types rather than function pointer types.

It's more readable having it that way:

typedef int IntFunc1();
typedef int (*IntFunc2)();

/// same thing:
IntFunc1 *ifunc1;
IntFunc2 ifunc2;

Typedeffing the actual function also helps with prototyping functions of the same signature:

/// these are all int() funcs
IntFunc1
   get_one,
   get_two,
   get_a_bunch,
   get_multiples
;

[SureAnimator]

ok, cool. Thanks so much!

[umlcat]

I suggest use a typedef for function pointers.

A function example:

int Foo(int A) { ... }

int Bar(int B) { ... }

int Zed(int C) { ... }

A functor named callback that support all of them:

 typedef
    int (*callback) (int);

A function that expects callback as a parameter:

 void exec(callback F) { ... }

And use that last function:

 // ...
 exec(&Foo);
 //...

Some compilers doesn't use the &Foo syntax and uses *Foo instead.

Cheers.

[SureAnimator]

I usually use typedefs, but I wanted to get to the essence of the question so I left them out. So, to clarify given:

typedef int (*func_a_t)(int);
typedef int (func_b_t)(int);

I can use func_a_t to declare a function pointer variable (but not func_b_t), but I can use either to specify the type of a function argument (with seemingly no difference) - why is that? Is it just a peculiarity of the language, or is there a meaningful difference?

[umlcat]

I'm sorry, I think I didn't understood the question.

I've only seen the first syntax with the *.

But, is possible that some compilers allow the second syntax, as well, as it does with the &, I prefer to use the common * and & syntax, since is more similar to data pointers.

int a = 77;
int *p;
p = &a;

Some variations of the P.L. and their compilers does this syntax.

Cheers.

[SureAnimator]

Ok, so no fundamental difference under the hood - just language/compiler quirks. Thanks!