在 C 中，每个带有“类型数组”的表达式将始终转换为“指向类型数组的指针”

Question

Example code:

int a[10]={0};
a = (void *) 0; // error: assignment to expression with array type

According to 6.5.1 Primary expressions

primary-expression:
 identifier
 constant
 string-literal
 ( expression )

and 6.3.2.1 Lvalues, arrays, and function designators

An lvalue is an expression with an object type or an incomplete type other than void; if an lvalue does not designate an object when it is evaluated, the behavior is undefined. When an object is said to have a particular type, the type is specified by the lvalue used to designate the object. A modifiable lvalue is an lvalue that does not have array type, does not have an incomplete type, does not have a const-qualified type, and if it is a structure or union, does not have any member (including, recursively, any member or element of all contained aggregates or unions) with a const-qualified type.

We know both a and (void *) 0 are l-value expression and a has a array of type.

If we look following definition:

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. If the array object has register storage class, the behavior is undefined.

Looks like type of a transfer from array of int to pointer to array of int , it becomes "modifiable lvalue". But my gcc 9.3.0 said:

error: assignment to expression with array type"

I am confused.

Answer 1

The part you missed is section 6.5.16p2 regarding constraints on Assignment Operators:

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

An array is not a modifiable lvalue, therefore it's a constraint violation to have it on the left side of an assignment.

Also, (void *)0 is not an lvalue, as per footnote 104 on 6.5.4p5:

A cast does not yield an lvalue. Thus, a cast to a qualified type has the same effect as a cast to the unqualified version of the type.

Answer 2

Looks like type of a transfer from array of int to pointer to array of int, it becomes "modifiable lvalue".

No, it doesn't. Per the definition already included in the question, a is converted to an expression of type "pointer to int " that is not an lvalue . Among the consequences of the result not being an lvalue is that you cannot assign to (whole) arrays.

But my gcc 9.3.0 said:

 error: assignment to expression with array type"

... which is easier to understand than "assignment to an expression that is not an lvalue".