Understanding Memory Layout of Structs in C: Alignment Rules and Compiler Behavior

Core Rules of Struct Memory Layout in C

In C, the memory layout of a struct follows explicit rules defined in the C99 standard (§6.7.2.1). Unlike high-level languages such as C#, C compilers do not reorder struct members by default, offering greater predictability for low-level programming. According to the standard, members are stored in the order declared, with addresses increasing sequentially. For example, consider this struct definition:

struct Example {
    char a;
    int b;
    char c;
};

Members a, b, and c will be placed in memory strictly in this order, without automatic compiler optimization for reordering as seen in some languages.

Alignment Requirements and Padding Byte Insertion

Although member order is fixed, compilers may insert padding bytes as needed to ensure each member meets its type's alignment requirements. Alignment is typically implementation-defined, but a common practice is to align primitive types to their size (e.g., int to 4 bytes, long long to 8 bytes). This can cause structs to occupy more memory than the sum of member sizes. For instance, on a 64-bit system, the struct:

struct ST {
    char ch1;
    short s;
    char ch2;
    long long ll;
    int i;
};

has a layout where ch1 is at offset 0, with 1 padding byte before s at offset 2 (aligned to 2 bytes), ch2 at offset 4, 3 padding bytes before ll at offset 8 (aligned to 8 bytes), i at offset 16, and 4 padding bytes at the end for a total size of 24 bytes (a multiple of 8). This padding ensures efficient memory access but may increase overhead.

Strategies for Optimizing Memory Layout

To reduce padding, developers can manually reorder members, placing those with larger alignment first. For example, restructuring the above as:

struct ST_optimized {
    long long ll; // offset 0
    int i;        // offset 8
    short s;      // offset 12
    char ch1;     // offset 14
    char ch2;     // offset 15
};

eliminates all internal padding, reducing total size to 16 bytes and improving memory efficiency. This optimization is crucial in resource-constrained systems like embedded environments.

Non-Standard Extensions and Implementation Dependence

While the C standard prohibits member reordering, it allows implementation-defined alignment details. Many compilers offer non-standard extensions like #pragma pack to control padding, e.g., forcing 1-byte alignment for hardware interfaces. However, these should be used cautiously as they can break portability and introduce undefined behavior. In practice, rely on standard behavior first and resort to compiler-specific features only when necessary.

Conclusion

C's struct memory layout is characterized by fixed member order and alignment-driven padding, providing low-level control without unpredictable reordering. By understanding these rules, developers can write more efficient and portable code, especially in system programming and performance-critical applications. Refer to the C99 standard for authoritative details and consult compiler documentation for implementation-specific issues.