Is there a reason the array name is not an lvalue value?

Question

For instance,

int x[10]; int i = 0; x = &i; //error occurs! 

According to the C - Reference Guide , an array name cannot be lvalue. So x cannot be an lvalue. But why can't the array name be lvalue? For example, why does the third line cause an error?

Answer 1

Your link is incorrect. An array can be an lvalue (but not a modifiable value of lvalue), and the "array name" (identifier) ​​is always an lvalue.

Take your example:

 int x[10]; int i = 0; x = &i; //error occurs! 

Apply C11 6.5.1, paragraph 2:

An identifier is the main expression if it was declared as a designation of an object (in this case it is an lvalue) ...

We see that x is a primary expression and is an lvalue value, as it was previously declared as an array object.

However, the rules of the C language indicate that an array expression in various contexts, including the left side of an assignment expression, is converted to a pointer that points to the first element of the array and is not a l value, even if the array was. In particular:

Unless it is an operand of the sizeof operator, the _Alignof operator is either unary and the operator, or is a string literal used to initialize an array, an expression that has type '' of type type is converted to an expression with type pointer '' to type such points to the original element of the array object and is not an lvalue value. If the array object has a register storage class, the behavior is undefined.

(C11 6.3.2.1, paragraph 3).

A pointer that is the result of the above conversion is not an lvalue, because an lvalue denotes an object, and there is no suitable object containing the value of the pointer; an array object contains array elements, not a pointer to these elements.

The example that you use in your question implies that you understand that the expression of the array decays (converts) to the value of the pointer, but I think that you do not understand that after the conversion, the value of the pointer and the array are two different things. A pointer is not an lvalue value; an array can be (and in your example it is). Regardless of whether arrays are lvalues, it really has nothing to do with your example; this is the value of the pointer you are trying to assign.

If you were to ask: Why do arrays break up into pointers when they are on the left side of the assignment operator? “Then I suspect that there is no particular good answer.” C just doesn't allow you to assign arrays, historically.

Answer 2

Array names are unmodifiable lvalues ​​in C. :)

Arrays are called extents of memory where their elements are located. Thus, you cannot replace one amount of memory with another amount of memory. Each amount of memory originally allocated to declare an array has its own unique name. Each array name is limited by its own memory area.

Answer 3

It is true that array names give pointer values ​​in many contexts. But the & operator also works, and you do not expect it to be assigned.

 int i = 42; int *j = malloc(sizeof *j); &i = j; /* obviously wrong */ int a[] = {1,2,3}; &a[0] = j; /* also obviously wrong */ a = j; /* same as the previous line! */ 

Therefore, when studying the relationship between arrays and pointers, remember that a usually matches &a[0] , and then you will not think that the value of lvalue-ness is an exception to the rule - it respects the rule perfectly.

Answer 4

An array is an lvalue, but it is an unmodifiable lvalue.

This is most likely due to type compatibility. For example, you can do this:

 struct ss { char c[10]; }; ... struct ss s1 = { { "hello" } }; struct ss s2 = s1; 

But not this:

 char s1[10] = "hello"; char s2[10] = s1;