Why isn't this pointer arithmetic allowed in C?

Question

char arr[] = "Hello";
arr = arr + 1;  // error occurs

As far as I know, an expression that has array type is converted to pointer type that points to the initial element of the array. Therefore, I expected arr = arr + 1 (pointer to first element(arr) of the array becomes the pointer to the second element of the array)to work. Why doesn't this work in C?

Answer 1

arr + 1 is indeed a pointer to the second element of the array (i.e. &arr[1]).

However, that does not mean that you can somehow write that pointer value back into arr. You can't do it for at least two reasons.

Firstly, arr is an array of char elements, not a pointer. There's an obvious type mismatch here.

Secondly, being an array, arr a non-modifiable lvalue. You cannot change arr itself, you can only change its elements (this distinction is somewhat hard to grasp, but it is there).

Finally, if we just ignore the deeper intricacies and focus on what formally happens at the top level, due to array type decay your expression is equivalent to

(char *) arr = (char *) arr + 1;

The assignment is impossible since the left-hand side is a result of [implicit] type conversion. In C type conversions always produce rvalues. You cannot assign to rvalues.

In other words, it is not the "pointer arithmetic" that's disallowed here. The pointer arithmetic is fine. It is what you do with the result of that pointer arithmetic that causes the error.

Answer 2

Arrays are non-modifiable lvalues. They can't be the left operand of an assignment operator.

C11-§6.3.2.1:

A modifiable lvalue is an lvalue that does not have array type, does not have an incomplete type, [...]

§6.5.16/2:

An assignment operator shall have a modifiable lvalue as its left operand.

In the statement

arr = arr + 1; 

arr is the left operand of = operator and is of array type. It can't be modified.
So, it's not the pointer arithmetic but the constraint by the language on the assignment operator that is the reason for syntactical error.

---

Note that in some contexts arrays decay to a pointer to its first element, though pointers and arrays are different types. Arrays are not pointers. It is only the pointer arithmetic and array indexing which are equivalent. For example

char *ptr = &arr[0] + 1 => &(*(arr + 0)) + 1 => &(*arr) + 1 => arr + 1 // * and & nullify each other 

Answer 3

This is because arrays are similar to pointers except that they can not be modified. However you can modify a pointer that is pointing to an array. For the above example you can do like this:

char arr[]="Hello";
char *ptr=arr;
ptr=ptr+1;

Initially the pointer ptr will be pointing to the first character of the array i.e. 'H' and after modifying the value it will point to the second character i.e. 'e'. You can also do the following:

char arr[]="Hello";
char *ptr=arr;
ptr=arr+1;

Both produce the same effect which shows that arr+1 is indeed pointer arithmetic. However you can not modify the value of arr because its type is that of a character array and not pointer to a character array.

Answer 4

As far as I know, an expression that has array type is converted to pointer type that points to the inital element of the array.

It is true in most contexts. It is not true in the following contexts:

1. When using the addressof operator (&arr). The type of &arr is char (*)[6]. It is not char**.

2. When using the sizeof operator. sizeof(arr) is 6. Had it been a pointer, it would be the size of a pointer (4 or 8 in most common platforms).

3. When used as the LHS of an assignment operator. A variable of array type is not modifiable.

Therefore, I expected arr = arr + 1 (pointer to first element(arr) of the array becomes the pointer to the second element of the array)to work. Why doens't this work in C?

The RHS of the expression evaluates to a pointer to the second element of arr. However, that line does not work due to (3) above. arr is not a modifiable value. It cannot be used as the LHS of an assignment operator.

Answer 5

char[] is not pointer, while char* is a pointer. This works, but it is wrong solution:

int main()
{
    char *arr = "Hello";
    arr = arr + 1;  // Wrong!
    printf("%s\n", arr); // Output: ello
}

If arr is heap-allocated with malloc you can get memory leak if free memory starting arr+1 not arr.

But you can do something like this:

int main()
{
    char arr[] = "Hello";
    char *wordFromSecondLetter = &arr[0] + 1;
    printf("%s\n", wordFromSecondLetter); // Output: ello
}

Or like this

int main()
{
    char arr[] = "Hello";
    printf("%s\n", &arr[1]); // Output: ello
}

Answer 6

Because arr is not a pointer but a char array. You can verify this by checking sizeof arr. To get a pointer to char, you should use char *arr = "Hello";.

The biggest difference between a pointer and an array is that you can directly assign a value to a pointer, but you can't do this to an array.

In fact, when you write arr + 1, arr "decays" to the pointer to its first element, that is to say, arr == &arr[0]. So arr + 1 is legal pointer arithmetic, but giving its value to arr, which is an array, is illegal.