Structure Padding in C

Structure padding in C is the process of adding extra memory bytes between the members of a structure to align the data in memory for optimized access by the CPU. The padding is compiler-dependent and helps maintain data alignment according to the machine's architecture.

Why Structure Padding?

• To optimize CPU performance by ensuring data alignment.
• To avoid misaligned memory access, which can slow down program execution.
• To adhere to the system's memory alignment requirements.

Example: Without Padding

This example demonstrates a structure without padding:

                        
#include <stdio.h>

#pragma pack(1) // Disable padding
struct NoPadding {
    char c;    // 1 byte
    int i;     // 4 bytes
};
        
int main() 
{
    struct NoPadding np;
    printf("Size of structure without padding: %zu bytes\n", sizeof(np));
        
    return 0;
}
                        
                    

Example: With Padding

By default, the compiler adds padding to align data members:

                        
#include <stdio.h>
        
struct WithPadding {
    char c;    // 1 byte
    int i;     // 4 bytes, starts at the 4th byte due to padding
};
        
int main()
{
    struct WithPadding wp;
    printf("Size of structure with padding: %zu bytes\n", sizeof(wp));
    return 0;
}
                        
                    

Explanation

• In the second example, the int member starts at a memory address aligned to a 4-byte boundary, so 3 bytes of padding are added after the char member.
• The total size of the structure becomes a multiple of 4 (the size of an int).

Using #pragma pack()

You can use the #pragma pack directive to control padding:

                        
#include <stdio.h>
        
#pragma pack(1) // Disable padding
struct CustomPacking {
    char c;    // 1 byte
    int i;     // 4 bytes
};
        
int main() 
{
    struct CustomPacking cp;
    printf("Size of structure with custom packing: %zu bytes\n", sizeof(cp));
    return 0;
}
                        
                    

Key Points

• Structure padding is compiler-dependent, and different compilers may produce different sizes for the same structure.
• Padding improves CPU efficiency by aligning data to memory boundaries.
• Use #pragma pack to control or disable padding when memory usage is critical.
• Be cautious while disabling padding, as it may affect performance.