C++ 对象内存布局解析 ​

面试考点 ​

对象内存布局是面试中用来考察你对 C++ 底层理解的经典题目。面试官通常会问:一个类的对象占多少字节?成员变量怎么排列?有虚函数的类和没有虚函数的类有什么区别?多重继承时布局怎样?

核心概念 ​

C++ 对象在内存中是一块连续的字节,由以下部分组成:

  • 非静态数据成员(按声明顺序排列)
  • 内存对齐产生的 padding
  • vptr(虚函数指针,如果类有虚函数)
  • 基类子对象(如果有继承)

对象布局由编译器和 ABI 决定,标准没有规定具体实现,但 Itanium ABI(GCC/Clang)和 MSVC ABI 是最常见的两种。

基本示例 ​

cpp
#include <iostream>
#include <cstddef>

// ============================
// 示例1:简单类的布局
// ============================

class Simple {
    char a;    // 1 字节
    int b;     // 4 字节
    char c;    // 1 字节
};
// 布局(64 位,4 字节对齐):
// 偏移 0: char a     (1 字节)
// 偏移 1-3: padding   (3 字节,对齐 int)
// 偏移 4-7: int b     (4 字节)
// 偏移 8: char c      (1 字节)
// 偏移 9-11: padding   (3 字节,总大小需要是最大对齐的倍数)
// sizeof(Simple) = 12

// 优化:调整成员顺序减少 padding
class SimpleOptimized {
    int b;     // 4 字节
    char a;    // 1 字节
    char c;    // 1 字节
};
// 布局:
// 偏移 0-3: int b     (4 字节)
// 偏移 4: char a      (1 字节)
// 偏移 5: char c      (1 字节)
// 偏移 6-7: padding    (2 字节)
// sizeof(SimpleOptimized) = 8

// ============================
// 示例2:空类的大小
// ============================

class Empty {};
// sizeof(Empty) = 1
// 空类大小为 1 字节,确保不同对象有不同地址

class EmptyDerived : public Empty {
    int x;
};
// sizeof(EmptyDerived) = 4
// 空基类优化(EBO):空基类不占空间

// ============================
// 示例3:有虚函数的类
// ============================

class WithVirtual {
    int x;                     // 4 字节
    virtual void func() {}     // 引入 vptr
};
// 64 位系统布局:
// 偏移 0-7: vptr       (8 字节,指向虚函数表)
// 偏移 8-11: int x     (4 字节)
// 偏移 12-15: padding   (4 字节,对齐到 8)
// sizeof(WithVirtual) = 16

class WithoutVirtual {
    int x;
    void func() {}  // 非虚函数不影响布局
};
// sizeof(WithoutVirtual) = 4

// ============================
// 示例4:单继承布局
// ============================

class Base {
public:
    int base_x;
    virtual void func() {}
};
// sizeof(Base) = 16(vptr 8 + int 4 + padding 4)

class Derived : public Base {
public:
    int derived_y;
};
// 布局:
// 偏移 0-7: vptr(指向 Derived 的 vtable)
// 偏移 8-11: int base_x(继承自 Base)
// 偏移 12-15: int derived_y(Derived 自己的成员)
// sizeof(Derived) = 16(刚好没有额外 padding)

// ============================
// 示例5:多重继承布局
// ============================

class A {
public:
    int a;
    virtual void funcA() {}
};
// sizeof(A) = 16

class B {
public:
    int b;
    virtual void funcB() {}
};
// sizeof(B) = 16

class C : public A, public B {
public:
    int c;
};
// 布局(64 位 Itanium ABI):
// 偏移 0-7:   vptrA(A 子对象的 vptr)
// 偏移 8-11:  int a(A 的成员)
// 偏移 12-15: padding
// 偏移 16-23: vptrB(B 子对象的 vptr)
// 偏移 24-27: int b(B 的成员)
// 偏移 28-31: int c(C 自己的成员)
// sizeof(C) = 32(两个 vptr)

// ============================
// 示例6:虚继承布局
// ============================

class VBase {
public:
    int v;
    virtual void funcV() {}
};

class VDerived1 : virtual public VBase {
public:
    int d1;
};

class VDerived2 : virtual public VBase {
public:
    int d2;
};

class Diamond : public VDerived1, public VDerived2 {
public:
    int diamond;
};
// 虚继承确保只有一份 VBase 子对象
// 但引入额外的虚基类指针或偏移量,使布局更复杂

// ============================
// 示例7:查看布局的工具代码
// ============================

