int a[5] .. difference between a and &a

[onkar]

#include<stdio. h>
int main(int argc,char **argv){
int a[5]={1,2,3,4,5};
printf("%p\n%p\ n",a,&a);
return 0;
}
gives me :
0xbfe837a0
0xbfe837a0
this means that a and its address is same ?? Please explain ..

[matevzb]

onkar wrote:

#include<stdio. h>
int main(int argc,char **argv){
int a[5]={1,2,3,4,5};
printf("%p\n%p\ n",a,&a);
return 0;
}
gives me :
0xbfe837a0
0xbfe837a0
this means that a and its address is same ?? Please explain ..

See comp.lang.c FAQ, 6.12: http://c-faq.com/aryptr/aryvsadr.html
(You can also write &a[0])
--
WYCIWYG - what you C is what you get

[Richard Heathfield]

onkar said:

#include<stdio. h>
int main(int argc,char **argv){
int a[5]={1,2,3,4,5};
printf("%p\n%p\ n",a,&a);
return 0;
}
gives me :
0xbfe837a0
0xbfe837a0

Invoking undefined behaviour can give any result whatsoever.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

[P.J. Plauger]

"Richard Heathfield" <rj*@see.sig.in validwrote in message
news:7r******** *************** *******@bt.com. ..

onkar said:

>#include<stdio .h>
int main(int argc,char **argv){
int a[5]={1,2,3,4,5};
printf("%p\n%p\ n",a,&a);
return 0;
}
gives me :
0xbfe837a0
0xbfe837a0

Invoking undefined behaviour can give any result whatsoever.

Seems to me that a decays to an int * while &a is int[5] *.
Both are well formed and happen to have the same address value,
just different types. The only thing undefined about this
program is that %p strictly speaking accepts just a void *,
which *might* have a different representation than int * or
int[5] *. Add the casts and I'll bet you get the same printout,
in a well formed program.

P.J. Plauger
Dinkumware, Ltd.
http://www.dinkumware.com

[Richard Heathfield]

P.J. Plauger said:

"Richard Heathfield" <rj*@see.sig.in validwrote in message
news:7r******** *************** *******@bt.com. ..

>onkar said:

>>#include<stdi o.h>
int main(int argc,char **argv){
int a[5]={1,2,3,4,5};
printf("%p\n%p\ n",a,&a);
return 0;
}
gives me :
0xbfe837a0
0xbfe837a0

Invoking undefined behaviour can give any result whatsoever.

Seems to me that a decays to an int * while &a is int[5] *.

Well, int (*)[5], but yes. Neither is of type void *, however.

Both are well formed and happen to have the same address value,
just different types. The only thing undefined about this
program is that %p strictly speaking accepts just a void *,
which *might* have a different representation than int * or
int[5] *. Add the casts and I'll bet you get the same printout,
in a well formed program.

And what lesson will the OP draw from your apparent condoning of the cast
omission, I wonder?

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

[matevzb]

onkar wrote:

#include<stdio. h>
int main(int argc,char **argv){
int a[5]={1,2,3,4,5};
printf("%p\n%p\ n",a,&a);
return 0;
}
gives me :
0xbfe837a0
0xbfe837a0
this means that a and its address is same ?? Please explain ..

See comp.lang.c FAQ, 6.12: http://c-faq.com/aryptr/aryvsadr.html
(You can also write &a[0])
--
WYCIWYG - what you C is what you get

[Sourcerer]

"onkar" <on*******@gmai l.comwrote in message
news:11******** **************@ 80g2000cwy.goog legroups.com...

#include<stdio. h>
int main(int argc,char **argv){
int a[5]={1,2,3,4,5};
printf("%p\n%p\ n",a,&a);
return 0;
}
gives me :
0xbfe837a0
0xbfe837a0
this means that a and its address is same ?? Please explain ..

No.
a is a pointer to an address where the array a[] begins. a[x] is thus an element
of that field, and the address of that element is calculated like this:

address = a + x * sizeof(int); //int is interchangeable here, depends on what
type of array you are using

