C Integer Types: Sizes and `sizeof` Verification

The Integer Family: A Trade-off Between Range and Memory

In systems programming, and especially in game development, every byte of memory can count. C provides a family of integer types to give you, the programmer, precise control over this trade-off. A variable that only needs to store a player's level (e.g., 1-99) doesn't require the same amount of memory as one storing, for instance, a high score that could run into the billions.

The basic integer types you'll work with, in increasing order of guaranteed minimum size, are:

• char
• short int (or just short)
• int
• long int (or just long)
• long long int (or just long long)

Each of these types can be modified with the signed or unsigned keyword.

• signed (the default): The variable can hold both positive and negative values.
• unsigned: The variable can only hold non-negative values (zero and positive). This effectively doubles the maximum positive value the type can store compared to its signed counterpart.

The following video gives a fast-paced overview of these types, their typical memory usage, and the crucial unsigned modifier.

Choosing unsigned is a logical decision when you know a value will never be negative, such as a player's health, an item count in an inventory, or a timer. This not only communicates the variable's purpose but also gives you a larger positive range for the same amount of memory.

The Portability Problem: A long isn't always a long

A critical concept in C is that the standard does not strictly define the exact byte size for types like int and long. It only guarantees minimum ranges, such as:

• short is at least 16 bits (2 bytes).
• int is at least 16 bits (2 bytes).
• long is at least 32 bits (4 bytes).
• long long is at least 64 bits (8 bytes).

The actual size of these types depends on the combination of the CPU architecture (32-bit vs. 64-bit) and the compiler/OS conventions. This is known as the data model. The three most common data models you will encounter are:

Notice the key difference: on 64-bit Linux and macOS, a long is 64 bits, but on 64-bit Windows, a long is still 32 bits. This is a classic source of bugs when porting code between operating systems.

The following article explains this concept brilliantly.

The Solution: Verifying Sizes with the sizeof Operator

Since we cannot assume the size of a type, C provides an operator to ask the compiler directly: sizeof. This operator returns the size of a type or a variable in bytes. It is a compile-time operator, meaning the values are resolved when you build your program, not when you run it.

This next video provides a comprehensive tutorial on how to use sizeof.

Practical Verification

Let's put this knowledge into practice. The following program uses sizeof to print the memory footprint of all the integer types on your system.

#include <stdio.h>

int main(void) {
    printf("--- Integer Type Sizes on This System ---\n");
    
    printf("Size of char: \t\t%zu byte(s)\n", sizeof(char));
    printf("Size of short: \t\t%zu byte(s)\n", sizeof(short));
    printf("Size of int: \t\t%zu byte(s)\n", sizeof(int));
    printf("Size of long: \t\t%zu byte(s)\n", sizeof(long));
    printf("Size of long long: \t%zu byte(s)\n", sizeof(long long));
    printf("Size of a pointer: \t%zu byte(s)\n", sizeof(void*));

    printf("\n--- Unsigned Variants ---\n");
    printf("Size of unsigned char: \t\t%zu byte(s)\n", sizeof(unsigned char));
    printf("Size of unsigned short: \t%zu byte(s)\n", sizeof(unsigned short));
    printf("Size of unsigned int: \t\t%zu byte(s)\n", sizeof(unsigned int));
    printf("Size of unsigned long: \t\t%zu byte(s)\n", sizeof(unsigned long));
    printf("Size of unsigned long long: \t%zu byte(s)\n", sizeof(unsigned long long));

    return 0;
}

Your Task:

1. Save the code above into a file named sizes.c.
2. Compile and run it on your machine: gcc -Wall -Wextra -Werror -o sizes sizes.c followed by ./sizes.
3. Observe the output. Based on the data models table, can you identify which model your system uses? (If you are on a modern 64-bit Mac or Linux machine, you will likely see long as 8 bytes, indicating LP64. If you are on 64-bit Windows, you will likely see long as 4 bytes, indicating LLP64).
4. Bonus Challenge: If you are on Linux or macOS, re-compile the program for a 32-bit architecture using the -m32 flag: gcc -m32 -o sizes32 sizes.c. Run ./sizes32 and compare the output. You should see the sizes change to match the ILP32 data model.

This simple exercise provides definitive proof that type sizes are not universal and demonstrates your power to verify them for any platform you target. The image below summarizes the typical sizes and ranges you'll find on common 32-bit and 64-bit systems.

Conclusion

In this lesson, you've taken a significant step toward understanding how C handles data at a low level. You now know that C offers a variety of integer types to balance memory usage and value range, and that the unsigned modifier is a powerful tool for both documenting intent and expanding the positive range of a variable.

Most importantly, you've learned that you cannot make assumptions about type sizes. They are dictated by the target system's data model. The sizeof operator is your essential tool for writing portable code by allowing you to programmatically determine the exact memory footprint of any data type.

Key Takeaways:

• C's integer types (char, short, int, long, long long) provide a trade-off between memory use and the range of values they can store.
• The unsigned keyword restricts a type to non-negative values, doubling its maximum positive value.
• The exact size of integer types is not fixed by the C standard but is determined by the system's data model (e.g., ILP32, LP64, LLP64).
• The sizeof operator is a compile-time tool that returns the size of a type or variable in bytes, enabling you to write portable and memory-aware code.

Now that we understand that each integer type has a fixed, finite size on a given system, a crucial question arises: what happens if we try to store a number that is too large for its container? This phenomenon, called integer overflow, is the subject of our next lesson.