📑 本页目录(点开跳转)
02 · 值语义与所有权:谁负责释放
C++ / 02 · 值与寿命
谁持有资源,离开作用域时谁负责收尾?
先分清复制、借用和移动,再看 RAII 守卫如何把释放责任绑定在作用域上。
读完可沿原代码辨认释放责任,并在继续借用前核对被借对象的寿命。
RAII 示例:责任跟着守卫的作用域走
- 进入作用域,构造守卫并取得资源
- 在作用域内使用资源,守卫仍负责收尾
- 正常离开或按规则异常展开,守卫析构并释放
abort、terminate 等不按这条时间线保证局部析构;复制、借用及 Tensor 句柄语义仍以原代码、表和类型契约为准。实验记录怎么读
本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。
⏱ 90 分钟 | ⭐ Python 的 = 默认共享,C++ 的 = 默认复制 —— 两边的默认值正好反着
🎯 一句话
在 Python 里你从来不用回答「谁负责释放」,因为语言替你答了;到了 C++,这个问题必须由代码里的某个符号明确回答 —— 而源码里那些 const Tensor&、std::move、unique_ptr 就是答案本身。
读懂它们不需要会写 C++,只需要知道每一个符号在说「我拿走了」还是「我只是借来看看」。
🧩 一、同一个问题被切成了三块,这一章只管第三块
你在站内会撞见三个长得很像、其实完全不同的现象。它们分属三个板块,先把界划清楚,免得你在这一章找一个不在这一章的东西。
| 现象 | 一句话 | 归哪一章 |
|---|---|---|
| 名字绑到对象 | b = a 之后 a is b 为真,改 b 就是改 a |
《Python 会咬你的地方》01 |
| 缓冲区被共享 | y = x[:2] 之后是两个不同的对象,但它们指着同一块内存 |
《NumPy 与向量化思维》04 |
| ⭐ 谁负责释放 | 这块内存什么时候消失、由谁决定 | 这一章 |
前两块 Python 都替你处理了,所以你从来没被问过第三个问题。下面这段把前两块跑出来,好让你确认自己认得它们 —— 然后这一章就再也不碰它们了:
# c02_three.py
import sys
# ① Python 的 = :给同一个对象再挂一个名字
a = [1, 2, 3]
b = a
b.append(4)
print("① Python: a =", a, " b =", b, " 同一个对象吗:", a is b, " id 相同吗:", id(a) == id(b))
# ② NumPy 的切片:两个不同的对象,共用同一块缓冲区
import numpy as np
x = np.array([1, 2, 3, 4])
y = x[:2]
y[0] = 99
print("② NumPy : x =", x, " y =", y, " 同一个对象吗:", x is y, " y 借的是谁的内存:", y.base is x)
# ③ 引用计数:Python 自己数
c = []
print("③ refcount 一开始:", sys.getrefcount(c) - 1) # 减掉传参那一次
d = c
print(" 多挂一个名字后:", sys.getrefcount(c) - 1)
del d
print(" del 掉之后 :", sys.getrefcount(c) - 1)
实跑输出:
操作步骤
- Python: a = [1, 2, 3, 4] b = [1, 2, 3, 4] 同一个对象吗: True id 相同吗: True
- NumPy : x = [99 2 3 4] y = [99 2] 同一个对象吗: False y 借的是谁的内存: True
- refcount 一开始: 1
- 多挂一个名字后: 2
- del 掉之后 : 1
⭐ 第 ③ 段是这一章的引子。 Python 内置了一个计数器:每多一个名字指向某个对象,计数 +1;每少一个,计数 -1;归零就释放。这件事你从来没写过一行代码去做它,它是语言的一部分。
⭐ C++ 没有这个内置计数器。 所以「什么时候释放」必须写在代码里,而 C++ 提供了好几种写法 —— 源码里那一堆符号,就是不同的写法。
🧩 二、⚠️ 第一个反直觉:C++ 的 = 默认是复制
这是从 Python 下来的人最容易读错的一处,而且它不报错,只是让你把源码理解反。
// c02_copy.cpp
// g++ -O2 -std=c++17 c02_copy.cpp -o c02_copy
#include <cstdio>
#include <vector>
#include <string>
#include <utility>
struct Loud {
std::string name;
std::vector<double> data;
Loud(std::string n, size_t k) : name(std::move(n)), data(k, 1.0) {
std::printf(" [构造] %s (%zu 个 double)\n", name.c_str(), data.size());
}
Loud(const Loud& o) : name(o.name + "-拷贝"), data(o.data) {
std::printf(" [拷贝构造] %s <- %s ⚠️ 复制了 %zu 个 double\n",
name.c_str(), o.name.c_str(), data.size());
}
Loud(Loud&& o) noexcept : name(std::move(o.name)), data(std::move(o.data)) {
std::printf(" [移动构造] %s ⭐ 只搬了指针,原对象现在有 %zu 个\n",
name.c_str(), o.data.size());
}
~Loud() {
std::printf(" [析构] %s\n", name.empty() ? "(已被搬空)" : name.c_str());
}
};
void take_by_value(Loud x) { std::printf(" -> 函数里拿到 %s\n", x.name.c_str()); }
void take_by_ref(const Loud& x) { std::printf(" -> 函数里拿到 %s(没拷贝)\n", x.name.c_str()); }
int main() {
std::printf("① 传值:\n");
{ Loud a("a", 3); take_by_value(a); }
std::printf("\n② 传 const 引用:\n");
{ Loud b("b", 3); take_by_ref(b); }
std::printf("\n③ 传值 + std::move:\n");
{ Loud c("c", 3); take_by_value(std::move(c)); }
return 0;
}
实跑输出(g++ 15.1.0,-O2 -std=c++17):
操作步骤
⭐ 三件事一次看清:
- ① 传值 = 真的复制了一份。
data里那 3 个 double 被逐个复制,函数结束时那份副本被单独析构。如果data里是 1000 万个数,这里就复制 1000 万个数。 - ②
const Loud&一次拷贝都没有。整个过程只有一次构造一次析构 —— 函数里拿到的就是外面那个对象本身。 - ③
std::move之后走的是移动构造,输出里那句「原对象现在有 0 个」是关键:数据被搬走了,源对象空了。
📋 两边的默认值对照:
b = a 的意思 |
改 b 会影响 a 吗 |
|
|---|---|---|
| Python | 给同一个对象再挂一个名字 | ✅ 会(它们本来就是一个东西) |
| C++ | 把 a 整个复制一份给 b |
❌ 不会(两份互不相干) |
⚠️ 所以从 Python 带过来的直觉在这里会给你两种相反的错:以为「不会拷贝」的地方悄悄拷贝了一整个矩阵(性能问题),以为「会跟着变」的地方根本没变(正确性问题)。
可选深入:构造、花括号与返回值,到底少了哪一次复制?
先分清初始化语法,再看构造日志
这一补充固定以 C++17 为基线,独立标准库例子也在 C++20 下核过。默认构造函数能无参调用;从参数初始化对象的构造函数不等于隐式转换许可。复制构造通常接收 const T&,移动构造通常接收 T&&,后者怎样转移资源仍由类型实现决定。下面的 Loud 用日志把它们拆开:
#include <cassert>
#include <iostream>
#include <utility>
#include <vector>
struct Base { Base() { std::cout << "base "; } };
struct Member {
int value;
Member(const char* name, int n) : value(n) { std::cout << name << '=' << n << ' '; }
};
struct Loud : Base {
Member first; // declaration order decides initialization order
Member second;
Loud() : Loud(0) { std::cout << "default\n"; }
explicit Loud(int n) : second("second",n+1), first("first",n) {
std::cout << "from-int\n"; // safe: no read of uninitialized first
}
Loud(const Loud& o) : Base(o), first("first",o.first.value), second("second",o.second.value) {
std::cout << "copy\n";
}
Loud(Loud&& o) noexcept : Base(std::move(o)), first("first",o.first.value), second("second",o.second.value) {
std::cout << "move\n";
}
};
Loud direct() { return Loud{5}; } // C++17 prvalue direct construction
Loud named() { Loud local{6}; return local; } // NRVO permitted, not required
int main() {
Loud a; Loud b(2); Loud c{b}; Loud d(std::move(b));
assert(a.first.value==0 && d.first.value==2);
auto e=direct(); auto f=named();
assert(e.first.value==5 && f.first.value==6);
std::vector<int> count_value(3,7), elements{3,7};
assert(count_value.size()==3 && count_value[0]==7);
assert(elements.size()==2 && elements[0]==3 && elements[1]==7);
}
观察顺序:基类先于成员;first 先于 second,尽管初始化列表反着写。对非委托构造,虚基类由最派生对象按规定遍历顺序初始化,然后是直接基类声明顺序、非静态成员声明顺序,最后进入函数体。初始化列表的文本顺序改不了它。示例的两个成员只依赖 n;不要把 second 写成依赖尚未初始化成员的危险试验。委托构造则先完成目标构造,再执行委托者函数体。
“虚基类”可用一个最小菱形关系理解:若 L、R 都以 virtual 继承 B,D 再继承 L、R,这些虚继承路径在 D 中共享同一个 B 子对象,由最派生对象初始化;普通重复继承路径则各有子对象。混合虚/非虚路径仍可带来额外的非虚 B,不是所有菱形都自动只有一份。虚继承解决基类子对象关系,虚函数解决调用派发,不能由同一个关键词推出相同用途或固定布局。
回看现有 Loud : Base 与 Member first/second:有合理基类契约和可替换关系时可考虑继承;独立职责或寿命的部件可用组合表达,避免仅为复用几行实现就继承。这是设计取舍,不是标准强制或“组合永远更好”;含成员不等于运行期多态,继承也不自动需要虚函数。
默认、复制、移动构造是否由编译器生成有条件:声明其他构造函数会抑制隐式默认构造;用户声明复制/移动或析构函数会影响隐式移动的生成,声明移动操作还可能使隐式复制被定义为删除;成员不可复制也可能使生成的复制构造被删除。因此“没写就一定有”不成立;本节不展开全部特殊成员规则。
Loud b(2) 与 Loud b{2} 都是直接初始化,允许调用 explicit 构造;Loud b = 2 的复制初始化不允许这样隐式转换。故意不能编译的最小反例,须单独作为一个文件:
struct Loud { explicit Loud(int) {} };
int main() { Loud value = 1; } // expected compile error: explicit conversion
花括号还检查窄化,并在合适时优先考虑 initializer_list 构造。因而 vector 的 (3,7) 是三个 7,{3,7} 是两个元素;花括号不是圆括号的统一替代。下面同样是预期编译失败,不能与可运行文件合并:
int main() { int value{3.5}; } // expected compile error: narrowing
return Loud{5} 的同类型 prvalue 在 C++17 起直接构造结果对象,不要求存在一个可复制/移动的中间对象;下面删除两种构造仍能编译,析构函数仍须可访问且未删除。return local 则是命名返回值优化 NRVO 的候选,是否发生不能由一份日志保证;不发生时还要满足相应复制/移动要求。不要把一次编译观察到的“零 move”写成所有返回形式的保证,也不要为提速机械改成 return std::move(local),那会失去 NRVO 的候选形式。
struct Token {
Token() = default;
Token(const Token&) = delete;
Token(Token&&) = delete;
};
Token make() { return Token{}; }
int main() { Token value = make(); }
上面的断言核对值,不锁死 named() 的构造次数。依据 C++17 草案:构造函数、复制/移动生成条件、转换构造、列表初始化、初始化顺序、复制消除。
可选深入:Loud 里的 this、默认访问与空指针
对象指针不等于所有权
在本章 C++17 的非静态成员函数里,this 指向本次调用的对象;const 成员函数中的 this 类型为 const Loud*,限制这条访问路径,不让对象自动线程安全。struct 默认成员访问与默认基类继承为 public,class 默认均为 private;显式写出访问说明后,它们都能有构造、成员函数等机制。以下是独立缩小版 Loud,不改前面的类型。
访问级别另问“谁可以用这个成员”:public 对调用方开放;private 仍允许本类成员和友元访问;protected 还允许符合规则的派生类成员/友元访问。对于派生类 D 取得权限的受保护非静态成员访问,通常还要求对象表达式的静态类型是 D 或其派生类,不能因此任意经 Base& 或兄弟派生对象访问;成员指针也有额外限定。访问控制不等于所有权、线程安全或运行期内存隔离。依据:C++17 访问控制与protected 访问规则。
#include <cassert>
#include <cstddef>
#include <type_traits>
struct Loud {
int value=3; // struct: public by default
int read() const {
static_assert(std::is_same_v<decltype(this),const Loud*>);
return this->value;
}
};
class Hidden { int value=3; }; // class: private by default
int choose(int) { return 1; }
int choose(const int*) { return 2; }
int main() {
const Loud object;
assert(object.read()==3);
static_assert(std::is_same_v<decltype(nullptr),std::nullptr_t>);
assert(choose(0)==1 && choose(nullptr)==2);
// choose(NULL) intentionally omitted: NULL's definition varies.
}
nullptr 有专门类型 std::nullptr_t,可转为指针空值,示例因此选指针重载;整数 0 选 int 重载。NULL 是实现定义的空指针常量宏,定义形式会影响重载或造成歧义,不能断言所有平台都等于同一类型的 0。这里不执行对空 this 的成员访问,也不展开继承/虚函数。依据:C++17 this、nullptr_t。
🧩 三、于是源码里到处是 const Tensor&
上一节的输出只有 3 个 double,看不出代价。把规模放大量一下 —— 每个 vector 约 78 KB,5000 个:
// c02_cost.cpp
// g++ -O2 -std=c++17 c02_cost.cpp -o c02_cost
#include <cstdio>
#include <vector>
#include <chrono>
#include <utility>
using Clock = std::chrono::steady_clock;
static double ms_since(Clock::time_point t) {
return std::chrono::duration<double, std::milli>(Clock::now() - t).count();
}
int main() {
const size_t N = 10'000; // 每个 vector 1 万个 double ≈ 78 KB
const int R = 5000;
// 计时之外先把 5000 个源 vector 都造好,两组用的是同样的东西
std::vector<std::vector<double>> poolA(R, std::vector<double>(N, 3.0));
std::vector<std::vector<double>> poolB(R, std::vector<double>(N, 3.0));
std::vector<std::vector<double>> bag;
double sink = 0;
// ① 拷贝:源对象还留着,所以必须重新分配一块再逐字节复制
bag.clear(); bag.reserve(R);
auto t = Clock::now();
for (int i = 0; i < R; ++i) bag.push_back(poolA[i]); // ⚠️ 拷贝构造
double t_copy = ms_since(t);
sink += bag[0][0] + poolA[0].size(); // ⭐ 源还在,size 仍是 N
// ② 移动:告诉编译器「源我不要了」,于是只搬指针
bag.clear(); bag.reserve(R);
t = Clock::now();
for (int i = 0; i < R; ++i) bag.push_back(std::move(poolB[i])); // ⭐ 移动构造
double t_move = ms_since(t);
sink += bag[0][0];
std::printf("%d 个 vector,每个 %.0f KB(合计 %.0f MB)\n",
R, N * sizeof(double) / 1024.0, R * N * sizeof(double) / 1048576.0);
std::printf("① 拷贝进 bag: %8.2f ms\n", t_copy);
std::printf("② 移动进 bag: %8.2f ms\n", t_move);
std::printf(" 倍数 : %8.1f x\n", t_copy / t_move);
std::printf("移动之后,源 poolB[0] 的 size = %zu(被搬空了)\n", poolB[0].size());
std::printf("拷贝之后,源 poolA[0] 的 size = %zu(还在)\n", poolA[0].size());
std::printf("(sink=%.1f)\n", sink);
return 0;
}
跑三次的实跑结果:
| 次 | ① 拷贝 | ② 移动 | 倍数 |
|---|---|---|---|
| 1 | 264.02 ms | 0.02 ms | 16197x |
| 2 | 280.50 ms | 0.02 ms | 17104x |
| 3 | 300.58 ms | 0.02 ms | 18107x |
⭐ 倍数大到没什么意义,重点是它的形状:移动那一栏基本不随数据量增长 —— 它每次只搬 3 个指针(起点、终点、容量上限),跟里面装 1 万个还是 1 亿个 double 无关。拷贝那一栏则是老老实实分配 381 MB 再逐字节复制。
⚠️ 顺带一个诚实的记录:我最早的版本还量了「传 const&」这一组,结果是 0.00 ms —— 编译器在 -O2 下把整个调用优化没了,算出来的倍数是几万到几百万,纯属噪声。所以正文里的对照换成了上面这组:两边都真的把东西放进了 bag,只有「要不要复制」这一点不同。
🚦 读法:把 & 当成一句声明
这就是为什么 PyTorch 的 C++ 源码里,函数签名几乎清一色长这样:
Tensor add(const Tensor& self, const Tensor& other, const Scalar& alpha);
读它的时候在心里翻译成:
| 你看到的 | 它在说 |
|---|---|
const Tensor& |
「借我看看,我不改它,也不负责释放它」 —— 出了这个函数它还是外面那个 |
Tensor& |
「借我用,允许我改它」 —— 外面能看见改动 |
Tensor |
「给我一份」 —— 要么复制、要么你 move 给我,反正这份归我了 |
Tensor&& |
「我只收你不要了的那种」 |
⭐ 这四行是本章最实用的一张表。 读源码卡住时,八成是把某个 & 读漏了。
🔎 const 管哪一层,借用能活多久?
下面按 C++17 读声明,假定 T 是普通非 const 对象类型。表里的“可改”表示接口允许,不表示每次调用一定修改。const Tensor& 限制的是通过这个访问路径修改句柄;它不是底层 tensor 数据不可变的证明,间接数据与别名仍须读框架 API 的契约。
| 声明 | 自身能改指向? | 能经它修改 T? | 容易误读处 |
|---|---|---|---|
T* p | 能 | 能 | 指针可能为空;解引用前仍须有效 |
const T* p | 能 | 不能 | 指向 const 的指针;其他可写别名可能仍能改原对象 |
T* const p = &x | 不能 | 能 | 指针自身 const,目标并未因此 const |
const T* const p = &x | 不能 | 不能 | 两层分别受限,不代表对象永远无人可改 |
T& r = x | 引用不能重新绑定 | 能 | r = y 给 x 赋值,不是把 r 改绑到 y |
const T& r = x | 引用不能重新绑定 | 不能 | 只读访问路径;不负责销毁被借对象 |
绑定与寿命再分开:普通 T& 绑定可写左值;const T& 也可绑定临时量;固定类型的 T&& 可绑定合适的右值。局部直接绑定 const std::string& s = std::string("hi"); 可延长该临时对象的寿命到 s 的寿命;把临时量传给引用形参,通常只活到包含这次调用的完整表达式结束。函数把这个引用存起来或返回,不会再次延长寿命。后面的悬垂实验继续解释借用失效。
读源码时别让推导把“借用”弄丢:对下面这个普通变量,按 C++17 规则手推类型(这里没有容器深拷贝的统一承诺):
int x = 1;
const int& r = x;
auto a = r; // int,独立的值;按值 auto 不保留顶层 const/引用
auto& b = r; // const int&,仍借用 x
decltype(r) c = x; // const int&:未加括号的名字,取声明类型
decltype(x) d = x; // int
decltype((x)) e = x; // int&:括号后按表达式值类别判断
decltype(auto) f = (x); // int&,不是 int;别返回对已销毁局部量的引用
decltype 通常不求值:对未加括号的名字取声明类型;其余表达式按左值 → T&、将亡值 → T&&、纯右值 → T 判定。以上只补本章签名读法,不展开列表初始化等额外推导规则。
依据:C++17 工作草案 N4659 的 引用初始化、临时对象寿命、cv 限定、auto 与 decltype;可对照 WG21 原稿。这些是语言规则核对,不是 PyTorch 全部 API 的不可变性保证。
🧩 四、std::move 不移动任何东西
这个名字起得很坏,坑过所有人。
⭐ std::move(x) 在运行时什么都不做。 它是一个纯粹的类型转换 —— 把 x 标记成「这是一个可以被掏空的东西」,好让编译器在重载里挑中移动那个版本而不是拷贝那个版本。真正搬东西的是移动构造函数/移动赋值,不是 std::move 本身。
所以读源码时可把它理解成:允许后续操作从 x 转移资源。是否真的移动,要看随后的重载选择;转换本身不销毁 x,也不保证它被清空。
⚠️ 资源真的被转走后,不要再假定原内容还在。 上一节实验记录的是这两次操作的结果:
要点
移动之后,源 poolB[0] 的 size = 0(被搬空了)
拷贝之后,源 poolA[0] 的 size = 10000(还在)
💀 除非类型另有规定,标准库对象移动后处于「有效但未指定」状态。这次 vector 实验读到了 size = 0;不能把这条观察推广成所有类型、所有移动操作都保证清空。对象仍可按类型契约使用,具体允许什么还要检查操作的前置条件。
📋 两条能保命的规矩:
| 规矩 | 为什么 |
|---|---|
| ⭐ 移动后按类型契约与前置条件使用;重新赋值、析构是常见选择,vector 的 size/empty 也可查询 | 不要假定旧值或必为空;front 等操作仍须先满足非空条件 |
| ⚠️ 不要对准备继续用的东西 move | 编译器不会拦你,症状是后面某处数据莫名变空 |
🧪 有名字的 T&&,为什么还是左值?
值类别属于表达式。在本例的对象表达式中:n 和有名字的 r 是左值;7 是纯右值;std::move(n) 是将亡值(xvalue)。纯右值与将亡值合称右值。int&& 是变量的声明类型,不会让每次写下名字 r 都成为右值。
下面是 C++17 最小可编译示例;输出按重载规则手推,未标为本机编译实跑。可保存后用支持 C++17 的编译器验证:
#include <iostream>
#include <utility>
void pick(int&) { std::cout << "L "; }
void pick(int&&) { std::cout << "R "; }
template<class T> void relay(T&& v) { // T 由实参推导:这里才是转发引用
pick(v); // v 有名字,总按左值传
pick(std::forward<T>(v)); // 恢复这次推导对应的值类别
}
int main() {
int n = 1;
int&& r = std::move(n);
pick(r); // L
pick(std::move(r)); // R;转换本身不把 int 清零
relay(n); // T = int&,引用折叠后为 int&:L L
relay(7); // T = int,形参为 int&&:L R
} // 合起来:L R L L L R
两种转换分工不同:std::move(v) 无条件把对象表达式转成可用于移动的将亡值;std::forward<T>(v) 在这个推导场景中保留调用者的左/右值类别,不能把它当成“更快的 move”。固定类型参数 void f(int&&) 不是转发引用。move 也不去掉 const:从 const std::string 做 std::move 得到 const std::string&&,通常无法选中接收非 const 右值的移动构造,反而走拷贝。
移动后怎样继续用?对未另作规定的标准库类型,移动后保持有效但未指定:不变量成立,操作仍按该类型的契约工作。以 std::vector<int> v 为例,移动后可调用 v.empty()、v.size();只有先确认非空,才能调用要求非空的 v.front()。不能假定读到旧内容,也不能把“未指定”当成允许越过前置条件。自定义类型还须看其移动操作承诺。
依据:N4659 的 表达式值类别、move / forward、标准库移动后状态 与 有效但未指定的定义。这里选用 C++17 版本文本;不把后续草案新增内容倒推成所有 C++ 版本的规则。
🧩 五、RAII:C++ 版的 with
这里的析构保证针对正常离开作用域和按规则进行的异常栈展开;进程被强制结束、std::abort、std::terminate 或某些直接退出路径不会按这条规则清理所有局部对象。RAII 也不替代跨进程崩溃恢复。引用、指针和 Tensor 句柄的复制语义同样要按类型看,不能把“C++ 赋值会复制”读成“深拷贝底层数据”。
现在回答开头那个问题:既然 C++ 没有内置的引用计数,那释放靠什么?
⭐ 靠作用域。 一个对象在离开它所在的大括号时,析构函数一定会被调用。于是 C++ 的惯用法是:把「要还回去的东西」包成一个对象,让析构函数去还。 这套做法有个名字叫 RAII(Resource Acquisition Is Initialization,资源获取即初始化)。
// c02_raii.cpp
// g++ -O2 -std=c++17 c02_raii.cpp -o c02_raii
#include <cstdio>
#include <stdexcept>
#include <memory>
struct Guard { // 一个最小的 RAII 对象
const char* what;
explicit Guard(const char* w) : what(w) { std::printf(" 拿到 %s\n", what); }
~Guard() { std::printf(" 还回 %s\n", what); }
};
void may_throw(bool boom) {
Guard g("锁"); // ⭐ 出这个函数时一定还锁,不管怎么出去
std::printf(" 干活中…\n");
if (boom) throw std::runtime_error("中途炸了");
std::printf(" 正常干完\n");
}
struct Node {
int id;
explicit Node(int i) : id(i) { std::printf(" Node%d 出生\n", id); }
~Node() { std::printf(" Node%d 死亡\n", id); }
};
int main() {
std::printf("① 正常返回:\n");
may_throw(false);
std::printf("\n② 抛异常:\n");
try { may_throw(true); }
catch (const std::exception& e) { std::printf(" 接住了:%s\n", e.what()); }
std::printf("\n③ unique_ptr(唯一所有者):\n");
{
std::unique_ptr<Node> p = std::make_unique<Node>(1);
std::unique_ptr<Node> q = std::move(p); // ⭐ 所有权搬走,不能拷贝
std::printf(" p 现在是空的吗: %s\n", p ? "不是" : "是");
std::printf(" q 指着 Node%d\n", q->id);
} // ⭐ q 出作用域 -> Node1 死
std::printf("\n④ shared_ptr(大家共有,最后一个走的关灯):\n");
{
std::shared_ptr<Node> a = std::make_shared<Node>(2);
std::printf(" 持有者 %ld 个\n", a.use_count());
{
std::shared_ptr<Node> b = a; // ⭐ 拷贝 = 计数 +1,不复制 Node
std::printf(" 多了一个 b,持有者 %ld 个\n", a.use_count());
}
std::printf(" b 走了,持有者 %ld 个(Node2 还活着)\n", a.use_count());
}
std::printf(" a 也走了 ↑\n");
return 0;
}
实跑输出:
操作步骤
- 正常返回:
- 拿到 锁
- 干活中…
- 正常干完
- 还回 锁
- 抛异常:
- 拿到 锁
- 干活中…
- 还回 锁
- 接住了:中途炸了
- unique_ptr(唯一所有者):
- Node1 出生
- p 现在是空的吗: 是
- q 指着 Node1
- Node1 死亡
- shared_ptr(大家共有,最后一个走的关灯):
- Node2 出生
- 持有者 1 个
- 多了一个 b,持有者 2 个
- b 走了,持有者 1 个(Node2 还活着)
- Node2 死亡
- a 也走了 ↑
⭐ ①② 的对比是 RAII 的全部价值:抛异常那一路,「干完」那行没打印,但「还回 锁」打印了,而且是在 catch 接住之前。作用域一结束析构就跑,正常返回和异常离开走的是同一条路。
📋 和 Python 的对应关系:
| Python | C++ | 差别 |
|---|---|---|
with open(f) as x: |
{ std::ifstream x(f); ... } |
Python 要你记得写 with;C++ 是只要对象在栈上就自动生效 |
__exit__ |
析构函数 | 同一个位置 |
try / finally |
析构函数 | C++ 没有 finally,因为 RAII 覆盖了它的用途 |
⭐ 回扣 01 章:那一章说 py::gil_scoped_release 是 RAII 对象、所以「哪怕函数中途抛异常锁也一定会被还回去」—— 上面 ② 那三行输出就是这句话的实况。构造时放开锁,析构时拿回来,中途炸了照样拿回来。
可选深入:拿到存储,不等于对象已经构造
new/delete 与 malloc/free 的配对边界
| 方式 | 对象生命周期 | 对应清理 |
|---|---|---|
| new T / new T[n] | 分配存储并初始化单个对象 / 数组元素 | delete / delete[],调用析构并释放相应存储 |
| malloc(bytes) | 只申请存储,不调用非平凡类型的构造函数 | free,不调用析构函数 |
| new (storage) T | 在已有且满足大小/对齐要求的存储上构造 | 显式析构结束对象生命周期,再按原来源释放存储 |
不能 new 配 free、malloc 配 delete,new[] 也不能配 delete。下面 Guard 有非平凡构造/析构,malloc 返回地址不会让 alive 增加。示例不涉及过度对齐类型:普通 malloc 的对齐不能泛化为任意 over-aligned T 的保证。实际业务优先用容器、make_unique 和作用域来表达所有权,手动分层只是解释接口。
#include <cassert>
#include <cstdlib>
#include <memory>
#include <new>
#include <stdexcept>
#include <iostream>
struct Guard {
inline static int alive = 0;
Guard() { ++alive; }
~Guard() { --alive; }
};
int main() {
{ auto p = std::make_unique<Guard>(); assert(Guard::alive == 1); }
assert(Guard::alive == 0);
try { auto p = std::make_unique<Guard>(); throw std::runtime_error("stop"); }
catch (const std::runtime_error&) {}
assert(Guard::alive == 0); // normal and exception exit both release
auto array = new Guard[2];
assert(Guard::alive == 2);
delete[] array; // matches new[]
void* storage = std::malloc(sizeof(Guard));
if (!storage) return 2;
Guard* object = nullptr;
try { object = new (storage) Guard; } // start nontrivial object's lifetime
catch (...) { std::free(storage); throw; }
object->~Guard(); // end lifetime, does not free malloc storage
std::free(storage);
assert(Guard::alive == 0);
std::cout << "alive=" << Guard::alive << '\n';
}
普通抛异常的 new 在分配失败时抛 std::bad_alloc,malloc 失败返回空指针,另有 nothrow new 的接口。new 表达式若构造失败,通常由匹配的释放函数归还刚分配的存储;完整对象没构造成功,就不会调用它的析构,但已完成构造的子对象会按规则展开。标准 placement new 不负责 free 你给的存储,所以这里在 catch 中归还 malloc 存储。正常路径先析构再 free,异常路径与正常路径的 make_unique 都验证 alive 回到 0。
存储从哪里来?以 glibc 2.42 的 malloc 为例,分配器用块大小、状态等元数据管理存储,可复用已空闲的块,必要时再经 brk/mmap 等路径取得更多虚拟空间。不是每次调用都进内核,也没有适用于所有平台的固定阈值或物理连续保证;返回非空仍不等于所有物理页已驻留。这里接的是 01 章的用户态分配器边界,不改变上面的构造/释放规则。
“局部对象在栈上、new 对象在堆上”只是常见实现速记。语言讨论的是自动/静态/线程/动态等存储期、生命周期与销毁责任,不强制某个物理栈或堆布局;优化也可能消除实际分配。依据 C++17 草案:new 表达式、delete 表达式、C 存储管理。
可选深入:锁也是 RAII 资源,接口失败怎样传播?
guard 固定作用域,unique_lock 可改变持有状态
lock_guard 不可复制/移动,常规构造立即上锁,作用域结束解锁;unique_lock 不可复制但可移动,能延后获取、显式解锁/再锁,并查询自己是否持锁。被锁对象必须活得比管理器久。下面只验证单线程资源管理路径,不是同步协议或锁竞争性能试验:
#include <cassert>
#include <mutex>
#include <stdexcept>
#include <utility>
int main() {
std::mutex m;
try {
std::lock_guard<std::mutex> guard(m);
throw std::runtime_error("operation failed");
} catch (const std::runtime_error&) {}
assert(m.try_lock()); // proves scope cleanup on this exception path
m.unlock();
std::unique_lock<std::mutex> delayed(m,std::defer_lock);
assert(!delayed.owns_lock());
delayed.lock();
auto transferred=std::move(delayed);
assert(!delayed.owns_lock() && transferred.owns_lock());
transferred.unlock();
assert(!transferred.owns_lock());
transferred.lock(); // destructor unlocks only if still owning
}
异常可把失败向调用链传播,按规则栈展开时 RAII 清理已构造资源;返回状态/错误码则把分支留给调用者,须检查结果,不能靠“没抛异常”判断成功。接口选择看恢复责任、调用约定、异常边界与团队约定,不能未经测量声称谁永远更快。析构期间再抛异常可能导致 terminate,清理函数应按接口约定处理失败;异常也不意味着数据库写入等外部效果自动回滚。下面只补一次条件等待,不展开并发事务。依据:lock_guard、unique_lock。
这里有三层:RAII 管理器调用 mutex 的接口;互斥原语协调所有权及解锁到随后成功加锁的同步;实现再选择原子状态与等待/唤醒机制。例如 Linux futex 可把用户态状态与必要的内核等待连接起来,但 C++ 标准没有规定 std::mutex 必须用 futex,也不是每次 lock 都进内核;公平性、自旋轮数和平台路径不能从 RAII 例推出。
unique_lock 能暂时释放再获取锁,也可交给条件变量等待。下面只交接一次数据:同一 m 保护持久的 ready/stop 状态和数据,先于等待发生的通知要靠状态承接,而非靠通知次数。
一次条件等待的交接(伪代码,非可编译 C++ 程序)
worker:
unique_lock lock(m)
cv.wait(lock, ready || stop 的谓词)
若 stop,返回;否则取走数据
lock.unlock();处理一次数据后返回
主线程:
{ 持 m 写入数据,ready = true }
cv.notify_one()
不持 m 调用 worker.join()
cv.wait(lock, pred) 原子地释放锁并进入等待,醒来后重新持锁、复查谓词,因而也处理虚假唤醒;循环本身不能修复未按同一锁协议保护的状态。停止分支同样在锁内置 stop=true,再通知;notify 可在解锁后发出,不要求持锁。m、条件变量、状态和数据都要活到 worker 退出并被 join 之后;不用 sleep 假装同步,也不把这一个标志当生产消息队列。依据:C++17 condition_variable。
🧩 六、四种指针,四种所有权声明
unique_ptr / shared_ptr 那两段(③④)演示的是同一件事的两种回答。把它们和裸指针、引用放在一起:
| 你在源码里看到 | 谁负责释放 | 能不能拷贝 | 读作 |
|---|---|---|---|
T*(裸指针) |
⚠️ 文档说了算,代码里看不出来 | 能(但拷的只是地址) | 「这里有个地址,别的什么都别假设」 |
T&(引用) |
❌ 不是我 | —— | 「借我看看,出了这个函数它还归外面」 |
std::unique_ptr<T> |
⭐ 我,而且只有我 | ❌ 不能拷贝,只能 move | 「这东西归我,要给别人就得 std::move」 |
std::shared_ptr<T> |
最后一个走的人 | ✅ 能(计数 +1) | 「大家共有,谁都可能是最后一个」 |
std::weak_ptr<T> |
❌ 不是我 | ✅ 能 | 「我盯着它,但不延长它的命,用之前得先问它还在不在」 |
⭐ 读源码时把这一列当成注释读,比看真注释可靠 —— 注释会过期,类型不会,编译器会强制它成立。三条最有信息量的:
- 看到
unique_ptr出现在返回值上,你立刻知道「这个函数造了个东西,所有权交给你了」。 - 看到
unique_ptr作为参数且传值,你立刻知道「调用方必须std::move进来,之后就别用了」。 - 看到
weak_ptr,八成是在打破循环引用 —— 两个shared_ptr互相指着对方,计数永远归不了零,就泄漏了。⚠️ 这是shared_ptr常见的循环持有问题,和 Python 引用计数的循环引用问题是同一个病(Python 靠额外的循环垃圾回收器兜底,C++ 靠你写weak_ptr)。
⚠️ shared_ptr 不是「更安全的 unique_ptr」,别无脑用它:它要多存一个控制块(计数在那里),计数的加减是原子操作,多线程下会真的争抢缓存行(03 章会看到这件事的代价)。默认选 unique_ptr,确实说不清谁最后走才用 shared_ptr。
可选深入:shared_from_this 复用的是哪个控制块?
对象地址相同,还不够证明共享所有权
对象想把“自己的一份共享所有权”交出去,使用公开且无歧义的 enable_shared_from_this<Node> 基类,并先让合适的 shared_ptr 建立所有权。下面 make_shared 返回后调用 self,owner_before 双向都为 false,才核对了 p/q 的所有权等价。use_count=2 仅是这个单线程小例此刻的观察。
#include <cassert>
#include <memory>
#include <iostream>
struct Node : public std::enable_shared_from_this<Node> {
std::shared_ptr<Node> self() { return shared_from_this(); }
};
int main() {
auto p = std::make_shared<Node>();
auto q = p->self();
assert(p.get()==q.get());
assert(!p.owner_before(q) && !q.owner_before(p)); // same control block
assert(p.use_count()==2);
Node unmanaged;
bool caught=false;
try { auto invalid=unmanaged.self(); }
catch (const std::bad_weak_ptr&) { caught=true; } // specified failure, not UB
assert(caught);
std::cout << "same owner; unmanaged rejected\n";
// Never test shared_ptr<Node>(p.get()) or delete p.get(): double ownership/deletion risk.
}
不要写 std::shared_ptr<Node>(this):它可能再建立一个独立控制块,与既有所有者争着删除同一个对象。shared_from_this 从内部 weak_ptr 取得既有控制块;尚无所有者的栈对象在 C++17 下调用会抛 bad_weak_ptr,构造函数体内也不能假定 make_shared 已完成绑定。可在工厂完成创建后再调用需要共享所有权的初始化步骤;不得靠执行重复释放验证风险。
delete this 也不是“计数减一”。它要求对象来源适合这次单对象 delete、删除类型正确、没有另一套所有者继续销毁,且之后任何路径都不能再访问已结束生命周期的对象或释放它。它不适用于栈对象、数组元素或仍被智能指针拥有的对象。普通 RAII/共享所有权设计不手动自删。shared_ptr 对控制块计数的同步不使 Node 的成员访问自动线程安全;同一 shared_ptr 实例的并发修改也要遵守同步规则。
依据 C++17 草案:enable_shared_from_this、shared_ptr 构造与绑定、delete 的要求。
🧩 七、💀 悬垂:这一章真正存在的理由
前面都是「怎么写对」。这一节是「写错了会怎样」,而它的可怕之处不是崩溃,是不崩溃。
// c02_dangle.cpp
// g++ -O2 -std=c++17 c02_dangle.cpp -o c02_dangle
#include <cstdio>
#include <cstdint>
#include <vector>
int main() {
std::vector<int> v{10, 20, 30};
const int* p = v.data(); // ⚠️ 记住这个地址
std::printf("push 之前: data=%p capacity=%zu p[0]=%d\n",
(const void*)p, v.capacity(), p[0]);
const auto old_address = reinterpret_cast<std::uintptr_t>(p);
for (int i = 0; i < 100; ++i) v.push_back(i); // 容量不够 -> 换一块更大的地方
std::printf("push 之后: data=%p capacity=%zu\n",
(const void*)v.data(), v.capacity());
std::printf("地址变了吗: %s\n", old_address == reinterpret_cast<std::uintptr_t>(v.data()) ? "没变" : "⚠️ 变了");
std::printf("v[0] 从新地址读 = %d (正确)\n", v[0]);
// ⚠️⚠️ 下面这一行是【未定义行为】:p 指着已经被释放的那块内存
// 禁止执行旧指针解引用:std::printf("%d", p[0]);
return 0;
}
历史危险版本记录(只摘关键行):原稿曾执行旧指针解引用,留下下面三次观察。现在上方已注释该行,地址比较也使用失效前保存的整数;本次没有重跑未定义行为,修正版不会输出表中的旧地址读数。
| 次 | v[0] 从新地址读 |
p[0] 从旧地址读 |
退出码 |
|---|---|---|---|
| 1 | 10 | 618801184 | 0 |
| 2 | 10 | -283301856 | 0 |
| 3 | 10 | -1883166688 | 0 |
💀💀 三次跑出三个完全不同的垃圾数,一次都没崩,退出码全是 0。
⭐ 这些只是未定义行为的一种历史表现。语言不保证垃圾数、不崩溃或退出码 0,崩溃、看似正确或其他结果都不能作为程序正确的证据:
| Python 出错时 | C++ 悬垂时 | |
|---|---|---|
| 有没有异常 | 有,IndexError / AttributeError |
❌ 没有 |
| 有没有 traceback | 有,指到出错那一行 | ❌ 没有 |
| 能不能复现 | 能 | ⚠️ 时好时坏,加个 printf 可能就"好了" |
| 错在哪一行 | 就是报错那一行 | ⚠️ 可能在几百行之前 —— 崩的地方和错的地方无关 |
⚠️ 注意它出错的机制:p 拿到地址的那一刻是完全合法的;是后来的 push_back 让 vector 换了一块更大的内存,把旧的那块还给了系统。p 自己什么都没做错,是它指着的东西跑了。
📋 跨语言时最常见的三种悬垂(全是 01 章第五节那个坑的展开):
| 情形 | 谁跑了 |
|---|---|
C++ 那边存了 float* ptr = arr.data(),Python 那边这个数组被回收了 |
数组的内存 |
| C++ 存了指向某个元素的指针,容器随后扩容 / 重排 | 整块缓冲区搬家了(就是上面这个实验) |
| 函数返回了一个指向局部变量的引用或指针 | 局部变量随函数栈帧一起消失 |
可选深入:vector 容量、原地构造与 list 的稳定性
改容器前先问:哪些借用还能继续用?
迭代器先是“遍历位置+允许的操作”的抽象。算法通过同一套接口处理不同序列:对可解引用的位置用 *it 访问元素,用 ++it 前进;end 表示结束位置,不能解引用。它不要求迭代器对象本身就是元素的裸地址。
这些接口常按 STL 的六类组件来理解:容器存元素(如 vector),迭代器给位置与能力,算法处理范围(如 find),函数对象提供策略(如 std::less),适配器包装接口(如 std::stack),分配器供给存储(如 std::allocator)。这是常见教材的分类,不是标准强制枚举;STL 不等于整个 C++ 标准库,不能把 iostream 或 shared_ptr 都归进去。分配器供存储与对象构造是两步,也不代表全部 new 路径。
沿现有 vector<int> 看一次组件配合:std::find 接收半开范围 [begin, end),只有结果不等于 end 才解引用。以下是独立 C++17 文件,未编译、未运行,不和下方原容器实验合并:
// Proposed C++17 teaching file; NOT COMPILED/RUN in this review.
#include <algorithm>
#include <cassert>
#include <vector>
int main() {
std::vector<int> values{10,20,30};
const auto it = std::find(values.begin(), values.end(), 20);
assert(it != values.end() && *it == 20);
} // no modification while retaining this iterator
操作能力有层次:输入/输出关注读/写;前向支持多遍前进,双向再支持后退;随机访问还能常数时间按距离跳转,连续迭代器另加元素地址连续的保证。不是每一种迭代器都能做所有这些操作,可写性也要另看类型。下面只比较普通 int 数组、vector<int> 与 list<int>:
| 遍历位置 | 可用的移动能力 | 地址与表示前提 |
|---|---|---|
| 数组里的 int* | 在同一有效数组范围内可 ++ / --、按距离跳转与求差;不能越界解引用。 | 裸指针满足适当要求时本身可作迭代器。 |
| vector<int>::iterator | 随机访问,可用 it+n;普通 vector 的元素连续。 | 迭代器类型由实现决定,不要求就是 int*。 |
| list<int>::iterator | 双向,支持 ++ / --;不支持 it+n。逐步走 n 个位置通常需要线性步数。 | 逻辑相邻元素没有连续存储保证,++ 不能理解为通用的地址加 sizeof(int)。 |
这里的 vector/list 移动能力可用于本章 C++17 语境;C++20 起的 contiguous_iterator 概念把连续地址关系正式表达为可约束的要求,普通 vector 的迭代器满足它,但仍不等于“迭代器类型必须是指针”。本比较不包含 vector<bool>,也不扩展全部 traits 或算法要求。
“支持某操作”与“此刻仍有效”是两件事。下方 vector/list 失效表仍按具体容器与修改操作判断:重分配后,保存的 vector 指针和迭代器都不能继续使用;list 的稳定性也不保护被删除的元素。不能用裸指针形式、迭代器大小或“能编译”来绕过范围与寿命要求,旧 end 也须按原表重新取得。
依据:当前公开草案迭代器要求、能力概念、连续迭代器、vector与list。这里只补定义与现有借用小例的读法,未新增运行或性能结论。
| vector 操作 | size / 元素生命周期 | capacity / 借用 |
|---|---|---|
| reserve(n) | 不增加元素,不改变 size | n 大于原 capacity 才重新分配;随后 capacity 至少 n |
| resize(n) | 增加时构造新元素,减少时销毁末尾元素;本例 int 新元素为 0 | 增长超过 capacity 才重新分配;缩小不要求释放存储 |
| shrink_to_fit() | 不改 size | 缩减容量的非强制请求,不能断言 capacity 恰好等于 size;若重新分配,借用全部失效 |
| push_back / emplace_back | 都增加一个元素;前者接收对象,后者用参数直接构造元素 | 容量不够仍会重分配并迁移旧元素,emplace 不豁免 |
下面预留四个 Item 的空间:push 左值复制一次,emplace_back(2) 直接构造,push 临时 Item 移动一次。因此断言 copies=1、moves=1 仅适用于此处无重分配、构造函数明确计数的序列,不能推出 emplace 永远更快。数值 capacity 的增长倍数也不是语言保证。
#include <cassert>
#include <cstdint>
#include <iostream>
#include <iterator>
#include <list>
#include <vector>
struct Item {
inline static int copies=0, moves=0;
int value;
explicit Item(int v):value(v) {}
Item(const Item& o):value(o.value) { ++copies; }
Item(Item&& o) noexcept:value(o.value) { ++moves; }
};
int main() {
std::vector<int> v{10,20,30};
v.reserve(8); assert(v.size()==3 && v.capacity()>=8);
auto first=v.begin(); const int* p=v.data();
v.push_back(40); // within capacity: existing element handles remain valid
assert(*first==10 && *p==10); // old end() would be invalid
v.resize(6); assert(v.size()==6 && v[4]==0 && v[5]==0);
for(auto it=v.begin(); it!=v.end();) {
if(*it==20) it=v.erase(it); else ++it;
}
const std::size_t saved_index=0;
const auto old_address=reinterpret_cast<std::uintptr_t>(v.data());
const auto old_capacity=v.capacity();
v.reserve(old_capacity+1); // guaranteed to reallocate, old p/first must not be used
assert(v.capacity()>=old_capacity+1 && v[saved_index]==10);
const auto new_address=reinterpret_cast<std::uintptr_t>(v.data());
std::cout << "capacity grew=" << (v.capacity()>old_capacity)
<< " addresses=" << old_address << ',' << new_address << '\n';
v.shrink_to_fit(); assert(v.capacity()>=v.size()); // request, not exact guarantee
std::vector<Item> items; items.reserve(4);
Item a(1); items.push_back(a); items.emplace_back(2); items.push_back(Item(3));
assert(Item::copies==1 && Item::moves==1); // no reallocation in this controlled example
std::list<int> nodes{1,2,3}; auto middle=std::next(nodes.begin());
nodes.insert(nodes.begin(),0); assert(*middle==2);
auto next=nodes.erase(middle); assert(*next==3); // middle is erased: do not reuse it
std::cout << "copies=" << Item::copies << " moves=" << Item::moves << '\n';
}
| 操作(普通 vector<T> / list<T>) | 失效规则 |
|---|---|
| vector 发生重新分配 | 所有元素引用、指针、迭代器及旧 end() 失效 |
| vector 插入,未重新分配 | 插入点之前的元素借用有效;插入点及之后的借用和旧 end() 失效。尾插保留已有元素借用,却不保留旧 end() |
| vector erase | 删除点及之后的引用/指针/迭代器与旧 end() 失效;此前的保留 |
| list 插入 / 删除 | 插入不使已有元素借用失效;删除只使被删元素借用失效,其他元素和 end() 保留 |
表只讨论这些操作,不扩展到 swap/splice、容器被销毁、vector<bool> 特化等情形。vector 是连续存储并支持随机访问;随机访问能力本身并不等于连续存储(例如 deque),list 两者都没有。vector 中间插删要移动后续元素,却常有较好的局部性;list 在已知位置迭代器时可常数复杂度插删,但先找位置通常仍是线性遍历,还要支付节点链接、分配及缓存访问成本,不能推出 list 插删总更快。
deque 的标准语义是随机访问,首尾单元素插入/删除为常数复杂度,中间操作通常为线性;它不承诺元素整体连续。libstdc++ 15.2.0 的一种实现用块指针表指向数组块,首尾迭代器记录边界,迭代器负责跨块跳转:既不是连续 vector,也不是每个元素一个链表节点。块大小、对象大小和增长策略不能背成标准通则;元素地址暂时稳定也不代表迭代器永远有效,仍须按具体修改操作查失效规则。
若要按键选容器,map 按比较器有序,键查找为对数复杂度,适合有序遍历或范围需求;标准不强制它采用红黑树。unordered_map 用哈希桶,合适点查负载下平均常数、最坏线性,哈希与相等判断须相容。键比较/哈希成本、碰撞、负载和内存都影响取舍,不能从 O(1) 推出必然更快;rehash 会使迭代器失效,却不因此使元素指针/引用失效,擦除仍使被擦元素的借用失效。依据:C++17 有序与无序关联容器。
安全改写有两个落点:erase 循环接住它返回的下一个迭代器;重分配前只保留逻辑索引,之后从新容器重新取得引用。索引也不是稳定身份,若插删改变了逻辑位置,还须更新索引或改用显式 ID。示例把旧地址提前转成整数用于显示,重分配后既不解引用、比较也不递增旧指针/迭代器;地址数字和增长策略不作固定输出断言。
依据 C++17 草案:vector 容量、vector 插删、list 插删。以上是标准库的独立编译验证,没有编译 PyTorch 扩展,也不是跨平台性能测量。
可选深入:数组、字符指针与 string_view 的长度从哪来?
借用要同时交代范围与寿命
数组和指针是不同类型。数组在许多表达式中会退化为首元素指针,函数参数写 T a[] 也会调整为 T*,长度不会自动随它传入;sizeof 数组拿到整个数组大小,sizeof 指针拿到指针对象大小,两者碰巧相等也不能说明类型相同。sizeof 不会在这里触发数组退化,单位是 C++ 字节。
#include <cassert>
#include <cstddef>
#include <cstring>
#include <iostream>
#include <type_traits>
std::size_t pointer_size(const int* p) { return sizeof(p); }
int main() {
int a[3]{1,2,3}; const int* p=a;
static_assert(sizeof(a)==3*sizeof(int));
static_assert(!std::is_same_v<decltype(a),decltype(p)>);
assert(pointer_size(a)==sizeof(const int*));
char text[]="ab";
assert(sizeof(text)==3 && std::strlen(text)==2);
char raw[2]{'a','b'}; // no NUL: never pass raw to strlen
assert(sizeof(raw)==2);
std::cout << "array bytes=" << sizeof(a) << " pointer bytes=" << sizeof(p) << '\n';
}
strlen 扫到首个 NUL 才停,前提是指针指向有效且存在终止符的字符序列;没有终止符的 raw 不得交给它。string_view 保存指针和长度,借用而不拥有字符,子视图末端不要求 NUL;data() 不能直接当成任意 C 字符串参数。给出显式长度可避免为找长度而扫描,但视图内容比较仍可能线性;不能从名字推出一定比字符指针更快。
复制也要说明范围:memcpy(dst, src, count) 与 memmove(dst, src, count) 按 count 字节复制,后者允许源、目标范围重叠;strcpy(dst, src) 复制到源的首个 NUL,连终止符一起复制。memcpy/strcpy 的重叠用法不合法,memmove 允许重叠也不等于允许越界:源必须有效、目标必须有足够容量,字符串源还须正确终止。非平凡对象的所有权与构造/拷贝语义不能用这些字节复制替代;上面的字符缓冲区也不因此自动安全。
#include <cassert>
#include <string>
#include <string_view>
int main() {
std::string owner="abc";
std::string_view prefix(owner.data(),2);
assert(prefix.size()==2 && prefix=="ab");
assert(owner[2]=='c'); // prefix.data()[2] is not NUL: not a C string
char raw[2]{'x','y'};
std::string_view explicit_length(raw,2); // no scanning for NUL
assert(explicit_length=="xy");
// No return of a view into a local string; no use after owner's reallocation.
}
本例 owner 与 raw 在使用视图时都存活且未重分配;若返回局部 string 的视图,或 owner 销毁/扩容后继续访问,视图不会替你延长寿命。需要所有权就复制成 string,或在接口上约束调用者寿命。依据:数组退化、sizeof、string_view。
🚦 对照:Python 遇到同一种情况会拦住你
Python 不是没有这个问题,是它加了一道锁:只要还有人在看着某块缓冲区,就不许把它挪走。
# c02_buffer.py
buf = bytearray(b"hello")
mv = memoryview(buf) # ⭐ 有人在看着这块内存了
try:
buf.extend(b"world") # 会导致重新分配 —— 正是上面 C++ 那个实验干的事
except BufferError as e:
print("BufferError:", e)
mv.release() # 看完了,松手
buf.extend(b"world")
print("release 之后再 extend 就成功了:", bytes(buf))
实跑输出:
要点
BufferError: Existing exports of data: object cannot be re-sized
mv.release() 之后再 extend 就成功了: b'helloworld'
⭐ 同样是「有人指着我,而我想换个地方」,Python 抛了一个能看见的异常,C++ 打印了 618801184 然后正常退出。 这一条差别,就是你为什么必须自己去读那些 const& 和 unique_ptr。
🧩 八、⭐ 于是 Tensor 长成了一个「把手」
把前面几节合起来,能解释一个你天天在用、但可能没想过为什么的现象:PyTorch 里 b = a 从来不复制数据。
在 C++ 那一侧,at::Tensor 不是一个装着数据的大对象,它是一个只有一个指针那么大的把手,真正的数据挂在它指向的那个实现对象上。用标准库的 shared_ptr 可以把这个形状完整复现出来:
// c02_handle.cpp
// g++ -O2 -std=c++17 c02_handle.cpp -o c02_handle
#include <cstdio>
#include <vector>
#include <string>
#include <memory>
// 真正装数据的那个东西
struct Impl {
std::vector<float> data;
explicit Impl(size_t n) : data(n, 1.0f) { std::printf(" Impl(%zu) 出生\n", n); }
~Impl() { std::printf(" Impl 死亡\n"); }
};
// 外面这层只是一个「把手」:里面就一个指针
struct Handle {
std::shared_ptr<Impl> impl;
explicit Handle(size_t n) : impl(std::make_shared<Impl>(n)) {}
size_t size() const { return impl->data.size(); }
long owners() const { return impl.use_count(); }
};
int main() {
std::printf("sizeof(std::vector<float>) = %zu 字节\n", sizeof(std::vector<float>));
std::printf("sizeof(std::string) = %zu 字节\n", sizeof(std::string));
std::printf("sizeof(std::shared_ptr<Impl>) = %zu 字节\n", sizeof(std::shared_ptr<Impl>));
std::printf("sizeof(std::unique_ptr<Impl>) = %zu 字节\n", sizeof(std::unique_ptr<Impl>));
std::printf("sizeof(Handle) = %zu 字节 ⭐ 和里面装多少数据无关\n\n",
sizeof(Handle));
Handle a(1'000'000); // 100 万个 float
std::printf("a 有 %zu 个 float,持有者 %ld\n", a.size(), a.owners());
Handle b = a; // ⭐ 拷贝「把手」,不拷贝那 100 万个 float
std::printf("b = a 之后,持有者 %ld,b 也有 %zu 个\n", b.owners(), b.size());
std::printf("a 和 b 指着同一块数据吗: %s\n",
a.impl->data.data() == b.impl->data.data() ? "是" : "否");
std::printf("主函数结束 ↓\n");
return 0;
}
实跑输出:
算一算
sizeof(std::vector<float>) = 24 字节
sizeof(std::string) = 32 字节
sizeof(std::shared_ptr<Impl>) = 16 字节
sizeof(std::unique_ptr<Impl>) = 8 字节
sizeof(Handle) = 16 字节 ⭐ 和里面装多少数据无关
Impl(1000000) 出生
a 有 1000000 个 float,持有者 1
b = a 之后,持有者 2,b 也有 1000000 个
a 和 b 指着同一块数据吗: 是
主函数结束 ↓
Impl 死亡
⭐ Handle 只有 16 字节,里面装 100 万个 float 也还是 16 字节。 而 b = a 之后持有者变成 2、两边 data() 是同一个地址、Impl 只死了一次 —— 这正是第二节那个「C++ 的 = 默认复制」的例外形状:复制的确发生了,只不过复制的是把手,不是数据。
⚠️ 注意这不是语言的例外,是设计者主动选的:Handle 里唯一的成员是 shared_ptr,而 shared_ptr 的拷贝构造被定义成「计数 +1」。默认规则没变,是这个类的成员选择让「复制它」变得很便宜。
Python 那一侧看得到同一件事:
# c02_torch_ptr.py
import torch
x = torch.ones(1000)
y = x
z = x.clone()
print("y = x -> data_ptr 相同:", x.data_ptr() == y.data_ptr())
print("z = clone-> data_ptr 相同:", x.data_ptr() == z.data_ptr())
实跑输出(torch 2.13.0+cpu):
关键信息
⭐ 于是「显存为什么没释放」这类问题有了 C++ 侧的解释:del x 只是让 Python 少一个名字;底下那块显存要等持有者计数归零才真的还回去,而计数里可能还有别人 —— 一个还没被回收的中间结果、一个存进 list 的张量、一段计算图。⚠️ 具体怎么省显存不在这一章,AI 基础设施 09 有完整的账。
🔗 这一章连到哪里
| 相关的地方 | 为什么 |
|---|---|
| 《Python 会咬你的地方》01 | 三方分工的第一块:「名字绑到对象」。b = a 之后 a is b 为真是那边的正题,本章第一节只是引用它来划界 |
| 《NumPy 与向量化思维》04 | 三方分工的第二块:「缓冲区被共享」。y.base is x 为什么成立、什么时候是视图什么时候是拷贝,全在那边 |
| 01 章 | 那一章第五节最后一个坑写着「C++ 存了指向 Python 对象内存的指针,而 Python 那边已经把它回收了 —— 谁负责释放是 02 章的正题」,⭐ 第七节就是那句话的兑现;第五节还解释了 gil_scoped_release 为什么抛异常也能还锁 |
| 03 章 | 第六节说 shared_ptr 的原子计数「多线程下会真的争抢缓存行」—— 那件事的代价在下一章量出来 |
| AI 基础设施 09 | 第八节说显存要等持有者计数归零;怎么让它归零、能省多少是那一章的账,本章不重算 |
| 《PyTorch 这个框架本身》 | state_dict、detach、计算图什么时候放手,是 Python 接口那一侧的事 |
✅ 检查点
- 「名字绑到对象」「缓冲区被共享」「谁负责释放」分别归哪一章?本章管哪一个?
- Python 和 C++ 的
b = a默认行为分别是什么?从 Python 带过来的直觉会造成哪两种相反的错? c02_copy.cpp里,传值、传const&、传值+std::move三种写法各触发了什么?「原对象现在有 0 个」这句话说明了什么?- 5000 个 78 KB 的 vector,拷贝进容器和移动进容器实跑各是多少毫秒?移动那一栏为什么基本不随数据量增长?
- 为什么正文最后没有拿「传
const&」那一组做对照? std::move在运行时做了什么?被 move 走的对象之后只允许对它做哪两件事?- RAII 是什么?
c02_raii.cpp抛异常那一路,哪一行输出证明了它有效?C++ 为什么不需要finally? T*/T&/unique_ptr/shared_ptr/weak_ptr各自在声明「谁负责释放」的什么答案?weak_ptr最常用来解决什么问题?- 历史 c02_dangle.cpp 的旧地址读数与退出码能否预测下一次?修正版为什么注释旧指针解引用,并在重分配后重新获取借用?
- 同样是「有人指着我而我想换地方」,Python 的
memoryview+bytearray会发生什么? sizeof(Handle)是多少字节?为什么它和里面装 100 万个 float 无关?这解释了 PyTorch 里的哪个现象?
👀 答案
- 「名字绑到对象」 → 《Python 会咬你的地方》01;「缓冲区被共享」 → 《NumPy 与向量化思维》04;「谁负责释放」 → 本章。前两块 Python 都替你处理了,所以你从来没被问过第三个问题。
- Python 的
b = a是给同一个对象再挂一个名字(a is b为真,改b就是改a);C++ 的b = a是把a整个复制一份(两份互不相干)。两种相反的错:以为不会拷贝的地方悄悄拷贝了一整个矩阵(性能问题),以为会跟着变的地方根本没变(正确性问题)。 - 传值 → 拷贝构造(那 3 个 double 被逐个复制,函数结束时副本单独析构);传
const Loud&→ 一次拷贝都没有,全程只有一次构造一次析构;传值+std::move→ 移动构造。「原对象现在有 0 个」说明数据被搬走了、源对象空了。 - 拷贝 264.02 / 280.50 / 300.58 ms,移动 0.02 ms(三次都是),倍数 16197x / 17104x / 18107x。移动只搬 3 个指针(起点、终点、容量上限),跟里面装 1 万个还是 1 亿个 double 无关;拷贝要真的分配 381 MB 再逐字节复制。
- 因为编译器在
-O2下把那个调用整个优化没了,量出来是 0.00 ms,算出的倍数是几万到几百万,纯属噪声。换成的对照里两边都真的把东西放进了容器,只差「要不要复制」这一点。 - 运行时什么都不做 —— 它只是一个类型转换,把
x标记成「可以被掏空」,好让编译器挑中移动版本的重载。真正搬东西的是移动构造/移动赋值。之后只允许:重新赋值,或者让它析构。读它的内容是「有效但未指定」。 - RAII = 把「要还回去的东西」包成对象,让析构函数去还;对象离开大括号时析构一定执行。抛异常那一路,「正常干完」没打印但「还回 锁」打印了,而且在
catch接住之前。不需要finally,是因为析构函数已经覆盖了它的用途。 T*:代码里看不出来,文档说了算;T&:不是我负责,借来看看;unique_ptr:我,而且只有我,不能拷贝只能move;shared_ptr:最后一个走的人关灯;weak_ptr:不是我,盯着但不延长它的命。weak_ptr最常用来打破循环引用(两个shared_ptr互指,计数永远归不了零就泄漏)。- 618801184 / -283301856 / -1883166688,三次全不一样;退出码全是 0,一次都没崩。所以未定义行为的样子是:没有异常、没有 traceback、时好时坏、崩的地方和错的地方无关(可能在几百行之前)。
- Python 会抛
BufferError: Existing exports of data: object cannot be re-sized—— 只要还有人在看着这块缓冲区就不许挪。mv.release()之后同样的extend就成功了。同一种情况,Python 抛了个看得见的异常,C++ 打印了 618801184 然后正常退出。 - 16 字节,因为它唯一的成员是一个
shared_ptr(sizeof也是 16),数据挂在它指向的实现对象上。这解释了 PyTorch 里b = a从不复制数据:实跑中y = x之后data_ptr()相同、z = x.clone()之后不同。也解释了del x之后显存可能没还 —— 要等持有者计数归零。
本节回顾
⚡ 走神救援
🧭 同一个问题被切成三块,这一章只管第三块:「名字绑到对象」归 Python 板块、「缓冲区被共享」归 NumPy 板块、⭐ 「谁负责释放」是本章。⭐ 前两块 Python 都替你答了——它内置引用计数,而 C++ 没有,所以「什么时候释放」必须写在代码里。
⚠️ 第一个反直觉:C++ 的
=默认是复制,和 Python 正好反着。 ⭐ 代价的形状是:拷贝的耗时随数据量走,移动几乎恒定为零——移动只搬几个指针,与数据量无关。 ⚠️ 诚实记录:其中一组被编译器优化成了 0,倍数纯属噪声,所以对照换了一组。🔑 ⭐ 最实用的一张表是「把
&当声明读」:const T&是「借我看看,不改也不负责释放」、T&是「借我用,我会改」、T是「给我一份」、T&&是「只收你不要了的」。⭐std::move运行时什么都不做——它只是个类型转换,一句「我之后不用了」的承诺。⭐ RAII 是靠作用域还东西:实跑抛异常那一路,「正常干完」没打印,而「还回锁」打印了、且在 catch 之前——⭐ 这就是上一章那个释放锁的原理,也是 C++ 不需要 finally 的原因。
💀 这一章真正的理由是「不崩」:拿到内部指针之后让容器扩容,旧指针读出来的是垃圾——三次全不同,而退出码都是 0。⭐⭐ 未定义行为的样子就是:没异常、没 traceback、时好时坏、崩的地方和错的地方无关。 ⭐ 同一种情况 Python 会拦你,抛的是一句明确的「还有人在用这块内存,不能改大小」。
⭐ 最后一节的回报:那个把手的大小和它里面装了多少数据完全无关——
Tensor就是这个形状。
下一节 👉 03-cache与数据布局.md