Are arrays in C a syntactic sugar for pointers?

Question

Let's take a look at the following code:

int arr[n];
// s.t. i<n
arr[i] = 12;
// s.t. i<n 
*(arr + i) = 12;

Is arr[i] is a syntactic sugar for *(arr+ i) ?

Answer 1

Yes you can say that- array subscript access is identical to pointer access with * dereference.

From 6.5.2.1p2 C11 standard N1570

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).

This by no means should give you the impression that arrays are pointers. Interestingly when you apply [] the array decays into pointer to first element and that is being used to access the subsequent elements.

Array object is a different thing - there are cases when arrays don't decay into pointers. They are not syntactic sugar - you can consider one example -

int p[] = {1, 2 ,3};
int *t = p;
size_t sz1 = sizeof p;
size_t sz2 = sizeof t;
printf("%zu %zu\n", sz1, sz2);

Run this and I will understand something much more relevant to your question. An array can't be realized using something other than the array itself. Array access is identical to pointer dereference but that doesn't mean pointers take the position of array or vice versa.

Key takeaway or red pill of C programming:

Arrays are arrays and pointers are pointers. They are different thing.

---

By the way if sizeof tricked you a bit - don't worry there is a standard section saying that. From 6.3.2.1p3

Except when it is the operand of the sizeof operator, the _Alignof 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...

Array doesn't get converted to pointer when used as an operand to sizeof. That's the thing. That's why you get what you get in earlier code snippet.

Answer 2

Yes, arr[i] is the same as *(arr+i) which is the same as *(i+arr) which again is the same as i[arr]

From Fabio Turati's comment: See "Why is a[5] == 5[a]" for more details.

Answer 3

Yes, you can access the elements of array with arr[i]/*(arr+i).

you can even use increment operation on array pointers. *ptr = &arr, ptr++

it means every time you add an integer or increment to array pointer the pointer add (size of datatype)*i to the previous pointer.

Answer 4

Strictly saying, array is NOT syntactic sugar for the pointer. By definition, "syntactic sugar" is language construct, which it allows you to write shorter / clearer an equivalent of some other language construct. Situation with pointers and arrays is different. Pointer is variable that contains memory address of some value. In difference, array is variable which contains those values themselves. However, syntax of C is built in a way, which allows you treat pointer as address of the first element of array and apply indexing operator on it. But I'd not say this is syntactic sugar, this is base syntax of language.

Answer 5

Absolutely not! To see that, just replace the array with a pointer in your example:

int *arr;
// s.t. i<n
arr[i] = 12;
// s.t. i<n 
*(arr + i) = 12;

This compiles fine, but it is undefined behavior. It is not guaranteed to work. In fact, there is nothing this program might do that would be considered a bug in the compiler.

Arrays are array; types containing data. Pointers point to where data is. Pointers don't contain actual data, while arrays do.

There are some circumstances where an array name behaves the same way as a pointer. This does not make the two identical.

For example, check this out:

int arr[12];
int ptr;

ptr = arr; // Legal
printf("array size %ld\n", sizeof(arr)); // Usually prints 12*4=48
printf("pointer size %ld\n", sizeof(ptr)); // Depending on your arch, will likely print either 4 or 8.