C语言编程。 无符号整数评估问题

Question

In C programming I have this problem :

int v = 0XFFFD;
unsigned z=1;

Evaluate the expressions:

a) (v+1)/2  
b) -1 > z

In the problem book, for
a) the answer is -1 , and for
b) the answer is 1 .

Can anybody explain why?
Because in my opinion for
a) I think the answer is 32767 , and for
b) is 0 .

Answer 1

Case 1 : By default type of int is signed that means compile will check sign bit and if sign bit is one means output will be negative.

int v = 0XFFFD

How v will be stored in memory,if its a little endian it looks like below

    -------------------------
    | 1111 1111  | 1111 1101 |
    -------------------------
   MSB                      LSB
                             v

As you can see sign bit(15th bit, in case of short int) is one, and negative number are stored in memory as two's compliment. and two's compliment of v i is

 one's compliment =>  0000 0000 |  0000 0010
                                          +1
                      -----------------------
                      0000 0000 |  0000 0011 => 3 and since sign bit is one  that's why v is -3 

When you are doing (v+1)/2 == (-3+1)/2 => -1

Case 2 :

unsigned z = 1;

Let's say statement looks like

printf("%d\n", -1 > z);

Here while performing any operation between two operands you should be aware of consequences of if operands types are different.

 -1  >  z
 |      |           => comparing different operands
signed unsigned       (one is signed and other one unsigned) => Implicit type conversion will happen i.e implicitly signed gets promoted into unsigned by compiler)
                            ||
                        65535 > 1 => true => pints 1 
                        |
               (-1 is signed and its converted into unsigned and unsigned equivalent of -1 is 65535 in case of shot integer)

Answer 2

C defines its integer math operation functionally, not as bit patterns. Thinking of a number in bits may be useful, but let us see what C specifies.

---

int v = 0XFFFD;

int must be at least encode [-32767 ... 32767]. OP's case appears to use minimally sized int .

0XFFFD is a hexadecimal constant with the value of 65,533. Its type is the first that it fits in: int, unsigned, long, unsigned long ... . In this case it is unsigned .

int v = some_unsigned requires a conversion of the unsigned to int . When the source is out-of-range of an int , it is implementation defined what happens. A common result is a "wrap-around" by subtracting 2 ¹⁶ . Code could instead assign INT_MAX . It is implementation defined . Apparently code is wrapping in OP's case.

int v = 65533 - 65536; // -3
// or maybe
int v = 32767; // Uncommon implementation defined result.

(v+1)/2 is simply then (-3 + 1)/2 --> -1.

Had the hexadecimal constant fit in an int , perhaps on a platform with a 32-bit int , (65533 + 1)/2 would have been 32767 as considered by OP.

---

unsigned z = 1; is simple. z has the value of 1.

-1 > z compares an int -1 to an unsigned . Compares are done with the same type.

unsigned is higher rank than int , so -1 is converted to an unsigned and its value is changed by adding UINT_MAX +1 . -1 + UINT_MAX +1 --> UINT_MAX .

Now the compare is like UINT_MAX > 1 which is true. A compare result is an int , either 0 or 1. The result here is an int 1.

The result is independent of the range of unsigned .

Answer 3

1. because int is signed integer, 0xfffd equals -3. So (v+1)/2 gets -1
2. signed integer is automatically converted (coercion) to unsigned integer if you compare signed integer with unsigned integer.

Answer 4

Short story : your book seems to be quite bad.

Never, ever, initialize an int (a signed type) with a value that can be unsigned such as a hexadecimal constant.

Long story :

The results of "1." depends on a lot of things. First, it would be important to know the number of significant bits of int . In the following let us assume that it is 16 bit, otherwise the questions is even more senseless.

If it is 16, then the hex constant on the right side is greater than the maximal int . Since integer constants in C always are positive, it doesn't fit into an int and thus it has type unsigned int .

Thus a conversion of an unsigned to int must be done for the intialization. This is "implementation defined" that is your compiler is allowed to do what pleases, as long as it is documented.

Many compilers do a "lazy" conversion, that is, they just chose the value that has the same representation as the unsigned value. If your machine has two's representation for int (again an implementation dependent choice) the result would be a negative value, most likely -3 .

So, the real answer for "1." is: it depends . An introductory book should never ask a question in that way, simply suggesting that the result of that operation is depending on the integer representation. Integer representation only comes in by accident.