没有sizeof运算符的数组大小

Question

I am trying to understand program below, but it's not clear to me.

    #include<stdio.h>
    int main()
    {
        int a[]={1,2,3,4,5,6,9};
        printf("sizeof array is %d\n",sizeof(a));
        printf("size of array using logic is %d\n",((&a)[1]-a));
        printf("value of (&a)[1] is %p \n",(&a)[1]);
        printf("value of a is %p \n",a);
        printf("address of a[0] is %p\n",&a[0]);
        printf("address of a[1] is %p\n",&a[1]);
        printf("address of a[2] is %p\n",&a[2]);
        printf("address of a[3] is %p\n",&a[3]);
        printf("address of a[4] is %p\n",&a[4]);
        printf("address of a[5] is %p\n",&a[5]);
        printf("address of a[6] is %p\n",&a[6]);
    }

Above code output is :

    sizeof array is 28
    size of array using logic is 7
    value of (&a)[1] is 0x7ffc4888e78c 
    value of a is 0x7ffc4888e770 
    address of a[0] is 0x7ffc4888e770
    address of a[1] is 0x7ffc4888e774
    address of a[2] is 0x7ffc4888e778
    address of a[3] is 0x7ffc4888e77c
    address of a[4] is 0x7ffc4888e780
    address of a[5] is 0x7ffc4888e784
    address of a[6] is 0x7ffc4888e788

It's not clear to me why ((&a)[1]-a)) on second print statement is returning 7; it should be 0x7ffc4888e78c - 0x7ffc4888e770 which is 0x1c ie 28 total size of array.

For reference I also tried printing (&a)[1] and a values which you can see in code. I tried also debugging.

Answer 1

If you cast (&a)[1] and a to long before the calculation, then you will get your expected result. As haccks commented, you're currently calculating the pointer difference.

// These two sizes will be the same
printf("sizeof array is %ld\n",sizeof(a));
printf("size of array using logic is %ld\n",((long)(&a)[1]-(long)a));

---

Explaining the Math

What's happening in this case, is &a is considered to be type int(*)[7] .

Then, you reference (&a)[1] , which translates to *((&a)+1) . In English, this means "give me the point in memory 1 after the beginning of a ." As &a happens to be type int(*)[7] , that point is at the end of the array.

When you subtract a , the pointer to the beginning of the array, you are performing pointer arithmetic and take a base the size of an int (because a is an int array). So the expression ((&a)[1]-a) is counting how many int are between (&a)[1] and a .

An overview on pointer arithmetic can be found here .

Answer 2

(&a)[1] is the address of the memory location past the array a , ie 0x7ffc4888e788 . (&a)[1] is of type int * . After conversion, a will be of type int * . It is equivalent to (&a)[0] .

Standard says that:

C11-§6.5.6/9:

When two pointers are subtracted, both shall point to elements of the same array object, or one past the last element of the array object; the result is the difference of the subscripts of the two array elements.

The difference (&a)[1]-a gives the number of elements in array a . Note that a in this expression is the address of array element a[0] , after decay, and this address is equivalent to the address of array a , though &a and a[0] have different type.

You can think of this difference as (&a)[1]-(&a)[0] or &a[7] - &a[0] .

sizeof(a) gives the memory size allocated for array a . sizeof(a)/sizeof(a[0]) will give the number of elements of array a .

Answer 3

So pointers are not integers. Sure, you can convert them to integers by casting them to an integer type, or add integers to them to slide them around. But they are not integers.

Pointers are like mathematical vectors over the integers, if you have done any linear algebra.

p1-p2 is the distance between p1 and p2 , the integer required to add to p2 to reach p1 .

When you add an integer to a pointer, you have to pay attention to the type of the pointer. If the pointer is to an object of size 4, each time you add 1 to a pointer its numerical address increases by 4, not 1.

The same thing is true when you subtract two pointers.

The key part here is that the numerical value of the address in memory matters, but the type matters just as much to understand what happens.

The second strange thing going on here is that arrays decay into pointers to their first element at the drop of a hat. They, however, are not pointers to their first element, they just convert into them very easily.

So when we do this:

(&a)[1]

