Memory Alignment & Padding

01Introduction

Have you ever noticed that the size of a struct is sometimes larger than the sum of its members? This is because of memory alignment and padding. Understanding these concepts is crucial for writing memory-efficient code, especially in embedded systems and performance-critical applications.

padding_surprise.c

1#include <stdio.h>
2
3struct Example {
4    char a;    // 1 byte
5    int b;     // 4 bytes
6    char c;    // 1 byte
7};             // Total: 6 bytes... right?
8
9int main() {
10    printf("Size of struct: %zu bytes\n", sizeof(struct Example));
11    // Output: Size of struct: 12 bytes  ← Why not 6?
12    return 0;
13}

What You'll Learn

• Why compilers add padding to structures
• How to calculate structure size with padding
• Techniques to minimize padding
• When and how to use packed structures

02Why Alignment Matters

CPUs are designed to access memory most efficiently when data is aligned to certain boundaries. For example, a 4-byte int is most efficiently accessed when its memory address is divisible by 4.

Aligned Access (Fast)

Address 0x1000: [int value]
→ Single memory read

Unaligned Access (Slow/Error)

Address 0x1001: [int value]
→ Two reads + combine OR crash!

Alignment Requirements by Type

Type	Size (typical)	Alignment	Valid Addresses
`char`	1 byte	1 byte	Any address
`short`	2 bytes	2 bytes	0, 2, 4, 6, 8...
`int`	4 bytes	4 bytes	0, 4, 8, 12, 16...
`long`	8 bytes	8 bytes	0, 8, 16, 24...
`double`	8 bytes	8 bytes	0, 8, 16, 24...
`pointer`	4/8 bytes	4/8 bytes	Depends on platform

03Structure Padding Explained

When you define a struct, the compiler automatically inserts padding bytesto ensure each member is properly aligned. Let's visualize this:

padding_visual.c

1struct Example {
2    char a;    // 1 byte at offset 0
3               // 3 bytes padding (to align int to 4-byte boundary)
4    int b;     // 4 bytes at offset 4
5    char c;    // 1 byte at offset 8
6               // 3 bytes padding (total size must be multiple of 4)
7};
8
9// Memory layout:
10// Offset:  0   1   2   3   4   5   6   7   8   9  10  11
11//        [ a |PAD|PAD|PAD| b | b | b | b | c |PAD|PAD|PAD]
12//
13// Total: 12 bytes (not 6!)

Two Types of Padding

Internal Padding: Between members to align them
Trailing Padding: At the end to make struct size a multiple of its largest alignment

04Calculating Structure Size

Use offsetof() to see where each member starts, and sizeof for total size:

offsetof_example.c

1#include <stdio.h>
2#include <stddef.h>  // For offsetof
3
4struct Example {
5    char a;
6    int b;
7    char c;
8};
9
10struct Better {
11    int b;     // Largest first
12    char a;
13    char c;
14};            // Members grouped to reduce padding
15
16int main() {
17    printf("=== struct Example ===\n");
18    printf("sizeof: %zu\n", sizeof(struct Example));
19    printf("offsetof(a): %zu\n", offsetof(struct Example, a));
20    printf("offsetof(b): %zu\n", offsetof(struct Example, b));
21    printf("offsetof(c): %zu\n", offsetof(struct Example, c));
22    
23    printf("\n=== struct Better ===\n");
24    printf("sizeof: %zu\n", sizeof(struct Better));
25    printf("offsetof(b): %zu\n", offsetof(struct Better, b));
26    printf("offsetof(a): %zu\n", offsetof(struct Better, a));
27    printf("offsetof(c): %zu\n", offsetof(struct Better, c));
28    
29    return 0;
30}

Expected Output:

=== struct Example ===
sizeof: 12
offsetof(a): 0
offsetof(b): 4
offsetof(c): 8

=== struct Better ===
sizeof: 8
offsetof(b): 0
offsetof(a): 4
offsetof(c): 5

Memory Savings!

By reordering members (largest to smallest), we reduced the struct from 12 bytes to 8 bytes — a 33% reduction! Imagine the savings with millions of instances.

05Optimizing Structure Layout

