Chapter 1: C++ Object Model
核心问题与阅读主线
STL 容器在底层持续调度原始存储与类型化对象的转换:std::vector<T> 扩容、std::list<T> 节点分配、allocator 的 construct / destroy 与 iterator 失效规则,全部取决于某段存储何时成为有效 T 对象、何时失去对象身份。厘清存储期、生命周期、对齐与布局约束,才能读懂容器在正常路径与异常回滚下的设计边界。
全章共用代码样本(下文各节持续拆解)
本章以一段贯穿材料串起对象模型,对应 STL 容器的核心底层动作:申请足够大且对齐的原始存储 → 构造对象 → 按类型访问状态 → 销毁对象并复用或释放存储。
#include <cstddef>
#include <memory>
#include <new>
#include <type_traits>
struct Item {
int key;
double score;
Item(int k, double s) : key(k), score(s) {}
void add(double delta) {
score += delta;
}
};
alignas(Item) std::byte raw[sizeof(Item)];
Item* make_item() {
return std::construct_at(reinterpret_cast<Item*>(raw), 7, 3.5);
}
void drop_item(Item* p) {
std::destroy_at(p);
}
这段代码的关键在于 raw 与 Item 的边界:raw 起初只是原始字节存储,std::construct_at 后成为有效的 Item 对象,std::destroy_at 后 Item 生命周期结束而 raw 存储依然存在。
标准语义参考 cppreference 的 Object 页面、Object lifetime 页面 和 Storage duration 页面。
1.1 对象身份、存储期与有效对象
C++ 对象由存储、类型、生命周期、值状态和可观察地址共同确定:地址提供定位,类型决定解释规则,生命周期划定对象身份(此刻存储中活着的那个对象)的起止边界。同一地址在不同时刻可承载不同对象。
Item* p = make_item();
p->add(1.0); // 访问活着的 Item 对象
drop_item(p); // Item 生命周期结束
贯穿材料中的调用包含两个层级,STL 容器同样按这两层管理内存:
- 外层存储(
raw数组对象):生命周期由定义位置决定,仅提供大小与对齐合格的字节区间。 - 内层元素(
Item对象):生命周期由std::construct_at启动、std::destroy_at结束;未构造槽位即使存储就绪,也不存在Item对象。
区分“物理存储存在”与“对象有效”依赖两个标准概念:
- 存储期(storage duration):决定物理存储至少存在多久,包括自动、静态、线程与动态四种存储期。
- 生命周期(lifetime):决定对象从创建完成到销毁开始(或存储被复用)之间,允许按
T访问的合法运行时区间。
边界与误区
仅 AliveItem 允许按 Item 读取 key 或调用 add;RawStorage 仅支持保存地址、计算容量与复用存储;进入 Released 后连存储承载关系也终止,旧指针立即失去定位语义。
这条边界直接解释了 std::vector<T> 为何区分 size 与 capacity:
| 地址区间 | 对应容器属性 | 存储与对象状态 | 允许操作 |
|---|---|---|---|
[begin(), end()) | size 范围内 | 存储已分配,元素已构造 | 正常读写元素与调用成员函数 |
[end(), begin() + capacity()) | size 到 capacity 之间 | 仅原始存储,元素未构造 | 仅用于就地构造新元素 |
capacity() 之外 | 超出已分配容量 | 无容器可用存储 | 禁止解引用或构造成员 |
指针与 iterator 有效必须同时满足三个条件:地址归属容器、对象生命周期有效、类型解释匹配,以下任一动作都会破坏其中之一:
vector扩容:释放旧存储,旧地址失去存储承载关系。erase销毁元素:槽位退回未构造存储,目标生命周期结束。- placement new 原地重建:旧对象身份终止,新对象身份重新建立。
1.2 对齐、padding 与 sizeof
对象布局由大小、对齐与成员排列共同决定:sizeof(T) 给出完整 T 对象字节数,alignof(T) 给出起始地址对齐要求,padding 是编译器为满足对齐而插入的填充字节。
实际大小与偏移取决于目标 ABI 与编译器实现,以下代码展示成员排列如何产生 padding:
#include <cstddef>
struct LayoutA {
char tag;
int value;
};
struct LayoutB {
int value;
char tag;
};
static_assert(sizeof(LayoutA) >= sizeof(char) + sizeof(int));
static_assert(sizeof(LayoutB) >= sizeof(char) + sizeof(int));
sizeof(T) 表达相邻对象之间的步长,而非成员大小的简单求和:
- 内部与尾部 padding:
LayoutA在tag后填充字节以对齐value;LayoutB在tag后插入尾部 padding,保证数组中下一元素对齐。 - 连续容器定位:
std::vector<LayoutA>按begin + i * sizeof(LayoutA)定位第i个元素,容器只需保证首地址满足alignof(LayoutA)。
边界与误区
alignas(Item) std::byte raw[sizeof(Item)] 缺一不可:sizeof(Item) 只解决字节容量,alignas(Item) 才保证起始地址对齐。省略 alignas(Item) 时 raw 仅满足 std::byte 对齐,在其上构造 Item 会破坏对齐前提;STL allocator 的 allocate 同样必须返回满足 alignof(T) 的地址。
阅读类布局源码时,还需区分完整对象、基类子对象与成员子对象的布局规则:
| 对象形态 | 地址唯一性要求 | 常见布局与大小特征 |
|---|---|---|
| 完整空类对象 | 相邻完整对象必须有可区分地址 | 非零大小(通常至少 1 字节) |
| 空基类子对象 | 允许与派生类其他子对象共用地址 | 常见实现启用 EBO(empty base optimization),不占额外字节 |
| 空成员子对象 | 默认独立占位;标注 [[no_unique_address]](C++20)后可共享 | 标注后可复用相邻成员空间或 padding |
padding 不承载业务值:可平凡复制(trivially copyable)类型按字节复制对象表示通常等价于复制值;持有资源的类型若按字节复制,则会绕过构造、拷贝/移动与析构语义。
核心判断
STL 连续存储必须守住三条底线:1. 分配器返回地址满足 alignof(T);2. 相邻元素步长使用 sizeof(T);3. 元素搬迁按类型语义调用构造、移动或拷贝,不能退化为纯字节拷贝。
1.3 栈对象、堆对象与所有权入口
工程中的“栈对象”和“堆对象”对应标准语义的自动存储期与动态存储期对象。下面对比局部自动对象、new 表达式与原始动态存储:
#include <cstdlib>
#include <new>
void local_object() {
Item local{1, 2.0}; // 自动存储期对象
local.add(0.5);
} // local 在作用域退出时销毁
Item* dynamic_object() {
return new Item{2, 4.0}; // 分配存储并构造 Item
}
void raw_dynamic_storage() {
void* mem = std::malloc(sizeof(Item));
Item* p = std::construct_at(static_cast<Item*>(mem), 3, 6.0);
std::destroy_at(p);
std::free(mem);
}
| 分配与构造模式 | 存储期与来源 | 生命周期起止 | 销毁与释放闭合方式 |
|---|---|---|---|
自动对象(local) | 自动存储期(块作用域) | 声明处构造,离开作用域逆序析构 | 编译器自动闭合 |
new / delete | 动态存储期 | new 先分配再构造,返回活对象指针 | delete 先析构再释放存储 |
std::malloc + construct_at | 动态原始存储 | malloc 仅取字节,construct_at 启动对象 | 须配对 std::destroy_at 与 std::free |
所有权入口是资源责任的起点:局部变量在声明处闭合,裸 new 在返回指针处转移责任,STL 容器则在取得存储并构造元素时建立责任,并在析构、clear、erase 与扩容失败回滚时反向闭合。
#include <vector>
void container_owns_elements() {
std::vector<Item> items;
items.emplace_back(10, 1.0);
items.emplace_back(20, 2.0);
} // vector 析构时销毁两个 Item,并释放内部存储
上例包含三层时间线:items 为自动存储期,其内部缓冲区为动态存储期,两个 Item 的生命周期由容器管理。不同元素类型决定了截然不同的资源责任链:
| 容器类型 | 容器直接拥有的对象 | 容器析构动作 | 底层资源释放责任 |
|---|---|---|---|
std::vector<Item> | Item 元素对象 | 逐个调用 ~Item() 并释放缓冲区 | Item 自身析构释放成员资源 |
std::vector<int*> | int* 指针值 | 指针析构为空操作,仅释放缓冲区 | 不释放所指 int,由外部约定 |
std::vector<std::unique_ptr<int>> | std::unique_ptr<int> | 调用 unique_ptr 析构并释放缓冲区 | 由 unique_ptr 释放堆上 int |
排查顺序
- 确认存储来源:定位缓冲区出自栈帧、全局区还是 allocator;
- 确认构造起点:定位
construct_at、placement new 或emplace; - 确认析构覆盖:核对析构、
clear、erase与异常路径是否销毁全部已构造元素; - 确认释放配对:核对释放函数是否匹配分配方式(如
free配malloc、allocatordeallocate配allocate)。
1.4 this 指针、成员函数与对象状态
非静态成员函数通过隐藏 this 指针操作具体实例:函数机器代码不存入单个对象,实例内仅保存非静态数据成员及多态元数据。调用 p->add(1.0) 时,p 作为 this 进入 Item::add 修改 score。
struct Counter {
int value;
void increment() {
++value;
}
int get() const {
return value;
}
};
void use_counter() {
Counter c{0};
c.increment();
int n = c.get();
(void)n;
}
成员函数与对象存储分离,容器搬迁元素时无需复制函数代码,搬迁后 this 直接绑定新地址。各类成员的存储与 this 语义如下:
| 类成员类别 | 是否计入 sizeof(T) | 是否接收 this | 访问与存储语义 |
|---|---|---|---|
| 非静态数据成员 | 是 | 不适用 | 随每个实例独立存储 |
| 非静态成员函数 | 否 | 是(T*) | 经 this 读写实例状态 |
const 非静态成员函数 | 否 | 是(const T*) | 限制修改权限,不改变对象布局 |
| 静态数据成员 | 否 | 不适用 | 类作用域独立存储对象 |
| 静态成员函数 | 否 | 否 | 不能直接访问实例非静态成员 |
边界与误区
this 的有效性完全绑定于对象生命周期。贯穿材料 drop_item(p) 后,p 虽保留原地址值,但目标 Item 已停止存在,继续调用 p->add(1.0) 即形成悬空 this 访问;STL iterator 失效的本质与此相同。
成员函数还负责维护类型不变量(如 size <= capacity、链表前后指针互指、哈希元素匹配桶位),容器与 value_type 因此形成明确分工:
- 容器负责:槽位分配、生命周期调度与异常回滚。
- 元素类型(
value_type)负责:构造后状态有效、移动后可析构、析构时释放内部资源。绕过成员函数按字节篡改对象会破坏不变量。
1.5 虚函数表与多态对象布局
含虚函数的类属于多态类型。为支持动态派发,常见实现模型在每个多态对象中放入隐藏指针(vptr)指向虚函数表(vtable),具体布局由 ABI 决定。
struct Plain {
int value;
void update() {
++value;
}
};
struct Poly {
int value;
virtual void update() {
++value;
}
virtual ~Poly() = default;
};
Plain(非多态):仅含value与 padding;非虚调用在编译期按静态类型绑定目标函数。Poly(多态):额外携带动态派发信息(sizeof(Poly)通常大于sizeof(int),is_polymorphic为真);Poly* p调用p->update()时按对象动态类型派发,构造和析构阶段同步更新动态类型信息。
#include <memory>
#include <vector>
struct Shape {
virtual double area() const = 0;
virtual ~Shape() = default;
};
struct Square : Shape {
double side;
explicit Square(double s) : side(s) {}
double area() const override {
return side * side;
}
};
void own_polymorphic_objects() {
std::vector<std::unique_ptr<Shape>> shapes;
shapes.push_back(std::make_unique<Square>(3.0));
}
上例中 shapes 拥有 std::unique_ptr<Shape>,智能指针再管理堆上的 Square;扩容仅移动指针本身,Square 留在原地址,shapes[0]->area() 经 Shape 接口动态派发至 Square::area。两种容器方案取舍如下:
| 存储方案 | 派生类多态支持 | 内存布局与访问 | 扩容与所有权 |
|---|---|---|---|
值容器(std::vector<Base>) | 不支持,派生对象写入会发生对象切片 | 元素连续紧排,缓存局部性好,步长为 sizeof(Base) | 容器直接管理值生命周期,无额外堆分配 |
指针容器(std::vector<std::unique_ptr<Base>>) | 支持不同大小与布局的派生对象 | 多一层指针间接访问,对象分散在堆上 | 扩容仅移动指针,销毁由智能指针与虚析构闭合 |
边界与误区
通过基类指针删除派生对象时,基类必须声明虚析构函数,否则 delete base_ptr 无法按动态类型析构派生部分。此外,基类构造期间派生部分尚未就绪,基类析构期间派生部分已经结束,这两阶段内的虚调用受当前基类阶段限制。
1.6 对象模型对 STL 实现的约束
STL 容器的核心动作都在“原始存储”与“有效对象”间切换:vector 扩容、deque 分配新块、list 插入节点、map 构造树节点均遵循同一流程——取对齐存储 → 构造元素 → 提交结构;失败则销毁已构造部分并释放未提交存储。
下面的 OneSlot<T> 演示单个槽位如何将原始存储与对象生命周期解耦:
#include <cstddef>
#include <memory>
#include <new>
#include <utility>
template <class T>
class OneSlot {
alignas(T) std::byte storage_[sizeof(T)];
bool engaged_ = false;
T* ptr() {
return std::launder(reinterpret_cast<T*>(storage_));
}
public:
template <class... Args>
void construct(Args&&... args) {
std::construct_at(ptr(), std::forward<Args>(args)...);
engaged_ = true;
}
void destroy() {
if (engaged_) {
std::destroy_at(ptr());
engaged_ = false;
}
}
T& get() {
return *ptr();
}
};
storage_ 与 alignas(T) 提供合格原始存储,engaged_ 追踪对象状态:construct 在 std::construct_at 成功后才置位 engaged_,destroy 也只析构已构造对象。真实容器将这一不变量扩展到连续数组、链表/树节点及 allocator traits 上:
| 容器形态 | 底层结构划分 | 插入与提交顺序 | 对象身份与 iterator 稳定性 |
|---|---|---|---|
连续容器(std::vector<T>) | 三指针划分 [begin, end)(活对象)与 [end, cap)(原始存储) | 扩容时在新存储移动/拷贝构造元素,再销毁旧元素并释放旧存储 | 扩容结束旧地址对象生命周期,iterator 全部失效 |
节点容器(std::list<T>、关联容器) | 独立节点含链接指针(前驱/后继或树/桶指针)与 T | 先分配节点,再构造 T,最后接入结构;构造抛异常仅释放节点 | 未删节点的 T 地址与生命周期稳定,对应 iterator 不失效 |
在此架构中,allocator 把内存来源从容器逻辑中解耦,提供满足 alignof(T) 的原始存储与构造/销毁路径,但不管理 size;容器也绝不能绕过类型构造语义直接修改未构造字节。
关键事实
异常安全严格依赖“已启动生命周期的对象计数”:若 vector 扩容搬迁 10 个元素时,新存储已构造 6 个、第 7 个抛出异常,容器必须精确销毁新存储中的那 6 个对象并释放新存储,同时保留旧存储中的原有元素。
排查顺序
- 判别槽位状态:区分指针指向原始存储、活对象还是已销毁的旧位置;
- 核对对齐前提:检查分配地址是否满足
alignof(T); - 追踪构造计数:核实异常前已启动生命周期的元素数量;
- 审计回滚路径:检查失败分支是否销毁已构造对象并配对释放未提交存储;
- 定位提交点:确认结构指针或
size仅在对象与不变量成立后更新; - 验证身份有效:确认 iterator、引用与指针仍绑定于未销毁、未迁移的活对象。
最小自检任务
阅读下面代码,判断每一行注释后的说法是否成立,并说明原因。重点关注存储、生命周期、对齐、对象身份和容器所有权。
#include <cstddef>
#include <memory>
#include <vector>
struct Item {
int key;
double score;
Item(int k, double s) : key(k), score(s) {}
void add(double delta) {
score += delta;
}
};
void check() {
alignas(Item) std::byte raw[sizeof(Item)];
Item* p = reinterpret_cast<Item*>(raw);
// A: 此时可以读取 p->key。
std::construct_at(p, 1, 2.0);
// B: 此时 raw 内部有一个有效 Item 对象。
p->add(3.0);
std::destroy_at(p);
// C: 此时 raw 仍然存在,但 Item 生命周期已经结束。
std::vector<Item> items;
items.emplace_back(7, 8.0);
// D: vector 拥有一个 Item 元素对象,并负责在合适时间销毁它。
}
本章知识点总结
- 对象身份
对象身份由地址、类型与生命周期共同确定,仅在生命周期区间内可按
T访问状态或调用成员函数。 - 存储期与生命周期
存储期决定物理空间存续,生命周期决定类型化访问边界;
capacity管理原始存储,size管理已构造对象。 - 对齐与步长
alignof(T)约束起始地址,sizeof(T)包含 padding 并作为连续容器步长;带资源类型不能绕过构造/析构做字节拷贝。 - 所有权闭合
外层容器存储期、内部缓冲区存储期与元素生命周期分层管理;分配、构造、析构与释放须沿所有权入口配对闭合。
- this 与不变量
成员函数代码不占对象空间,非静态成员函数经活对象的
this维护不变量;对象销毁后旧地址不可再绑定this。 - 多态对象布局
多态类型携带动态派发信息(如 vptr)有别于普通值类型;跨派生类存放对象通常用指针层配合虚析构闭合释放责任。
- STL 异常回滚与失效
容器按已构造计数回滚失败路径,结构提交点置于对象构造与不变量成立之后;iterator 稳定性取决于对象地址与生命周期是否保持。