C++ 对象内存布局解析
面试考点
对象内存布局是面试中用来考察你对 C++ 底层理解的经典题目。面试官通常会问:一个类的对象占多少字节?成员变量怎么排列?有虚函数的类和没有虚函数的类有什么区别?多重继承时布局怎样?
核心概念
C++ 对象在内存中是一块连续的字节,由以下部分组成:
- 非静态数据成员(按声明顺序排列)
- 内存对齐产生的 padding
- vptr(虚函数指针,如果类有虚函数)
- 基类子对象(如果有继承)
对象布局由编译器和 ABI 决定,标准没有规定具体实现,但 Itanium ABI(GCC/Clang)和 MSVC ABI 是最常见的两种。
基本示例
#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 + char | 12 | 有 padding |
| int + char + char | 8 | 减少 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 的影响。