need clarification regarding the array

[parveenjain]

Let's say the memory starts allocating from 1000.

main()
{
int a[]={1,2,3,4,5};

printf("sizeof(&a)=%d sizeof(a)=%d sizeof(*a)=%d sizeof(a[0])=%d\n",sizeof(&a),sizeof(a),sizeof(*a),sizeof(a[0]));

printf("a=%u &a+1 =%u a+1=%u *a+1=%u \n",a,(&a)+1,a+1,*a+0);
}

the output of this program is

sizeof(&a)=4 sizeof(a)=20 sizeof(*a)=4 sizeof(a[0])=4
a=1000 &a+1 =1020 a+1=1004 *a+1=1

This program was compiled and run under Linux.

I am a little confused with this output and my question is:
if sizeof(a)= 20 then a+1 should have been 1020.but program is giving me 1004.
similarly if the sizeof(&a)=4 then &a+1should have been 1004 but the program is giving me 1020.

because incrementing any pointer increments exactly with the size of that pointer.

Can anyone please help me out for understanding this situation or am I making any wrong assumption here.



shouldn't it?

[weaknessforcats]

Yes, the sizeopf a struct is not necessarily the sum of the sizes of its members. This is due to alignment. The C/C++ standard requires int to be aligned on a word boundary and a double on a double word boundary. Word here means processor word and is usually the size of the processor register.

So, for a 32-bit OS, the int has to be on a 4-byte boudary and a double on an 8-byte boundary. This all has to do with how many operations are required to get the int into a register. The answer is one if the int is aligned on a 4-byte boudary. An it is two if it isn't. Thanslate that to way slower.

If your struct member are:

struct MyStuff
{
   int a;
   char b;
   int c;
};
 

the compiler will add 3 pad bytes after b so that c is on a 4-byte boundary.

Unless you have real issues, use sizeof the struct.

The compiler factors in the pad bytes when computing addresses so you normally don't have to worry about this.

[ssorower]

Hi,

Just to remind you, when you write like
int a[] = {1,2,3,4,5}
then a is no longer an integer, a is a pointer to integer and in this case you allocated space for it (through initialization) which is 20 bytes (4 bytes for each number and 4*5=20). So, sizeof(a) will always return you 20 bytes, with 5 integers in this space. Where as sizeof(a[0]) returns 4 (size of an integer).

Now, if tyou increment a (a+1), then you are mistaken here assuming that it will increment by its own size. "a" is an integer pointer (it can point to or store integer(s)) and hence it always will increment by the size of integer (thats 4 bytes), not by the size of itself. Hence, a+1 is (1000+size of integer that is 4) = 1004.

Hope it answers your question.

Thanks,
Sorower

[parveenjain]

Thanls for your reply

So what about the &a and &a+1?What type of variable these are and why incrementing one it increases to 20.

Thanks & Regards,
Parveen