The golden rule for minimizing padding: order members from largest to smallest.

layout_optimization.c

1// BAD: Mixed sizes = lots of padding
2struct BadLayout {
3    char a;      // 1 byte + 7 padding
4    double b;    // 8 bytes
5    char c;      // 1 byte + 3 padding
6    int d;       // 4 bytes
7    char e;      // 1 byte + 7 padding
8};               // Total: 32 bytes (only 15 used!)
9
10// GOOD: Largest to smallest = minimal padding
11struct GoodLayout {
12    double b;    // 8 bytes
13    int d;       // 4 bytes
14    char a;      // 1 byte
15    char c;      // 1 byte
16    char e;      // 1 byte + 1 padding
17};               // Total: 16 bytes (15 used, 1 padding)
18
19// 50% memory savings!

Optimization Rules

1. Sort by size: double/pointer → long → int → short → char
2. Group same-sized members together
3. Put arrays at the end when possible
4. Consider cache line alignment for performance-critical structs (64 bytes)

06Packed Structures

When you need to eliminate ALL padding (for binary protocols, file formats, or hardware registers), you can use compiler-specific attributes to create packed structures:

packed_struct.c

1#include <stdio.h>
2
3// Regular struct with padding
4struct Normal {
5    char a;
6    int b;
7    char c;
8};  // 12 bytes
9
10// Packed struct - NO padding (GCC/Clang)
11struct __attribute__((packed)) Packed {
12    char a;
13    int b;
14    char c;
15};  // 6 bytes
16
17// Alternative: #pragma pack (works on MSVC, GCC, Clang)
18#pragma pack(push, 1)  // Set alignment to 1 byte
19struct PackedPragma {
20    char a;
21    int b;
22    char c;
23};  // 6 bytes
24#pragma pack(pop)      // Restore previous alignment
25
26int main() {
27    printf("Normal: %zu bytes\n", sizeof(struct Normal));
28    printf("Packed: %zu bytes\n", sizeof(struct Packed));
29    printf("PackedPragma: %zu bytes\n", sizeof(struct PackedPragma));
30    return 0;
31}

Packed Structure Warnings

• Performance penalty — Unaligned access is slower
• Some CPUs crash — ARM in particular may fault on unaligned access
• Not portable — Syntax varies by compiler
• No pointer casting — Taking address of packed member is dangerous

07C11: alignof and alignas

C11 introduced standard ways to query and control alignment:

c11_alignment.c

1#include <stdio.h>
2#include <stdalign.h>  // For alignof and alignas
3
4int main() {
5    // alignof: Query alignment requirement
6    printf("Alignment of char: %zu\n", alignof(char));    // 1
7    printf("Alignment of int: %zu\n", alignof(int));      // 4
8    printf("Alignment of double: %zu\n", alignof(double));// 8
9    
10    // alignas: Force specific alignment
11    alignas(16) int aligned_array[4];  // 16-byte aligned
12    alignas(64) char cache_line[64];   // Cache-line aligned
13    
14    printf("\nAddress of aligned_array: %p\n", (void*)aligned_array);
15    printf("Address of cache_line: %p\n", (void*)cache_line);
16    
17    return 0;
18}
19
20// Struct with custom alignment
21struct alignas(32) AlignedStruct {
22    int a;
23    double b;
24};  // Will be 32-byte aligned (and padded to 32 bytes)

When to Use alignas

• SIMD operations — SSE/AVX require 16/32-byte alignment
• Cache optimization — Align to 64-byte cache lines
• Memory-mapped hardware — Match hardware requirements
• DMA buffers — Often need specific alignment

08Real-World Example: Network Packet

Packed structures are essential for network protocols where byte order and layout must match exactly:

ip_header.c

