1. ## Numeric Ranges

If int one_billion = 1000000000 is times by three it displays -1294967296.
Apparently a truncating happens? but I thought truncating would suggest a chopping off of digits?...however 1 billion times three would add any digits? it can already display 10 digits it would make sense that it could display upto..9999999999 right ?

2. It still is truncated, but remember that a signed integer is represented by two's complement. So for example "0x7FFF" is 32767 for both unsigned and signed short, but "0x8000" is 32768 for unsigned and -32768 for signed.

And no, a typical int( one that is 32 bits ) can represent anything from 0 to 4294967295.

3. so its a signed int short it that gets overloaded? once it gets over 0x7FFF it gets inverted ? going from 32768 to -32768 "FFFFFFFFFFFF8000".?..

4. It basically behaves like this (using a 3 bit number here):
Code:
```binary  unsigned  signed

000         0       0
001         1       1
010         2       2
011         3       3
100         4      -4
101         5      -3
110         6      -2
111         7      -1```
Demo:
Code:
```void print(unsigned short us) {
cout << "unsigned(" << us << ") -> signed(" << static_cast<signed short>(us) << ")\n";
}

int main()
{
unsigned short us;

// Lower values identical
for (us = 0; us < 8; ++us) {
print(us);
}

cout << '\n';

// Mid values, signed type becomes negative (starting with maximum negative value)
for (us = 32764; us < 32772; ++us) {
print(us);
}

cout << '\n';

// Highest values, signed type has counted down to -1
for (us = 65528; us < 65535; ++us) {
print(us + 1);
}

cout << '\n';
}```