C 语言，在赋值中做隐式转换

Question

The C language, does implicit conversion in assignments, both from smaller types to larger types and from larger types to smaller ones, is that it?

#include <stdio.h>

int main(void) {
   int x = 5;
   long y = x; // conversion implicit ?

   long a = 12;
   int b = a; // conversion implicit ?
   return 0;
}

Another thing, have you written in the language standard about conversions when using the assignment operator?

Answer 1

I'll try to explain what the C standard says formally. We can start by reading 6.5.16.1/2:

In simple assignment (=), the value of the right operand is converted to the type of the assignment expression and replaces the value stored in the object designated by the left operand.

Simple assignment meaning = , as opposed to the various compound assignments like for example += .

The above mentioned conversion only happens if the assignment is a valid form. There's a list of all forms of valid assignments (you don't need to read it, I'm including it here for the sake of completeness):

6.5.16.1 Simple assignment

Constraints

One of the following shall hold:

• the left operand has atomic, qualified, or unqualified arithmetic type, and the right has arithmetic type;
• the left operand has an atomic, qualified, or unqualified version of a structure or union type compatible with the type of the right;
• the left operand has atomic, qualified, or unqualified pointer type, and (considering the type the left operand would have after lvalue conversion) both operands are pointers to qualified or unqualified versions of compatible types, and the type pointed to by the left has all the qualifiers of the type pointed to by the right;
• the left operand has atomic, qualified, or unqualified pointer type, and (considering the type the left operand would have after lvalue conversion) one operand is a pointer to an object type, and the other is a pointer to a qualified or unqualified version of void, and the type pointed to by the left has all the qualifiers of the type pointed to by the right;
• the left operand is an atomic, qualified, or unqualified pointer, and the right is a null pointer constant; or
• the left operand has type atomic, qualified, or unqualified _Bool, and the right is a pointer.

If a type of assignment is not on that list, it is a "constraint violation", meaning invalid C, and the compiler must issue a message about it.

If an assignment is on that list, the right operand is implicitly converted to the type of the left operand. In your case long y = x; , it fits the first bullet in the list: the left operand is an arithmetic type (integer or float) and the right operand is also arithmetic type. So the int operand x gets converted to long upon assignment.

---

Regarding qualifiers:

All the stuff about "qualified type" refers to const etc type qualifiers. During assignment, something called lvalue conversion occurs. 6.5.16/3:

The type of an assignment expression is the type the left operand would have after lvalue conversion.

Not very helpful if you don't know what an "lvalue conversion" is. The formal definition is found in 6.3.2.1/2, but it's equally unhelpful for beginners. To summarize it in simple terms, lvalue conversion means that it doesn't matter what qualifiers ( const , volatile etc) the right operand has, it gets converted to have the same qualifiers as the left operand. The term "lvalue" actually originates from "left value of the assignment operator".

Answer 2

From my knowledge it does, you can use print statements and see the warning about the types.

#include <stdio.h>

int main(void) {
   int x = 5;
   printf("%d ",x);
   long y = x; // conversion implicit ?
   printf("%d ",y);


   long a = 12;
   printf("%ld ",a);
   int b = a; // conversion implicit ?
   printf("%ld ",b);
   return 0;
}