Why do the following work?
void foo() {
cout << "Foo to you too!\n";
};
int main() {
void (*p1_foo)() = foo;
void (*p2_foo)() = *foo;
void (*p3_foo)() = &foo;
void (*p4_foo)() = *&foo;
void (*p5_foo)() = &*foo;
void (*p6_foo)() = **foo;
void (*p7_foo)() = **********************foo;
(*p1_foo)();
(*p2_foo)();
(*p3_foo)();
(*p4_foo)();
(*p5_foo)();
(*p6_foo)();
(*p7_foo)();
}
There are a few pieces to this that allow all of these combinations of operators to work the same way.
The fundamental reason why all of these work is that a function (like foo) is implicitly convertible to a pointer to the function. This is why void (*p1_foo)() = foo; works: foo is implicitly converted into a pointer to itself and that pointer is assigned to p1_foo.
The unary &, when applied to a function, yields a pointer to the function, just like it yields the address of an object when it is applied to an object. For pointers to ordinary functions, it is always redundant because of the implicit function-to-function-pointer conversion. In any case, this is why void (*p3_foo)() = &foo; works.
The unary *, when applied to a function pointer, yields the pointed-to function, just like it yields the pointed-to object when it is applied to an ordinary pointer to an object.
These rules can be combined. Consider your second to last example, **foo:
foo is implicitly converted to a pointer to itself and the first * is applied to that function pointer, yielding the function foo again.* is applied, again yielding the function foo.You can add as many *s as you like, the result is always the same. The more *s, the merrier.
We can also consider your fifth example, &*foo:
foo is implicitly converted to a pointer to itself; the unary * is applied, yielding foo again.& is applied to foo, yielding a pointer to foo, which is assigned to the variable.The & can only be applied to a function though, not to a function that has been converted to a function pointer (unless, of course, the function pointer is a variable, in which case the result is a pointer-to-a-pointer-to-a-function; for example, you could add to your list void (**pp_foo)() = &p7_foo;).
This is why &&foo doesn't work: &foo is not a function; it is a function pointer that is an rvalue. However, &*&*&*&*&*&*foo would work, as would &******&foo, because in both of those expressions the & is always applied to a function and not to an rvalue function pointer.
Note also that you do not need to use the unary * to make the call via the function pointer; both (*p1_foo)(); and (p1_foo)(); have the same result, again because of the function-to-function-pointer conversion.
I think it's also helpful to remember that C is just an abstraction for the underlying machine and this is one of the places where that abstraction is leaking.
From the perspective of the computer, a function is just a memory address which, if executed, performs other instructions. So a function in C is itself modelled as an address, which probably leads to the design that a function is "the same" as the address it points to.
& and * are idempotent operations on a symbol declared as a function in C which means func == *func == &func == *&func and therefore *func == **func, but they have different types, so you'll get a warning.
The parameter type of a passed function address to a function can be int () or int (*)(), and it can be passed as *func, func or &func. Calling (&func)() is the same as func() or (*func)(). Godbolt link.
* and & have no meaning on a function symbol, and instead of producing an error, the compiler chooses to interpret it as the address of func in both cases. The function does not exist as a separate pointer, like an array symbol, therefore &arr is the same as arr, because it is not a physical pointer with an address at runtime, it's a logical pointer at compiler level. Furthermore *func would read the first byte of the function code, which is an a code section, and rather than produce a compiler error or allow it to be a runtime error segmentation fault, it's just interpreted by the compiler as the address of the function.
& on a symbol declared as a function pointer however will get the address of the pointer (because it is now an actual pointer variable that manifests on the stack or data section), whereas funcp and *funcp will still be interpreted to be the address of the function.
If you are still not very convinced with @JamesMcNellis's answer, here is a prove. This is the AST(abstract syntax tree) from Clang compiler. Abstract syntax tree is the internal representation of the program structure inside the compiler.
void func1() {};
void test() {
func1();
(*func1)();
(&func1)();
void(*func1ptr)(void) = func1;
func1ptr();
(*func1ptr)();
//(&func1ptr)();//error since func1ptr is a variable, &func1ptr is its address which is not callable.
}
AST:
//func1();
|-CallExpr //call the pointer
| `-ImplicitCastExpr //implicitly convert func1 to pointer
| `-DeclRefExpr //reference func1
//(*func1)();
|-CallExpr //call the pointer
| `-ImplicitCastExpr //implicitly convert the funtion to pointer
| `-ParenExpr //parentheses
| `-UnaryOperator //* operator get function from the pointer
| `-ImplicitCastExpr //implicitly convert func1 to pointer
| `-DeclRefExpr //reference func1
//(&func1)();
|-CallExpr //call the pointer
| `-ParenExpr //parentheses
| `-UnaryOperator //& get pointer from func1
| `-DeclRefExpr //reference func1
//void(*func1ptr)(void) = func1;
|-DeclStmt //define variable func1ptr
| `-VarDecl //define variable func1ptr
| `-ImplicitCastExpr //implicitly convert func1 to pointer
| `-DeclRefExpr //reference func1
//func1ptr();
|-CallExpr //call the pointer
| `-ImplicitCastExpr //implicitly convert func1ptr to pointer
| `-DeclRefExpr //reference the variable func1ptr
//(*func1ptr)();
`-CallExpr //call the pointer
`-ImplicitCastExpr //implicitly convert the function to pointer
`-ParenExpr //parentheses
`-UnaryOperator //* get the function from the pointer
`-ImplicitCastExpr //implicitly convert func1ptr to pointer
`-DeclRefExpr //reference the variable func1ptr
