function pointer and memory address in C

Question

In the following program, &foo, *foo and foo points to the same memory adress :

#include <stdio.h>

int foo(int arg)
{
    printf("arg = %d\n", arg);
    return arg;
}

int main()
{
    foo(0); // ok
    (*foo)(0); // ok
    (&foo)(0); // ok

    printf("&foo = %lx\n", (size_t)(&foo));
    printf("foo = %lx\n", (size_t)(foo));
    printf("*foo = %lx\n", (size_t)(*foo));

    return 0;
}

the output is :

arg = 0
arg = 0
arg = 0
&foo = 55eeef54c720
foo = 55eeef54c720
*foo = 55eeef54c720

Does anyone can explain this ? Thank you.

Function name (a sysmbol) is actually - a memory address it self. Liker change function name with the memory address when linking an executable. CPU instruction like `call foo` is a jump to the RAM block where `foo` function CPU institutions (code) located. — Victor Gubin, Mar 28 '19 at 11:47

score 5 · Accepted Answer · answered Mar 28 '19 at 12:07

In the terminology of the C standard, any expression that has function type is a function designator. So, when used as an expression, the name of a function is a function designator.

There is nothing you can do with a function designator except take its address. You cannot add a number to a function designator, you cannot compare it to another function designator, and so on. Of course, you can call a function, but this is actually done by address, not by designator, as I will explain in a moment. Since there is nothing you can do with a function except take its address, C does this for you automatically. Per C 2018 6.3.2.1 4:

Except when it is the operand of the sizeof operator, or the unary & operator, a function designator with type "function returning type" is converted to an expression that has type "pointer to function returning type".

The result of this is:

In &foo, the & takes the address of foo, so &foo is the address of foo.
In foo, the function designator is automatically converted to the address of the function, so foo is &foo.
In *foo, the function designator is automatically converted to the address of the function. Then the * operator converts this back to the function, which produces a function designator. Then the automatic conversion happens again, and the function designator is converted back to the address of the function, so the result of *foo is &foo.

When you call a function, using the function ( argument-list... ) notation, the function must actually be a pointer to a function. Thus, you can call foo using (&foo)(arguments...). The automatic conversion simplifies the syntax so you can write foo(arguments...), but the call expression actually requires the address of the function, not the function designator.

Incidentally:

A proper printf specifier for size_t values is %zx, not %lx.
If you include <stdint.h>, it defines a type intended for converting pointers to integers, uintptr_t. This is preferably to converting pointers to size_t.

score 3 · Answer 2 · answered Mar 28 '19 at 12:07

The function foo is implicitly convertible to a pointer to the function foo.

The unary & applied to a function yields a pointer to the function, just like it yields the address of variable when applied to a variable.

The unary * applied to a function pointer, yields the pointed-to function, just like it yields the pointed-to variable when it is applied to an ordinary pointer to a variable.

So here, foo is the same as &foo which is the same as *foo.

So *foo is same as *(&foo) which is the same as foo.

function pointer and memory address in C

2 Answers2