&a doesn't mean anything. Since a is a pointer itself, there is no pointer to
that pointer (unless you explicitly declared there to be one). Pointer addresses
are remembered internally by the compiler and when the compiled program loads
into memory, they can be located on predefined places, depending on which part
of memory was the program loaded to. You have no access to these, and you don't
even need them. Most often, however, their relative position in the memory is
encoded into the very (binary) code of the program, so it's near to impossible
to extract them.

&a is therefore, not defined and it can be anything.

--
"It is easy in the world to live after the world's oppinion; it easy in solitude
to live after our own; but the great man is he who in the midst of the crowd
keeps with perfect sweetness the independence of solitude."
Ralph Waldo Emerson, Self-reliance 1841
http://pinpoint.wordpress.com/

[Sourcerer]

"Sourcerer" <en****@MAKNIgm ail.comwrote in message
news:el******** *@ss408.t-com.hr...

>
address = a + x * sizeof(int); //int is interchangeable here, depends on what
type of array you are using

Just remembered, C language "knows" the size of an array element, so the address
is calculated thus:

address = a + x;

This will move the pointer 'address' to the x-th element in any type of array
'a', thanks to the programmers of the compiler who have made our lives easier in
this aspect of C.

--
"It is easy in the world to live after the world's oppinion; it easy in solitude
to live after our own; but the great man is he who in the midst of the crowd
keeps with perfect sweetness the independence of solitude."
Ralph Waldo Emerson, Self-reliance 1841
http://pinpoint.wordpress.com/

[Richard Heathfield]

Sourcerer said:

"onkar" <on*******@gmai l.comwrote in message
news:11******** **************@ 80g2000cwy.goog legroups.com...

>#include<stdio .h>
int main(int argc,char **argv){
int a[5]={1,2,3,4,5};
printf("%p\n%p\ n",a,&a);
return 0;
}
gives me :
0xbfe837a0
0xbfe837a0
this means that a and its address is same ?? Please explain ..

No.
a is a pointer to an address where the array a[] begins.

Strictly, it is an array that, when evaluated, yields as its value the
address of its first element.

<snip>

&a doesn't mean anything. Since a is a pointer itself,

But it isn't a pointer - it's an array name. When used as an operand to &
(or to sizeof) it is not evaluated, and thus does not decay into a pointer
value.

&a means "the address of the array of 5 ints named a".

<incorrect deductions snipped>

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

[Sourcerer]

"Richard Heathfield" <rj*@see.sig.in validwrote in message
news:Xa******** *************** *******@bt.com. ..

Sourcerer said:

>>

No.
a is a pointer to an address where the array a[] begins.

Strictly, it is an array that, when evaluated, yields as its value the
address of its first element.

OK, that means that evaluated a = &a. &a is then the address of the array which
I earlier considered 'a' to be.
Only I have not been consistent in another matter earlier. &a isn't a pointer
(see example below). It is the value directly encoded into the binary processor
commands.

>&a doesn't mean anything. Since a is a pointer itself,

But it isn't a pointer - it's an array name. When used as an operand to &
(or to sizeof) it is not evaluated, and thus does not decay into a pointer
value.

<snip>

&a means "the address of the array of 5 ints named a".

Hmm... interesting how this subtlety affects program execution. Consider the
following program:
#include <stdio.h>
int main(void){
int a[5];
printf("%d, %d\n", sizeof(a), sizeof(&a));
return 0;
}

I first assumed this should give the output (if sizeof(int) = 4):
20, 4

This would be true if &a was a pointer, but it isn't. Execution of this program
gives the output:
20, 20

Why is the second value 20 as well? What exactly is
sizeof(&anythin g_that_is_not_a _pointer)?

--
"It is easy in the world to live after the world's oppinion; it easy in solitude
to live after our own; but the great man is he who in the midst of the crowd
keeps with perfect sweetness the independence of solitude."
Ralph Waldo Emerson, Self-reliance 1841
http://pinpoint.wordpress.com/