Data types — char, short, int, long, float, double, size_t: Exercises

This page is a staircase: we start by recognising the types, then apply the range formulas, then analyse tricky overflow/float traps, then synthesise multi-step programs, and finally reach mastery problems that combine everything. Every symbol used here was built in the parent note the parent Data Types note — if you want the "from zero" build-up of $2^{n}$ , two's complement, or the IEEE-754 formula, read that first.

Before we count anything, one picture fixes the vocabulary we lean on the whole page.

Figure — Data types — char, short, int, long, float, double, size_t

The two formulas we grind against, both derived in the parent note:

Level 1 — Recognition

Goal: read a type and immediately recall its size, its family (integer vs float), and whether it is signed.

L1.1

State: Which single data type has a sizeof that the C standard guarantees to equal $1$ ?

Recall Solution — L1.1

What we're asked: the one type whose byte-size is fixed by the standard (not by platform). Answer: char. Every other size (int, long, size_t, …) is only bounded by the standard, not pinned. By definition sizeof(char) == 1 — the byte is the unit of sizeof. See sizeof Operator.

L1.2

State: For each of unsigned int, size_t, signed char, double — say whether it can hold a negative value.

Recall Solution — L1.2

unsigned int → no (all patterns are non-negative; range starts at $0$ ).
size_t → no (it is unsigned — a size can never be below $0$ ).
signed char → yes (top bit carries negative weight in two's complement).
double → yes (it has a dedicated sign bit $s$ in $(- 1)^{s} \times \dots$ ).

L1.3

State: Order these by typical size on a 64-bit Linux (LP64), smallest first: long, char, int, short.

Recall Solution — L1.3

char (1) $\leq$ short (2) $\leq$ int (4) $\leq$ long (8). Why: this matches the standard's guaranteed ordering $char \leq short \leq int \leq long$ . Sizes are bytes; the picture of stacked boxes in Figure s01 shows why bigger boxes hold bigger numbers.

Level 2 — Application

Goal: plug numbers into the two range formulas and read off exact bounds.

L2.1

State: Compute the exact range of a signed char ( $n = 8$ ).

Recall Solution — L2.1

What we do: substitute $n = 8$ into the signed formula. $[- 2^{8 - 1}, 2^{8 - 1} - 1] = [- 2^{7}, 2^{7} - 1] = [- 128, 127]$ Why $128$ vs $127$ : there are $2^{7} = 128$ negative patterns but only $127$ strictly-positive ones, because zero uses a slot on the non-negative side. The asymmetry is not a bug — it is the two's-complement design.

L2.2

State: Compute the range of unsigned short ( $n = 16$ ).

Recall Solution — L2.2

What we do: unsigned formula with $n = 16$ . $[0, 2^{16} - 1] = [0, 65535]$ Why $65535$ not $65536$ : $2^{16} = 65536$ counts the patterns; subtract $1$ because pattern number one is the value $0$ .

L2.3

State: What is INT_MAX and INT_MIN for a 32-bit int?

Recall Solution — L2.3

Signed formula, $n = 32$ : $INT_MIN = - 2^{31} = - 2147483648, INT_MAX = 2^{31} - 1 = 2147483 647.$ Why it matters: adding $1$ to INT_MAX is undefined behaviour in signed arithmetic — see Integer Overflow and Undefined Behaviour.

L2.4

State: How many distinct values can a 4-bit unsigned "nibble" hold, and what is its max?

Recall Solution — L2.4

Count of patterns $= 2^{4} = 16$ . Max value $= 2^{4} - 1 = 15$ . So the range is $[0, 15]$ — exactly 16 values, matching Figure s02's little clock of 16 positions.

Level 3 — Analysis

Goal: predict what a program prints when wrap-around, conversion, or float rounding bites.

L3.1 — signed wrap

State:

signed char c = 127;
c = c + 1;
printf("%d\n", c);

Predict the output.

Recall Solution — L3.1

What happens: $127$ is 0111 1111. Adding $1$ gives 1000 0000. Read as two's complement, 1000 0000 is the most-negative pattern $= - 2^{7} = - 128$ . Why: the clock in Figure s02 wraps — one tick past the highest positive lands on the lowest negative. Output: -128. (Note: at wider int width this addition would be fine; the wrap here happens because c is stored back into an 8-bit signed char. Signed overflow at full int width is UB, see Integer Overflow and Undefined Behaviour.)

L3.2 — the char=200 classic

State:

char c = 200;            // assume char is signed
unsigned char u = 200;
printf("%d %d\n", c, u);

Predict.

Recall Solution — L3.2

Pattern: $200 =$ 1100 1000.

As unsigned char: value is literally $200$ .
As signed char: top bit set ⇒ value $= 200 - 256 = - 56$ . Why $- 256$ : the two's-complement rule "if top bit is 1, subtract $2^{n}$ " with $n = 8$ . See Type Conversion and Promotion for why the same bits get two readings. Output: -56 200.

L3.3 — the float equality trap

State: Does 0.1 + 0.2 == 0.3 evaluate to true in C?

Recall Solution — L3.3

No. Neither $0.1$ nor $0.2$ has a finite binary fraction (just as $1/3$ has no finite decimal). Each is rounded to the nearest representable double, and the rounded sum is 0.30000000000000004, which differs from the rounded 0.3. Fix: compare fabs((0.1+0.2) - 0.3) < 1e-9. Details in IEEE-754 Floating Point.

L3.4 — the unsigned countdown

State:

for (size_t i = 3; i >= 0; i--)
    printf("%zu ", i);

What happens?

Recall Solution — L3.4

Infinite loop. size_t is unsigned, so i >= 0 is always true. After i == 0, i-- computes 0u - 1, which wraps to the maximum size_t (e.g. $2^{64} - 1$ ), and the loop never ends. It prints 3 2 1 0 then a giant number, then keeps running. Fix: loop with a signed index, or use for (size_t i = 3; i-- > 0; ) idiom.

Level 4 — Synthesis

Goal: chain several ideas — bit layout, conversion, precision — into one answer.

L4.1 — decimal digits of `float`

State: From its bit layout, derive how many significant decimal digits a float carries.

Recall Solution — L4.1

Step 1 (WHAT): a float has $23$ explicit mantissa bits plus $1$ implicit leading bit $= 24$ bits of significand. Step 2 (WHY the log): each binary bit multiplies the number of representable values by $2$ ; to convert "how many bits" into "how many decimal digits" we ask how many powers of ten fit in that many powers of two — that is exactly $lo g_{10} 2 \approx 0.301$ decimal digits per bit. Step 3: $24 \times 0.301 \approx 7.2$ ⇒ ~7 significant decimal digits. For double: $53 \times 0.301 \approx 15.95$ ⇒ ~15–16 digits.

L4.2 — encode a value in IEEE-754 `float`

State: Give sign $s$ , stored exponent $e$ , and the value of $2^{e - bias}$ for the number $x = - 6.0$ in 32-bit float (bias $127$ ).

Recall Solution — L4.2

Step 1 (sign): $x < 0$ so $s = 1$ . Step 2 (normalize): $6.0 = 1.5 \times 2^{2}$ , so the significand is $1. f = 1. 1_{2}$ (i.e. $1.5$ ) and the true exponent is $2$ . Step 3 (bias it): stored $e = true exponent + bias = 2 + 127 = 129$ . Check: $(- 1)^{1} \times 1.5 \times 2^{129 - 127} = - 1.5 \times 4 = - 6.0$ . ✅ Formula recalled: $x = (- 1)^{s} \times (1. f)_{2} \times 2^{e - bias}$ , from IEEE-754 Floating Point.

L4.3 — promotion in a mixed expression

State:

unsigned int a = 1;
int b = -2;
printf("%s\n", (a + b > 0) ? "positive" : "not");

What prints, and why?

Recall Solution — L4.3

What: in a + b, the int b is converted to unsigned int (usual arithmetic conversions promote the signed operand to unsigned). -2 becomes $2^{32} - 2 = 4294967294$ . Then: $1 + (2^{32} - 2) = 2^{32} - 1 = 4294967295$ (mod $2^{32}$ ), which is $> 0$ . Output: positive. Why the surprise: you expected $1 + (- 2) = - 1$ , but signed→unsigned conversion happened before the comparison. See Type Conversion and Promotion.

Level 5 — Mastery

Goal: reason about limits, degenerate inputs, and full programs where several traps stack.

L5.1 — the most-negative has no positive twin

State: For 8-bit signed char, what does -INT_MIN-style negation do? Concretely, what is the value of -(signed char)(-128) when kept in a signed char?

Recall Solution — L5.1

What: $- 128$ is 1000 0000. To negate in two's complement: invert bits → 0111 1111, add $1$ → 1000 0000. We got the same pattern back! Why: $+ 128$ is not representable in signed char (max is $127$ ). The most-negative value is its own negation modulo $2^{8}$ . So -(-128) stays -128. Lesson: the range asymmetry ( $[- 128, 127]$ ) means "negate" is not always safe. At full int width, -INT_MIN is UB — Integer Overflow and Undefined Behaviour.

L5.2 — precision gap of `float` near a big number

State: Around $x = 2^{24}$ , a 32-bit float cannot represent every integer. What is the spacing between consecutive representable floats there, and hence: does (float)16777216 + 1 equal 16777217?

Recall Solution — L5.2

Step 1: with $24$ significand bits, consecutive floats near $2^{k}$ are spaced $2^{k - 23}$ apart (the last mantissa bit has weight $2^{k - 23}$ ). Step 2: at $k = 24$ : spacing $= 2^{24 - 23} = 2^{1} = 2$ . So representable values step by $2$ : $\dots, 16777216, 16777218, \dots$ — the odd integer $16777217$ is skipped. Step 3: (float)16777216 + 1 rounds to the nearest representable value. $16777217$ is exactly halfway... actually it rounds to the even neighbour $16777216$ . Answer: (float)16777216 + 1 == 16777216, not $16777217$ . Precision is relative: the higher you go, the coarser the grid (Figure s03).

L5.3 — zero and degenerate width

State: (a) What is the range of a hypothetical $n = 1$ -bit signed integer? (b) What is $2^{n}$ when $n = 0$ , and does a $0$ -bit type make sense?

Recall Solution — L5.3

(a) $n = 1$ signed: $[- 2^{0}, 2^{0} - 1] = [- 1, 0]$ . Just two values: 1 means $- 1$ , 0 means $0$ . There is no positive value — all the asymmetry collapsed onto the single negative. (b) $n = 0$ : $2^{0} = 1$ — exactly one pattern (the empty pattern), which can only encode the value $0$ . C has no $0$ -bit type, but the formula stays consistent: one pattern, range $[0, 0]$ . This is the degenerate limit that confirms the counting principle never breaks.

L5.4 — full program forecast

State:

#include <stdio.h>
int main(void) {
    unsigned char x = 250;
    x += 10;                 // (A)
    signed char y = x;       // (B)  assume signed char, value-preserving mod 256
    printf("%u %d\n", x, y);
    return 0;
}

Forecast the two printed numbers.

Recall Solution — L5.4

(A): unsigned char range is $[0, 255]$ . $250 + 10 = 260$ . Unsigned arithmetic wraps mod $2^{8} = 256$ : $260 - 256 = 4$ . So x == 4. (B): 4 fits in signed char $[- 128, 127]$ , so y == 4 (no re-interpretation needed). Output: 4 4. Why (A) is defined but signed overflow isn't: unsigned wrap-around is specified by the standard (mod $2^{n}$ ); signed overflow is UB. This is the single most important distinction from Integer Overflow and Undefined Behaviour.

Active Recall

Recall One-line self-test (cover the answers)

signed char range? → $[- 128, 127]$
unsigned short max? → $65535$
(char)200 as signed? → $- 56$
float significant digits & why? → ~7, from $24 \times lo g_{10} 2$
Spacing of floats near $2^{24}$ ? → $2$
250u + 10 in unsigned char? → $4$ (wraps mod 256)
-(signed char)(-128)? → still $- 128$

Range of an n-bit signed integer?

[- 2^{n - 1}, 2^{n - 1} - 1]

unsigned char max value?

255

(char)200 printed with %d (signed char)?

- 56

Does 0.1 + 0.2 == 0.3?

false (binary rounding)

Value of (float)16777216 + 1?

16777216

(odd integer is skipped)

unsigned char x = 250; x += 10; value of x?

4

(wraps mod 256)