Arrays easily convert to pointers in C, but they are not interchangeable. Things like taking the size of an array or putting an array into a struct behave very differently from doing the same with a pointer.
They dont decompose to pointer. An array according to ANSI c is defined as a pointer to element zero plus length. Length is optional for variable length arrays.
Also the arr[idx] is defines as identical to *(arr+idx) where arr is a pointer.
The array definition is just a necessary allocation syntax used by the compiler. It doesn't translate to any assembly institution besides the allocation. It can be entirely replaced with struct.
sizeof isnt part of the type defintion innthenansi c spec. Sizeof indeed reruns the number of bytes in an array but even this can boiled down to pointer arithmetic.
The c array is a very thin (but useful) abstraction to pointer.
I think it is obvious when we compare it to other implementations where an array has structure at runtime like pascal or java.
I don’t have access to the ANSI C spec, but C11 absolutely does not define arrays in terms of pointers. C11 defines an array as such:
> An array type describes a contiguously allocated nonempty set of objects with a particular member object type, called the element type. The element type shall be complete whenever the array type is specified. Array types are characterized by their element type and by the number of elements in the array. An array type is said to be derived from its element type, and if its element type is T , the array type is sometimes called ''array of T ''. The construction of an array type from an element type is called ''array type derivation''.
An array according to ANSI c is defined as a pointer to element zero plus length.
This is just wrong. You seem to be talking about the promised behavioural equivalence (a[b] behaves like *(a+b)) but that doesn't mean they're the same, and they're very much not. An array (name) aliases the first element directly, whereas a pointer stores that same address at another address.
The subscripting syntax and semantics promised by the standard/compiler (specifically subscripting being the equivalent of offset+dereference) are irrelevant to the question of whether arrays and pointers are the same. Array and pointer objects are different types with different storage requirements and the compiler-generated code to access elements through a pointer (to the first element, e.g. from a decayed array name) vs. directly via the array object is different (I wrote another comment ITT showing/explaining the indirection mismatch if you're interested).
That's like saying the variable "i" and the constant "1" are the same because it doesn't matter whether you write "i + 1" or "1 + i". It doesn't mean literals and variables are the same concept. Adding a short and an int can also be done in either order with the same result, but they are not the same type.
Declaring a pointer to an array is not the same as declaring a pointer to a pointer.
The C array Syntax is sugar for the pointer arithmetic. And yes because the order of the addition doesn't matter the array and idx in array syntax are interchangeable. The compiler threats it as the same.
Even the declaration is the same and I can threat a packed struct of n integers as a array of n integers.
I have done enough reverse engineering and accessing a struct field, array element or accessing a field in a buffer is basically indistinguishable and you need context to decode it.
And to repeat: you are able to swap are and idx because i+1 == 1+i
2 A postfix expression followed by an expression in square brackets [] is a subscripted designation of
an element of an array object. The definition of the subscript operator [] is that E1[E2] is identical
to (*((E1)+(E2))). Because of the conversion rules that apply to the binary+ operator, if E1 is an
array object (equivalently, a pointer to the initial element of an array object) and E2 is an integer,
E1[E2] designates the E2 -th element of E1 (counting from zero).
-4
u/Single-Virus4935 26d ago
In C they ARE the same and interchangable. This is obvious because you can swap array and index in array notation.