C Structure Padding and Packing – Controlling Memory Alignment in C

Introduction – What Is Structure Padding and Packing?

In C programming, structure padding and packing control how data is aligned in memory when stored inside a struct. While padding adds extra bytes for alignment, packing removes them to minimize memory usage—at the possible cost of performance.

In this guide, you’ll learn:

• The difference between padding and packing
• How compilers align structure members
• How to use #pragma and __attribute__ to control packing
• Best practices for portability and performance

Core Concept – Why Does Padding Occur?

To improve CPU memory access speed, compilers align structure members according to their data type size (usually to boundaries of 2, 4, or 8 bytes). If needed, padding bytes are inserted between members to satisfy alignment requirements.

Example – Structure with Padding

struct Padded {
    char a;   // 1 byte
    int b;    // 4 bytes (starts after 3 bytes of padding)
};

Total size may be 8 bytes: 1 (char) + 3 (padding) + 4 (int)

Code Examples – Padded vs Packed

Example 1: Structure with Default Padding

#include <stdio.h>

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

int main() {
    printf("Size: %lu\n", sizeof(struct DefaultPadding));
    return 0;
}

May print: Size: 12 depending on platform alignment rules.

Example 2: Structure with Packing Enabled

#include <stdio.h>

#pragma pack(1)  // Disable padding
struct Packed {
    char a;
    int b;
    char c;
};
#pragma pack()

int main() {
    printf("Size: %lu\n", sizeof(struct Packed));
    return 0;
}

Will likely print: Size: 6 (1 + 4 + 1 bytes)

Tools and Directives for Packing

Padding vs Packing Summary

Best Practices & Tips

Best Practice:
Use default padding unless working with memory-sensitive or binary data protocols.

Tip:
Use sizeof() to verify actual size of packed and padded structures for consistency across systems.

Pitfall:
Packing can lead to misaligned memory access, which may crash or slow down performance on some CPUs.

Real-World Applications

• Network protocol headers (exact byte layout matters)
• File format structures (e.g., BMP, WAV, ELF headers)
• Embedded systems and microcontrollers (low memory footprint)
• Device drivers interfacing with hardware registers

Summary – Recap & Next Steps

Structure padding ensures alignment for better performance, while packing saves memory. Use each wisely based on the needs of your program—padding for speed, packing for size-critical scenarios.

Key Takeaways:

• Padding aligns structure members for optimal memory access
• Packing minimizes structure size by disabling alignment
• Use compiler-specific directives like #pragma pack and __attribute__
• Verify sizes using sizeof() and test on target hardware

Real-World Relevance:

Essential in firmware development, network programming, and binary file processing where byte-exact structure layouts are required.

Frequently Asked Questions (FAQ)

Why does structure padding happen?

To align data members for faster access on most CPUs, preventing misalignment issues.

How do I disable padding?

Use #pragma pack(1) or __attribute__((packed)) depending on your compiler.

Is structure packing safe to use?

Yes, but it may affect performance or cause misaligned access on strict architectures.

How can I check the size of a struct?

Use sizeof(structName) to get the number of bytes it occupies.

Can packing break my code on other systems?

Potentially. Always test packed structures for portability and alignment compatibility.