1#include <stdio.h>
2#include <stdint.h>
3#include <arpa/inet.h>  // For htons, htonl
4
5// IP Header (simplified) - must be exactly 20 bytes
6struct __attribute__((packed)) IPHeader {
7    uint8_t  version_ihl;     // Version (4 bits) + IHL (4 bits)
8    uint8_t  tos;             // Type of Service
9    uint16_t total_length;    // Total Length
10    uint16_t identification;  // Identification
11    uint16_t flags_fragment;  // Flags (3 bits) + Fragment Offset (13 bits)
12    uint8_t  ttl;             // Time to Live
13    uint8_t  protocol;        // Protocol
14    uint16_t checksum;        // Header Checksum
15    uint32_t src_addr;        // Source Address
16    uint32_t dst_addr;        // Destination Address
17};
18
19_Static_assert(sizeof(struct IPHeader) == 20, "IP Header must be 20 bytes");
20
21void print_ip_header(struct IPHeader *hdr) {
22    printf("Version: %d\n", (hdr->version_ihl >> 4) & 0x0F);
23    printf("TTL: %d\n", hdr->ttl);
24    printf("Protocol: %d\n", hdr->protocol);
25    
26    // Convert network byte order to host byte order
27    uint32_t src = ntohl(hdr->src_addr);
28    printf("Source IP: %d.%d.%d.%d\n",
29           (src >> 24) & 0xFF, (src >> 16) & 0xFF,
30           (src >> 8) & 0xFF, src & 0xFF);
31}
32
33int main() {
34    printf("Size of IPHeader: %zu bytes\n", sizeof(struct IPHeader));
35    return 0;
36}

09Summary

Key Takeaways:

✓Alignment ensures data is at addresses divisible by its size
✓Padding is added by compilers to maintain alignment
✓Order struct members largest to smallest to minimize padding
✓Use offsetof() to inspect member positions
✓Use packed structures only when necessary (protocols, hardware)
✓C11 provides alignof and alignas for portable alignment control

01Introduction

padding_surprise.c

1#include <stdio.h>
2
3struct Example {
4    char a;    // 1 byte
5    int b;     // 4 bytes
6    char c;    // 1 byte
7};             // Total: 6 bytes... right?
8
9int main() {
10    printf("Size of struct: %zu bytes\n", sizeof(struct Example));
11    // Output: Size of struct: 12 bytes  ← Why not 6?
12    return 0;
13}

What You'll Learn

• Why compilers add padding to structures
• How to calculate structure size with padding
• Techniques to minimize padding
• When and how to use packed structures

02Why Alignment Matters

CPUs are designed to access memory most efficiently when data is aligned to certain boundaries. For example, a 4-byte int is most efficiently accessed when its memory address is divisible by 4.

Aligned Access (Fast)

Address 0x1000: [int value]
→ Single memory read

Unaligned Access (Slow/Error)

Address 0x1001: [int value]
→ Two reads + combine OR crash!

Alignment Requirements by Type

Type	Size (typical)	Alignment	Valid Addresses
`char`	1 byte	1 byte	Any address
`short`	2 bytes	2 bytes	0, 2, 4, 6, 8...
`int`	4 bytes	4 bytes	0, 4, 8, 12, 16...
`long`	8 bytes	8 bytes	0, 8, 16, 24...
`double`	8 bytes	8 bytes	0, 8, 16, 24...
`pointer`	4/8 bytes	4/8 bytes	Depends on platform

03Structure Padding Explained

When you define a struct, the compiler automatically inserts padding bytesto ensure each member is properly aligned. Let's visualize this:

padding_visual.c

1struct Example {
2    char a;    // 1 byte at offset 0
3               // 3 bytes padding (to align int to 4-byte boundary)
4    int b;     // 4 bytes at offset 4
5    char c;    // 1 byte at offset 8
6               // 3 bytes padding (total size must be multiple of 4)
7};
8
9// Memory layout:
10// Offset:  0   1   2   3   4   5   6   7   8   9  10  11
11//        [ a |PAD|PAD|PAD| b | b | b | b | c |PAD|PAD|PAD]
12//
13// Total: 12 bytes (not 6!)

Two Types of Padding

Internal Padding: Between members to align them
Trailing Padding: At the end to make struct size a multiple of its largest alignment

04Calculating Structure Size

Use offsetof() to see where each member starts, and sizeof for total size:

offsetof_example.c

1#include <stdio.h>
2#include <stddef.h>  // For offsetof
3
4struct Example {
5    char a;
6    int b;
7    char c;
8};
9
10struct Better {
11    int b;     // Largest first
12    char a;
13    char c;
14};            // Members grouped to reduce padding
15
16int main() {
17    printf("=== struct Example ===\n");
18    printf("sizeof: %zu\n", sizeof(struct Example));
19    printf("offsetof(a): %zu\n", offsetof(struct Example, a));
20    printf("offsetof(b): %zu\n", offsetof(struct Example, b));
21    printf("offsetof(c): %zu\n", offsetof(struct Example, c));
22    
23    printf("\n=== struct Better ===\n");
24    printf("sizeof: %zu\n", sizeof(struct Better));
25    printf("offsetof(b): %zu\n", offsetof(struct Better, b));
26    printf("offsetof(a): %zu\n", offsetof(struct Better, a));
27    printf("offsetof(c): %zu\n", offsetof(struct Better, c));
28    
29    return 0;
30}

Expected Output:

=== struct Example ===
sizeof: 12
offsetof(a): 0
offsetof(b): 4
offsetof(c): 8

=== struct Better ===
sizeof: 8
offsetof(b): 0
offsetof(a): 4
offsetof(c): 5

Memory Savings!

By reordering members (largest to smallest), we reduced the struct from 12 bytes to 8 bytes — a 33% reduction! Imagine the savings with millions of instances.

05Optimizing Structure Layout

The golden rule for minimizing padding: order members from largest to smallest.

layout_optimization.c

1// BAD: Mixed sizes = lots of padding
2struct BadLayout {
3    char a;      // 1 byte + 7 padding
4    double b;    // 8 bytes
5    char c;      // 1 byte + 3 padding
6    int d;       // 4 bytes
7    char e;      // 1 byte + 7 padding
8};               // Total: 32 bytes (only 15 used!)
9
10// GOOD: Largest to smallest = minimal padding
11struct GoodLayout {
12    double b;    // 8 bytes
13    int d;       // 4 bytes
14    char a;      // 1 byte
15    char c;      // 1 byte
16    char e;      // 1 byte + 1 padding
17};               // Total: 16 bytes (15 used, 1 padding)
18
19// 50% memory savings!

Optimization Rules

1. Sort by size: double/pointer → long → int → short → char
2. Group same-sized members together
3. Put arrays at the end when possible
4. Consider cache line alignment for performance-critical structs (64 bytes)

06Packed Structures

When you need to eliminate ALL padding (for binary protocols, file formats, or hardware registers), you can use compiler-specific attributes to create packed structures:

packed_struct.c

1#include <stdio.h>
2
3// Regular struct with padding
4struct Normal {
5    char a;
6    int b;
7    char c;
8};  // 12 bytes
9
10// Packed struct - NO padding (GCC/Clang)
11struct __attribute__((packed)) Packed {
12    char a;
13    int b;
14    char c;
15};  // 6 bytes
16
17// Alternative: #pragma pack (works on MSVC, GCC, Clang)
18#pragma pack(push, 1)  // Set alignment to 1 byte
19struct PackedPragma {
20    char a;
21    int b;
22    char c;
23};  // 6 bytes
24#pragma pack(pop)      // Restore previous alignment
25
26int main() {
27    printf("Normal: %zu bytes\n", sizeof(struct Normal));
28    printf("Packed: %zu bytes\n", sizeof(struct Packed));
29    printf("PackedPragma: %zu bytes\n", sizeof(struct PackedPragma));
30    return 0;
31}

Packed Structure Warnings

• Performance penalty — Unaligned access is slower
• Some CPUs crash — ARM in particular may fault on unaligned access
• Not portable — Syntax varies by compiler
• No pointer casting — Taking address of packed member is dangerous

07C11: alignof and alignas

C11 introduced standard ways to query and control alignment:

c11_alignment.c

1#include <stdio.h>
2#include <stdalign.h>  // For alignof and alignas
3
4int main() {
5    // alignof: Query alignment requirement
6    printf("Alignment of char: %zu\n", alignof(char));    // 1
7    printf("Alignment of int: %zu\n", alignof(int));      // 4
8    printf("Alignment of double: %zu\n", alignof(double));// 8
9    
10    // alignas: Force specific alignment
11    alignas(16) int aligned_array[4];  // 16-byte aligned
12    alignas(64) char cache_line[64];   // Cache-line aligned
13    
14    printf("\nAddress of aligned_array: %p\n", (void*)aligned_array);
15    printf("Address of cache_line: %p\n", (void*)cache_line);
16    
17    return 0;
18}
19
20// Struct with custom alignment
21struct alignas(32) AlignedStruct {
22    int a;
23    double b;
24};  // Will be 32-byte aligned (and padded to 32 bytes)

When to Use alignas

• SIMD operations — SSE/AVX require 16/32-byte alignment
• Cache optimization — Align to 64-byte cache lines
• Memory-mapped hardware — Match hardware requirements
• DMA buffers — Often need specific alignment

08Real-World Example: Network Packet

Packed structures are essential for network protocols where byte order and layout must match exactly:

ip_header.c

1#include <stdio.h>
2#include <stdint.h>
3#include <arpa/inet.h>  // For htons, htonl
4
5// IP Header (simplified) - must be exactly 20 bytes
6struct __attribute__((packed)) IPHeader {
7    uint8_t  version_ihl;     // Version (4 bits) + IHL (4 bits)
8    uint8_t  tos;             // Type of Service
9    uint16_t total_length;    // Total Length
10    uint16_t identification;  // Identification
11    uint16_t flags_fragment;  // Flags (3 bits) + Fragment Offset (13 bits)
12    uint8_t  ttl;             // Time to Live
13    uint8_t  protocol;        // Protocol
14    uint16_t checksum;        // Header Checksum
15    uint32_t src_addr;        // Source Address
16    uint32_t dst_addr;        // Destination Address
17};
18
19_Static_assert(sizeof(struct IPHeader) == 20, "IP Header must be 20 bytes");
20
21void print_ip_header(struct IPHeader *hdr) {
22    printf("Version: %d\n", (hdr->version_ihl >> 4) & 0x0F);
23    printf("TTL: %d\n", hdr->ttl);
24    printf("Protocol: %d\n", hdr->protocol);
25    
26    // Convert network byte order to host byte order
27    uint32_t src = ntohl(hdr->src_addr);
28    printf("Source IP: %d.%d.%d.%d\n",
29           (src >> 24) & 0xFF, (src >> 16) & 0xFF,
30           (src >> 8) & 0xFF, src & 0xFF);
31}
32
33int main() {
34    printf("Size of IPHeader: %zu bytes\n", sizeof(struct IPHeader));
35    return 0;
36}

09Summary

Key Takeaways:

✓Alignment ensures data is at addresses divisible by its size
✓Padding is added by compilers to maintain alignment
✓Order struct members largest to smallest to minimize padding
✓Use offsetof() to inspect member positions
✓Use packed structures only when necessary (protocols, hardware)
✓C11 provides alignof and alignas for portable alignment control

What You Will Learn

01Introduction

What You'll Learn

02Why Alignment Matters

Aligned Access (Fast)

Unaligned Access (Slow/Error)

Alignment Requirements by Type

03Structure Padding Explained

Two Types of Padding

04Calculating Structure Size

Expected Output:

Memory Savings!

05Optimizing Structure Layout

Optimization Rules

06Packed Structures

Packed Structure Warnings

07C11: alignof and alignas

When to Use alignas

08Real-World Example: Network Packet

09Summary

Key Takeaways:

Test Your Knowledge

Related Tutorials

C Program Memory Layout

Endianness: Big-Endian vs Little-Endian

Structures in C

Have Feedback?

What You Will Learn

01Introduction

What You'll Learn

02Why Alignment Matters

Aligned Access (Fast)

Unaligned Access (Slow/Error)

Alignment Requirements by Type

03Structure Padding Explained

Two Types of Padding

04Calculating Structure Size

Expected Output:

Memory Savings!

05Optimizing Structure Layout

Optimization Rules

06Packed Structures

Packed Structure Warnings

07C11: alignof and alignas

When to Use alignas

08Real-World Example: Network Packet

09Summary

Key Takeaways:

Test Your Knowledge

Related Tutorials

C Program Memory Layout

Endianness: Big-Endian vs Little-Endian

Structures in C

Have Feedback?