we are taking the address of a . The address of a is a pointer of type int(*)[7] . It is a pointer to an array, not a pointer to the first element of the array . The difference is in the type of the pointer. And that 7 is important.

We then use [] on the pointer . If you have a pointer or array p and a value v , p[v] is defined to be *(p+v) . This leads to humor if you do v[p] , but that isn't important.

Let pa represent (&a) . Then pa[1] is going to be *(pa + 1) .

Now, pa is a pointer-to-an-array (not a pointer-to-the-first-element of the array). So +1 adds the full size of the array (sizeof(int)*7) to the numeric value.

So pa+1 is a pointer to one-past-the-end of a , and is of type pointer-to-array.

We then dereference, and get the non-existent array of size 7 right after the end of the array a .

Then we subtract a .

(&a)[1]-a

This is where pointer decay kicks in. There is no - operation on arrays, but there is a - operation on pointers. So the C language helpfully decays each of these arrays into pointers to their first element.

The pointer to the first element of a is &a[0] .

The pointer to the first element of the array of size 7 immediately after the end of a is ... &a[7] .

Both of these pointers are of type int* . When you subtract two int* s, you get their numeric pointer value, divided by sizeof(int) . In this case, this is easy -- 7.

This might be easier if we looked at this:

(&a)[1]-(&a)[0]

or

*(&a+1)-*(&a+0)

&a is a pointer to the array a of type "pointer to array of size 7". We add 1 to it, getting the pointer to the array afterwards in one case, and zero in the other case.

We then go down back to being arrays, and subtract. Subtraction triggers decay to pointer-to-first-element, so we get a pointer to the element right after the end of a, and a pointer to the first element of a.

&a[7]-&a[0]

which is

&*(a+7)-&*(a+0)

Now &* does nothing to things that are already pointers (which they are at that point), so:

(a+7)-(a+0)

The question then becomes, how much do you have to add to a+0 to reach a+7 . The answer, not surprisingly, is 7 :

(a+7) = (a+0)+7

and that is what is displayed.

Answer 4

You operates but int* pointer. All arithmetic operations on it using 4 bytes ( sizeof(int) to be precise) as unit. Difference betwen two pointers expressed into this units. ((&a)[1]-a)) is equals as sizeof(a)/sizeof(a[0]) . For calc array size into bytes you need to cast pointer to integer value, unsigned int:

  printf("size of array using logic is %d\n",((int)((&a)[1])-(int)a));

Answer 5

If you want to get number of bytes, without using sizeof operator, then rather than casting to long data type*, I think that more idiomatic and safe way is to cast both pointers into char * :

printf("Size of array using pointer arithmethic is %td.\n", (char*)(&a)[1] - (char*)a);

Result:

Size of array using pointer arithmethic is 28.

Note that %td format specifier is suited for datatype ptrdiff_t (defined in <stddef.h> ), that is how pointer difference is represented.

---

*) There are dedicated data types intptr_t and uintptr_t for representing object pointers as integers if you really need that.

Answer 6

First thanks to all and special thanks to Yakk for giving me such great analysis on simple pointer arthamatics.I at last figured out why it is happening so as @Yakk explained in detail that cleared me to much extent but still had some doubt on that,so I started changing code and tryed to verify pointer arthematics. One short answer is if &a[0] is used it refers to first element in array address. If a or &a are used they refer to base address of complete array of size 7. Now to go clear ,we used (&a)[0] which point to base address of array of size 7 when incremented to 1 it goes to one-past-the-end of array a. As explained by --Yakk as below: This might be easier if we looked at this:

(&a)[1]-(&a)[0]

or

(&a+1)- (&a+0)

&a is a pointer to the array a of type "pointer to array of size 7". We add 1 to it, getting the pointer to the array afterwards in one case, and zero in the other case.

We then go down back to being arrays, and subtract. Subtraction triggers decay to pointer-to-first-element, so we get a pointer to the element right after the end of a, and a pointer to the first element of a.

&a[7]-&a[0]

which is

& (a+7)-& (a+0)

Now &* does nothing to things that are already pointers (which they are at that point), so:

(a+7)-(a+0)

The question then becomes, how much do you have to add to a+0 to reach a+7. The answer, not surprisingly, is 7:

(a+7) = (a+0)+7

and that is what is displayed.