What's the different between args and &args? - c

Question

Here is my code snip
#include <stdio.h>
void change(int a[]){
printf("%p\n",&a);
}
int main(){
int b[] = {1,2} ;
printf("%p\n",&b);
change(b);
return 0;
}
I run it and it get the result following
0x7fff5def1c60
0x7fff5def1c38
As we can see the actual parameter address is defferent from the formal parameter address
Then I edited my following
#include <stdio.h>
void change(int a[]){
printf("%p\n",a);
}
int main(){
int b[] = {1,2} ;
printf("%p\n",b);
change(b);
return 0;
}
Then I get the results
0x7fff56501c60
0x7fff56501c60
So it seems that the actual parameter and the formal parameter have the same address.
I am confused that what's the different between &a and a（a is a array）,and why I get the different address from the first snippet?
Thanks!

Answer 1

In:
printf("%p\n",&b);
you are printing the address to the first array cell.
In:
change(b);
and specifically in:
void change(int a[]){
printf("%p\n",&a);
}
you are printing the address of the variable a which in itself is a decayed pointer. So it is semantically equivalent to:
void change(int* a){
printf("%p\n",&a);
}
To retrieve the array first cell you would need to write the function as:
void change(int* a){
printf("%p\n", a);
// ^^
}

Answer 2

You can think of a is the starting address of the memory where to store array[1, 2].
Please also think of a is a variable that stores the array address. A variable means itself is somewhere in the memory. So &a is the address of the variable a. All in all, address &a in memory stores the address of the array[1,2].
In your first case, you are passing the address of variable b to function change so that the function variable a stores the address of variable b. But &a is the address of a not the content of a. That's the reason cause the difference.

Answer 3

Because I don't think that the answers so far stress it enough, I'll give another answer:
There is no difference between b and &b, if b is an array. An array is almost like a pointer, but not 100%. A pointer is a variable that stores an address, as you know. So when you create a pointer p, you create a new variable and then assign some address to it. Now the pointer variable p has an address, and it's value is also an address. You can do three things with it:
- Get ps address with &p
- Get ps value with p
- Get ps dereferenced value with *p
With an array ar, it is different. It acts like a pointer, but it is not a distinct variable where an adress is stored! By creating an array, you just allocate the memory for the elements you want to store, but not for a variable that stores the address of these elements. The variable ar just 'stands for' the address of the first element, but it is not saved somewhere in an extra space; the compiler makes sure to translate ar to the memory of the first element - this is important to understand. So what you can do with it is:
- Get ars address with &ar or with ar
- Get ars value with ar[0]
This is the reason why in your change function, int a[] is the same as int *a but in your main function, int b[] is not the same as int *b. The latter allocates memory for an address, while the first just creates memory for a specified amount of elements, and just uses b as a placeholder for the first address of these elements - there is no extra memory allocated for the first element's address, as it would be with a pointer.
This is also the reason why in main, you can't do b = some_pointer, but you can do it in change - because one is a pointer that has memory allocated and thus can change it's value like every other variable, and the other one is just a placeholder for it's first element and thus cannot change it's value.
I hope now it is clear why &b is the same as b - Since b is not a distinct variable with a place in memory, you cannot ask for it's address - it will just give you the address that b stand for anyway.

Answer 4

In main(), b is an array which size if derived from the initialisation, and &b denotes the adress of the array.
In change(), a is an array of unknown size, which as parameter is handled as a pointer. &a is the adress of this pointer.
In the second version of your code, without the & you refer in both case to the value of the pointer.
Here the relevant extracts from the C11 standard:
6.5.3 Unary operators, pt 3: The unary & operator yields the address of its operand.
6.7.6.3 Function declarators, pt 7: A declaration of a parameter as ‘‘array of type’’ shall be adjusted to ‘‘qualified pointer to
type’’, where the type qualifiers (if any) are those specified within
the [ and ] of the array type derivation.

Answer 5

The "&" operator returns the address of a variable and the "%p" construct in printf returns the address of the pointer.
In your example, these calls in main() are equivalent:
printf("%p\n",b);
printf("%p\n",&b);
Both return the memory position of b, which is 0x7fff56501c60 in your example
When you define a function, you introduce a local variable a:
void change(int a[]){
This is a pointer (equivalent to int * a) and has its own memory address.
When you call this inside the function:
printf("%p\n",a);
you get the same as above: The address of b: The value of pointer b is copied to a and printf tells you where it points at.
However if you do this:
printf("%p\n",&a);
Then you get the address of the local variable a, which is distinct to b. It does not matter what is inside a and in your example the value of b is not even used by function "change", you could also run this:
#include <stdio.h>
void change(int a[]){
printf("%p\n",&a);
}
int main(){
int b[] = {1,2} ;
printf("%p\n",&b);
change((int *)0);
return 0;
}
This runs "change" with a Nullpointer and it is still equivalent to your first example: "change" just prints out the address of the local variable a, regardless of contents.