🏠 总目录📚 本教程 02 · 值语义与所有权 ← →
📑 本页目录(点开跳转)

02 · 值语义与所有权:谁负责释放

C++ / 02 · 值与寿命

谁持有资源,离开作用域时谁负责收尾?

先分清复制、借用和移动,再看 RAII 守卫如何把释放责任绑定在作用域上。

读完可沿原代码辨认释放责任,并在继续借用前核对被借对象的寿命。

RAII 示例:责任跟着守卫的作用域走

  1. 进入作用域,构造守卫并取得资源
  2. 在作用域内使用资源,守卫仍负责收尾
  3. 正常离开或按规则异常展开,守卫析构并释放
只画正文 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)

实跑输出:

操作步骤

  1. Python: a = [1, 2, 3, 4] b = [1, 2, 3, 4] 同一个对象吗: True id 相同吗: True
  2. NumPy : x = [99 2 3 4] y = [99 2] 同一个对象吗: False y 借的是谁的内存: True
  3. refcount 一开始: 1
  4. 多挂一个名字后: 2
  5. 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):

操作步骤

① 传值:
[构造] a (3 个 double)
[拷贝构造] a-拷贝 <- a ⚠️ 复制了 3 个 double
-> 函数里拿到 a-拷贝
[析构] a-拷贝
[析构] a
② 传 const 引用:
[构造] b (3 个 double)
-> 函数里拿到 b(没拷贝)
[析构] b
③ 传值 + std::move:
[构造] c (3 个 double)
[移动构造] c ⭐ 只搬了指针,原对象现在有 0 个
-> 函数里拿到 c
[析构] c
[析构] (已被搬空)

⭐ 三件事一次看清:

📋 两边的默认值对照:

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;
}

实跑输出:

操作步骤

  1. 正常返回:
  2. 拿到 锁
  3. 干活中…
  4. 正常干完
  5. 还回 锁
  6. 抛异常:
  7. 拿到 锁
  8. 干活中…
  9. 还回 锁
  10. 接住了:中途炸了
  11. unique_ptr(唯一所有者):
  12. Node1 出生
  13. p 现在是空的吗: 是
  14. q 指着 Node1
  15. Node1 死亡
  16. shared_ptr(大家共有,最后一个走的关灯):
  17. Node2 出生
  18. 持有者 1 个
  19. 多了一个 b,持有者 2 个
  20. b 走了,持有者 1 个(Node2 还活着)
  21. Node2 死亡
  22. 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> ❌ 不是我 ✅ 能 「我盯着它,但不延长它的命,用之前得先问它还在不在」

⭐ 读源码时把这一列当成注释读,比看真注释可靠 —— 注释会过期,类型不会,编译器会强制它成立。三条最有信息量的:

⚠️ 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)不增加元素,不改变 sizen 大于原 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):

关键信息

y = x -> data_ptr 相同: True
z = clone-> data_ptr 相同: False

⭐ 于是「显存为什么没释放」这类问题有了 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 接口那一侧的事

✅ 检查点

  1. 「名字绑到对象」「缓冲区被共享」「谁负责释放」分别归哪一章?本章管哪一个?
  2. Python 和 C++ 的 b = a 默认行为分别是什么?从 Python 带过来的直觉会造成哪两种相反的错?
  3. c02_copy.cpp 里,传值、传 const&、传值+std::move 三种写法各触发了什么?「原对象现在有 0 个」这句话说明了什么?
  4. 5000 个 78 KB 的 vector,拷贝进容器和移动进容器实跑各是多少毫秒?移动那一栏为什么基本不随数据量增长?
  5. 为什么正文最后没有拿「传 const&」那一组做对照?
  6. std::move 在运行时做了什么?被 move 走的对象之后只允许对它做哪两件事?
  7. RAII 是什么?c02_raii.cpp 抛异常那一路,哪一行输出证明了它有效?C++ 为什么不需要 finally?
  8. T* / T& / unique_ptr / shared_ptr / weak_ptr 各自在声明「谁负责释放」的什么答案?weak_ptr 最常用来解决什么问题?
  9. 历史 c02_dangle.cpp 的旧地址读数与退出码能否预测下一次?修正版为什么注释旧指针解引用,并在重分配后重新获取借用?
  10. 同样是「有人指着我而我想换地方」,Python 的 memoryview + bytearray 会发生什么?
  11. sizeof(Handle) 是多少字节?为什么它和里面装 100 万个 float 无关?这解释了 PyTorch 里的哪个现象?
👀 答案
  1. 「名字绑到对象」 → 《Python 会咬你的地方》01;「缓冲区被共享」 → 《NumPy 与向量化思维》04;「谁负责释放」 → 本章。前两块 Python 都替你处理了,所以你从来没被问过第三个问题。
  2. Python 的 b = a 是给同一个对象再挂一个名字(a is b 为真,改 b 就是改 a);C++ 的 b = a 是把 a 整个复制一份(两份互不相干)。两种相反的错:以为不会拷贝的地方悄悄拷贝了一整个矩阵(性能问题),以为会跟着变的地方根本没变(正确性问题)。
  3. 传值 → 拷贝构造(那 3 个 double 被逐个复制,函数结束时副本单独析构);传 const Loud& → 一次拷贝都没有,全程只有一次构造一次析构;传值+std::move → 移动构造。「原对象现在有 0 个」说明数据被搬走了、源对象空了。
  4. 拷贝 264.02 / 280.50 / 300.58 ms,移动 0.02 ms(三次都是),倍数 16197x / 17104x / 18107x。移动只搬 3 个指针(起点、终点、容量上限),跟里面装 1 万个还是 1 亿个 double 无关;拷贝要真的分配 381 MB 再逐字节复制。
  5. 因为编译器在 -O2 下把那个调用整个优化没了,量出来是 0.00 ms,算出的倍数是几万到几百万,纯属噪声。换成的对照里两边都真的把东西放进了容器,只差「要不要复制」这一点。
  6. 运行时什么都不做 —— 它只是一个类型转换,把 x 标记成「可以被掏空」,好让编译器挑中移动版本的重载。真正搬东西的是移动构造/移动赋值。之后只允许:重新赋值,或者让它析构。读它的内容是「有效但未指定」。
  7. RAII = 把「要还回去的东西」包成对象,让析构函数去还;对象离开大括号时析构一定执行。抛异常那一路,「正常干完」没打印但「还回 锁」打印了,而且在 catch 接住之前。不需要 finally,是因为析构函数已经覆盖了它的用途。
  8. T*:代码里看不出来,文档说了算;T&:不是我负责,借来看看;unique_ptr:我,而且只有我,不能拷贝只能 move;shared_ptr:最后一个走的人关灯;weak_ptr:不是我,盯着但不延长它的命。weak_ptr 最常用来打破循环引用(两个 shared_ptr 互指,计数永远归不了零就泄漏)。
  9. 618801184 / -283301856 / -1883166688,三次全不一样;退出码全是 0,一次都没崩。所以未定义行为的样子是:没有异常、没有 traceback、时好时坏、崩的地方和错的地方无关(可能在几百行之前)。
  10. Python 会抛 BufferError: Existing exports of data: object cannot be re-sized —— 只要还有人在看着这块缓冲区就不许挪。mv.release() 之后同样的 extend 就成功了。同一种情况,Python 抛了个看得见的异常,C++ 打印了 618801184 然后正常退出。
  11. 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

打卡记录保存在你的浏览器里,首页能看到总进度