How does sizeof work with this dereferencing of a pointer to array?

Question

Here I have a pointer ptr to array arr of 4 integers. ptr points to the whole array. ptr[0] or *ptr points to the first element of the array, so adding 1 to ptr[0] gives the address of the second element of the array.

I can't understand why using sizeof(ptr[0]) gives the size of the whole array, 16 bytes, not the size of only the first element, 4 bytes, (as ptr[0] points to the first element in the array).

int arr[4] = {0, 1, 2, 3};
int (*ptr)[4] = &arr;
printf("%zd", sizeof(ptr[0])); //output is 16

Shouldn't the second line be `int *ptr = arr;` ? That would make it point to the start (first element of) the array, which is equivalent to `&arr[0]`. — Andreas Wenzel, Oct 27 '19 at 16:48
@AndreasWenzel *Shouldn't the second line be `int *ptr = arr;`?* Actually, no. `int (*ptr)[4]` creates `ptr` as a pointer to a full array of four `int` values. Pointer syntax like that is necessary to dynamically allocate true-multidimensional arrays. The "2-dimensional arrays" created with nested `malloc()` loops and wrongly described as multidimensional arrays are really 1-d arrays of pointers to multiple 1-d arrays. See https://stackoverflow.com/questions/42094465/correctly-allocating-multi-dimensional-arrays — Andrew Henle, Oct 27 '19 at 17:02

chux - Reinstate Monica · Accepted Answer · 2019-11-10T12:27:55.107

6

OP: ptr[0] points to the first element in the array.

Type confusion. ptr[0] is an array.

ptr is a pointer to array 4 of int.
ptr[0], like *ptr deferences the pointer to an array.
sizeof(ptr[0]) is the size of an array.

With sizeof(ptr[0]), ptr[0] does not incur "an expression with type ‘‘pointer to type’’ that points to the initial element of the array object" conversion. (c11dr §6.3.2.1 3). With sizeof, ptr[0] is an array.

edited Nov 10 '19 at 12:27

answered Oct 27 '19 at 16:47

chux - Reinstate Monica

143,097
13
135
256

I thought that because `ptr[0]` points to an integer so `sizeof[ptr[0])` equal the size of integer . – Abd-Elrahman Mohamed Oct 27 '19 at 17:10
@Abd-ElrahmanMohamed `ptr[0]` points to an array - in this case, the array `arr[]`. – chux - Reinstate Monica Oct 27 '19 at 17:52
No , ptr[0] is the address of first element in the array which means it points to integer . But ptr[0][0] is an integer not points to integer . – Abd-Elrahman Mohamed Oct 27 '19 at 17:53
1

@Abd-ElrahmanMohamed Agree "But ptr[0][0] is an integer not points to integer ". "ptr[0] is the address of first element in the array" is not true. – chux - Reinstate Monica Oct 27 '19 at 17:57
1

@Abd-ElrahmanMohamed yes, the values are same but types are different. ptr[0] has array type and `&ptr[0][0]` has `int *` type – Volodymyr Boiko Oct 27 '19 at 17:58
1

@chux `ptr[0]` (implicitly converted to `int *`) would evaluate to address of the first int element. – Volodymyr Boiko Oct 27 '19 at 18:00
@GreenTree `sizeof(ptr[0])` does not incur a _implicit conversion_.to `int *`. – chux - Reinstate Monica Oct 27 '19 at 18:05
@chux https://stackoverflow.com/questions/18518255/why-is-array-name-a-pointer-to-the-first-element-of-the-array – Abd-Elrahman Mohamed Oct 27 '19 at 18:05
@Abd-ElrahmanMohamed that reference about arrays does not apply here. `ptr` is not an array. It is a pointer, a pointer to an array. – chux - Reinstate Monica Oct 27 '19 at 18:07
@chux if you try to print ptr[0] , ptr[0]+1 you will notice that the difference is 4 which means that ptr[0] is pointer to int – Abd-Elrahman Mohamed Oct 27 '19 at 18:10
1

@chux about sizeof - right, I misunderstood the context of what you said – Volodymyr Boiko Oct 27 '19 at 18:12
1

@Abd-ElrahmanMohamed That does not. `printf("someforamt", ptr[0] , ptr[0]+1)` does something different than `sizeof(ptr[0])`. The `ptr[0]` in the first case goes through an inplicit conversion. With `sizeof(ptr[0])`, `ptr[0]` does not. – chux - Reinstate Monica Oct 27 '19 at 18:12
1

@Abd-ElrahmanMohamed Your reference question's accepted [answer](https://stackoverflow.com/a/18518282/2410359) points out the `sizeof` exception. – chux - Reinstate Monica Oct 27 '19 at 18:20
1

@Abd-ElrahmanMohamed "**Except** when it is the operand of the **sizeof operator** or the unary & operator, or is a string literal used to initialize an array, an expression that has type ‘‘array of type’’ is converted to an expression with type ‘‘pointer to type’’ that points to the initial element of the array object and is not an lvalue." c11 §6.3.2.1 3 – chux - Reinstate Monica Oct 27 '19 at 18:22
@chux if I want to understand pointers and its related topics very well . What book do you advise me to read ? – Abd-Elrahman Mohamed Oct 27 '19 at 18:32
1

@Abd-ElrahmanMohamed No book comes to mind. Best to remember an array is not a pointer and a pointer is not an array. [Where do I find the current C or C++ standard documents?](https://stackoverflow.com/q/81656/2410359) is useful. – chux - Reinstate Monica Oct 27 '19 at 18:47
1

@Abd-ElrahmanMohamed cppreference.com and the standard if the first is not enough. – Volodymyr Boiko Oct 27 '19 at 18:47

Volodymyr Boiko · Answer 2 · 2019-10-27T17:12:28.290

ptr here is of type pointer to an array of 4 int elements and the array type has size 16 on your platform (sizeof(int) * (number of elemetns)).

I can't understand why using sizeof(ptr[0]) gives the size of the whole array 16 bytes not the size of only the first element 4 bytes

because C type system has array types. Here both arr and *ptr has it. What you declare that you have. To get sizeof int here you should sizeof(ptr[0][0]) - where ptr[0] evaluates to array.

score 2 · Answer 3 · answered Oct 27 '19 at 17:14

with int (*ptr)[4] = &arr ; you have a pointer to an array of four integers and pointing to arr.

ptr is now pointing to arr, like a double pointer. We can access elements of arr using ptr[0][x] where x could be 0 to 4.

So sizeof(ptr[0]) is same as sizeof(arr)

score 2 · Answer 4 · answered Oct 27 '19 at 19:21

By definition, ptr[0] is the same as *(ptr + 0) which in turn is the same as *ptr. Further, ptr is initialized with &arr, so *ptr is *&arr and that is just arr. Note that the intermediate storage of &arr in ptr does not perform any array decay, so the equivalence is maintained and no type information is lost.

Note that all this is computed at compile-time, just to avoid this additional pitfall.

How does sizeof work with this dereferencing of a pointer to array?

4 Answers4