// 用 offsetof 和 sizeof 查看布局
void print_layout() {
    std::cout << "=== 简单类 ===" << std::endl;
    std::cout << "sizeof(Simple) = " << sizeof(Simple) << std::endl;
    std::cout << "sizeof(SimpleOptimized) = " << sizeof(SimpleOptimized) << std::endl;

    std::cout << "\n=== 空类 ===" << std::endl;
    std::cout << "sizeof(Empty) = " << sizeof(Empty) << std::endl;
    std::cout << "sizeof(EmptyDerived) = " << sizeof(EmptyDerived) << std::endl;

    std::cout << "\n=== 虚函数 ===" << std::endl;
    std::cout << "sizeof(WithVirtual) = " << sizeof(WithVirtual) << std::endl;
    std::cout << "sizeof(WithoutVirtual) = " << sizeof(WithoutVirtual) << std::endl;

    std::cout << "\n=== 继承 ===" << std::endl;
    std::cout << "sizeof(Base) = " << sizeof(Base) << std::endl;
    std::cout << "sizeof(Derived) = " << sizeof(Derived) << std::endl;

    std::cout << "\n=== 多重继承 ===" << std::endl;
    std::cout << "sizeof(A) = " << sizeof(A) << std::endl;
    std::cout << "sizeof(B) = " << sizeof(B) << std::endl;
    std::cout << "sizeof(C) = " << sizeof(C) << std::endl;

    std::cout << "\n=== 虚继承 ===" << std::endl;
    std::cout << "sizeof(VBase) = " << sizeof(VBase) << std::endl;
    std::cout << "sizeof(VDerived1) = " << sizeof(VDerived1) << std::endl;
    std::cout << "sizeof(Diamond) = " << sizeof(Diamond) << std::endl;
}

int main() {
    print_layout();

    // 验证 this 指针在多重继承中的变化
    C obj;
    A* pa = &obj;
    B* pb = &obj;

    std::cout << "\n=== this 指针调整 ===" << std::endl;
    std::cout << "&obj = " << &obj << std::endl;
    std::cout << "pa   = " << pa << std::endl;   // 和 &obj 相同
    std::cout << "pb   = " << pb << std::endl;   // 偏移了,指向 B 子对象

    return 0;
}

各种场景的对象大小(64 位系统) ​

类的特征sizeof说明
空类1保证不同对象有不同地址
只有 int 成员4没有 padding
char + int + char12有 padding
int + char + char8减少 padding
有 1 个虚函数8 + 成员vptr 占 8 字节
单继承(有虚函数)基类大小 + 派生类成员共享 vptr
多重继承(两个有虚函数的基类)基类1 + 基类2 + 自身成员多个 vptr
虚继承更大额外的虚基类偏移信息

常见问题 ​

vptr 在对象中的位置是什么?

标准没有规定。Itanium ABI(GCC/Clang)把 vptr 放在对象最开头(偏移 0)。MSVC 也通常放在开头。这不是语言标准保证的,不同编译器可能不同。

多重继承为什么有多个 vptr?

每个有虚函数的基类子对象都需要自己的 vptr。当通过基类指针调用虚函数时,需要通过该基类的 vptr 找到正确的虚函数。所以继承了两个有虚函数的基类就有两个 vptr。

static 成员变量影响对象大小吗?

不影响。static 成员变量存储在全局/静态数据区,不属于任何对象。成员函数(包括虚函数之外的普通成员函数)也不占对象空间。

空基类优化(EBO)是什么?

如果基类是空类(没有非静态数据成员、没有虚函数),编译器可以不为它分配空间。这样 struct D : Empty { int x; } 的 sizeof 是 4 而不是 8。

适用场景 ​

  • 分析程序内存占用
  • 优化数据结构的 cache 友好性
  • 跨编译器或跨平台的二进制兼容性
  • 序列化和网络传输时的数据对齐

注意事项 ​

  • 对象布局是编译器和 ABI 决定的,标准不保证
  • 不要用 reinterpret_cast 强行访问对象内部布局
  • 调整成员声明顺序可以减少 padding
  • 虚函数引入 vptr(通常 8 字节开销)
  • 多重继承会有多个 vptr

总结 ​

C++ 对象在内存中由成员变量、padding 和 vptr 组成。成员按声明顺序排列,编译器会插入 padding 保证对齐。有虚函数的类会多一个 vptr(通常 8 字节)。单继承共享 vptr,多重继承每个有虚函数的基类有自己的 vptr。虚继承引入额外开销来存放虚基类偏移。面试中要能画出对象的内存布局图,计算 sizeof,解释 padding 和 vptr 的影响。