Computer System Cp2.2 Truncating and expanding in C
Tags: computerscience, c, system, cpp
Published: 2022-01-28 02:15:23

If there is a question asking you, what these binary number means in C? (Basing on 32-bit machine, and we defaultly regrad that we are using 32-bit machine, except for spcially mention we are using others)

- 1011?
- 0100 0001?

Actually, it's hard to be determined, due to the fact that I haven't told you what data type you are using to contain them in this 32-bit machine. 

That is, what binary number 1011 actually is, is basing on the data type that you want to assign.
In different data type, for example:

- unsigned integer: 11
- signed integer: -5
(the difference of the range of signed and unsigned are described in [chapter 2.1](https://dev.to/devide_r_conquer/computer-systems-principles-cp2-nfo))

And, we have 0100 0001:
- unsigned integer: 65
- char: `'A'`

That is, the data type you declare in C program, will be determined to how this 32-bit machine "read". 

- If you declare `unsigned int a = 65;`
   a is printed as integer `65`
- If you declare `int *p = 65;`
   p is actually an address number 65, pointing a memory place containing an `int` variable.
- If you declare `unsigned int c = 'A';`
   c is actually 65, because when a char type variable is assigned to an `int` type, the machine will "read" this memory as an integer, where the ascii code of A is 65.

###But, how it works? 

I mean, we already know from chapter 2.1 that, `char` using 1 byte (that is 8 bits) to store the value, and `unsigned int` use 4 bytes (that is 32 bits) to store the value.

So now, we are going to thinking questions about **<u>value casting<u>** and **<u>bits truncating (extanding)</u>** between different data type in C.

There are two kinds of casting, obviously having upcasting and downcasting. However, when having casting problem, there are also be with **Extanding** and **Truncating**.
- Upcasting: Low byte(s) cast to high bytes.
- Downcasting: High bytes cast to low byte(s).
- There is also casting value between same byte:
   signed int => unsigned int
       or
   unsigned int => signed int

- ### Extanding:
   Happens in low bytes to high bytes. When a low-byte variable is cast to high-byte variable, the new high bits of high-byte variable will be extanded by
- 0: if the original value is positive
- 1: if the original value is nagetive

Example 1:
```
// In memory, c is 0100 0001, which is 1 byte (8 bits).
unsigned char c = 65;

unsigned int a = c; // Upcasting and extanding

//Now in memory, due to c is originally positive 
//number, variable a will be extanding by 0 on new high bit, 
//that is, adding 0s on the left(significant 
//position) till filling all 4 bytes (32 bits)
//a in memory:
//0000 0000 0000 0000 0000 0000 0100 0001

printf("%d", a);
//65
```

Example 2:
```
signed char c = -1;
signed int a = c;
printf("%d", a);
//-1
//Explaination:
//c in memory stored as:
//1111 1111
//(The way to figure out how to get the nagetive value from decimal, 
//please read the last chapter, section about 2's complement)
//Then, upcasting the 1111 1111, adding 1 (because original value 
//is nagetive value) on high bit position, so we have this in 4 bytes:
//1111 1111 1111 1111 1111 1111 1111 1111
```
Answer by calculator:
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/h6s4wfq90nryz3ux1q7p.jpg)
 
### Truncating:
How about when a high-bit variable casted to a low-bit variable? Obviously, the low-bit variable can not contain that many bits. So it must do the truncating on high bit position.

Example 3:
```
unsigned int a = 129;
//which is 0000 0000 0000 0000 0000 0000 1000 0001
//stored in memory, in 32-bit machine
//now I want to downcast it to signed char
signed char c = a;
printf("%d", c);
//what is the answer?
//It's -127
```
Explaination: 
**Always remember one sentence:**
<u>The data type decide the way that the computer reads!</u>
No matter how this value being stored in memory, the real value that computer will use just depends on how it reads this value.

Even though 129 is stored as an unsigned integer like:
 0000 0000 0000 0000 0000 0000 1000 0001
But eventually the computer reads this value as a data of signed char, that is, making this value being read only 8 bits from the lowest bit position, which is only
~~0000 0000 0000 0000 0000 0000~~ **1000 0001**
And, 1000 0001 in signed char is -127.
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2oxquogjc1da7kd509zq.png)


### Casting between **signed ** and **unsigned **:

If you follow these rules, you can hardly get lost:
1. **It's only about how computer reads!**
2. Remember, the most significant position of signed value is describing if it is positive(0) or nagetive(1).

-----------
Besides, bit operaters like |, &, <<, >>, <<< should be familiar with, even they are seldom used in our program. But, it did be used so many in like registers, memory allocation and ALU, which are located in the deeper level of system.

If you have any questions, feel free to comment here!