Alignment

Every type has an alignment requirement — the address it lives at must be a multiple of its size. A short (2 bytes) must be at an even address; an int (4 bytes) must be at an address divisible by 4, etc.

Word Sizes

"32-bit" and "64-bit" refer to the register size, which determines pointer size and how much RAM is addressable (32-bit registers can only reference ~3.5 GB RAM).

1 GB = 1000 MB, 1 MB = 1000 KB, 1 KB = 1000 B

When the compiler lays out a struct in memory, it inserts invisible padding bytes between members to ensure each member is properly aligned. This can make a struct larger than the sum of its members.

// As written — appears to be 8 bytes
struct MixedData {
    char  Data1;   // 1 byte
    short Data2;   // 2 bytes
    int   Data3;   // 4 bytes
    char  Data4;   // 1 byte
};

// After compilation on a 32-bit machine — actually 12 bytes!
struct MixedData {
    char  Data1;        // 1 byte
    char  Padding1[1];  // 1 byte padding so Data2 is 2-byte aligned
    short Data2;        // 2 bytes
    int   Data3;        // 4 bytes
    char  Data4;        // 1 byte
    char  Padding2[3];  // 3 bytes tail padding so struct size is multiple of 4
};

Declaring members in decreasing size order eliminates all internal padding because each member is already naturally aligned by the time it's placed:

struct MixedData {
    char  Data1;
    short Data2;
    int   Data3;
    char  Data4;
};

struct MixedData {
    int   Data3;  // largest
    short Data2;  // medium
    char  Data1;  // small
    char  Data4;  // small
};

To force the compiler to use 1-byte alignment (no padding at all), wrap the struct in #pragma pack directives:

#pragma pack(push, 1)
struct PackedData {
    char  a;
    int   b;
    short c;
};
#pragma pack(pop)

An empty class or struct has a size of at least 1 byte — never 0.

class Empty {};
sizeof(Empty);  // 1 (not 0)

This is required so that every object has a unique address — two distinct Empty objects must not share the same address, which a size of 0 would make impossible.

A real-world example of why alignment and cache behavior matters in game development: