Why Does Your C++ Object Use More Memory Than Expected? Uncover the Layout Secrets

Introduction: How are objects stored in memory?

Ever wondered how each C++ object you write is actually placed in memory? Understanding object memory layout is essential for writing efficient code, debugging memory issues, and optimizing performance.

What is memory layout?

Memory layout is the way a C++ object’s member variables are arranged in memory. Think of an object as a box that holds its member variables, and the compiler decides how to arrange them.

class MyClass {
public:
    char a;      // 1 byte
    double b;    // 8 bytes
    char c;      // 1 byte
};

a

– char, 1 byte b – double, 8 bytes c – char, 1 byte

Why care about memory layout?

Memory alignment : Compilers insert padding to satisfy alignment requirements, which can add hidden bytes.

Debugging : Knowing the layout helps you interpret memory dumps and debug issues.

Optimization : Reordering members can reduce wasted space and improve cache performance.

Member variables and layout (default 8‑byte alignment)

Layout analysis

a

(1 byte) starts at offset 0.

Padding after a to satisfy the 8‑byte alignment of double – 7 bytes. b (8 bytes) starts at offset 8. c (1 byte) starts at offset 16.

Padding at the end so the total size is a multiple of 8 – 7 bytes.

| a (1 byte) | padding (7 bytes) | b (8 bytes) | c (1 byte) | padding (7 bytes) |

Total size: 24 bytes

Using sizeof to check size

#include <iostream>
using namespace std;

class MyClass {
public:
    char a;      // 1 byte
    double b;    // 8 bytes
    char c;      // 1 byte
};

int main() {
    cout << "Size of MyClass: " << sizeof(MyClass) << " bytes" << endl;
    return 0;
}

Size of MyClass: 24 bytes

Effect of different alignment directives

Using #pragma pack you can force a different alignment.

#include <iostream>
using namespace std;

#pragma pack(4)  // 4‑byte alignment
class MyClass4 {
public:
    char a;      // 1 byte
    double b;    // 8 bytes
    char c;      // 1 byte
};

#pragma pack(8)  // 8‑byte alignment
class MyClass8 {
public:
    char a;      // 1 byte
    double b;    // 8 bytes
    char c;      // 1 byte
};

int main() {
    cout << "Size of MyClass4 (4-byte alignment): " << sizeof(MyClass4) << " bytes" << endl;
    cout << "Size of MyClass8 (8-byte alignment): " << sizeof(MyClass8) << " bytes" << endl;
    return 0;
}

Size of MyClass4 (4-byte alignment): 16 bytes
Size of MyClass8 (8-byte alignment): 24 bytes

Impact of member order

The compiler respects the declaration order; changing it can change padding.

class MyClass1 {
public:
    char a;      // 1 byte
    double b;    // 8 bytes
    char c;      // 1 byte
};

class MyClass2 {
public:
    char a;      // 1 byte
    char c;      // 1 byte
    double b;    // 8 bytes
};

MyClass1 layout

a

at offset 0 (1 byte).

Padding (7 bytes) to align b. b at offset 8 (8 bytes). c at offset 16 (1 byte).

Padding (7 bytes) at the end.

| a (1 byte) | padding (7 bytes) | b (8 bytes) | c (1 byte) | padding (7 bytes) |

Total size: 24 bytes

MyClass2 layout

a

at offset 0 (1 byte). c at offset 1 (1 byte).

Padding (6 bytes) to align b. b at offset 8 (8 bytes).

| a (1 byte) | c (1 byte) | padding (6 bytes) | b (8 bytes) |

Total size: 16 bytes

Size of MyClass1: 24 bytes
Size of MyClass2: 16 bytes

When to bother optimizing member order?

Optimizing layout is valuable in scenarios such as:

Creating thousands or millions of objects (e.g., particle systems in games, large server‑side data structures).

Embedded or memory‑constrained environments where every byte counts.

Performance‑critical code where tighter layouts improve cache utilization.

Guidelines

Do not sacrifice readability for minor memory savings in small projects. For large‑scale or performance‑sensitive code, group small types together and place larger aligned types after them to minimize padding.

Note : The tests were performed on Visual Studio 2022 with the default 8‑byte alignment; results may differ on other compilers or platforms.

Conclusion

Understanding C++ object memory layout helps you write faster, smaller programs. Use sizeof and debugging tools to verify the actual size, and reorder members wisely when the situation demands it.