3.5 借用检查不变量 on 编程那些事儿

3.5.1 生命周期与借用：抽象规则

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/leveraging-the-type-system/borrow-checker-invariants/generalizing-ownership.html

3.5.1 生命周期与借用：抽象规则

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
// 内部数据类型，用来有东西可持有。
pub struct Internal;
// 「外部」数据。
pub struct Data(Internal);

fn shared_use(value: &Data) -> &Internal {
 &value.0
}
fn exclusive_use(value: &mut Data) -> &mut Internal {
 &mut value.0
}
fn deny_future_use(value: Data) {}

fn demo_exclusive() {
 let mut value = Data(Internal);
 let shared = shared_use(&value);
 // let exclusive = exclusive_use(&mut value); // ❌🔨
 let shared_again = shared;
}

fn demo_denied() {
 let value = Data(Internal);
 deny_future_use(value);
 // let shared = shared_use(&value); // ❌🔨
}

# fn main() {}

本例将借用检查器规则从引用重新框定为非内存安全场景下的语义含义。

3.5.2 一次性值

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/leveraging-the-type-system/borrow-checker-invariants/single-use-values.html

3.5.2 一次性值

有时我们想要只能使用一次的值。密码学中的一个关键例子是「Nonce」。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
pub struct Key(/* specifics omitted */);

/// 适合密码学用途的一次性数字。
pub struct Nonce(u32);

/// 密码学上可靠的随机生成函数。
pub fn new_nonce() -> Nonce {
 Nonce(4) // chosen by a fair dice roll, https://xkcd.com/221/
}

/// 消费 nonce，但不消费 key 或 data。
pub fn encrypt(nonce: Nonce, key: &Key, data: &[u8]) {}

fn main() {
 let nonce = new_nonce();
 let data_1: [u8; 4] = [1, 2, 3, 4];
 let data_2: [u8; 4] = [4, 3, 2, 1];
 let key = Key(/* specifics omitted */);

 // key 和 data 可以复用、复制等，但 nonce 不行。
 encrypt(nonce, &key, &data_1);
 // encrypt(nonce, &key, &data_2); // 🛠️❌
}

问题：我们如何保证一个值只被使用一次？

3.5.3 互斥引用 / 「别名 XOR 可变」

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/leveraging-the-type-system/borrow-checker-invariants/aliasing-xor-mutability.html

3.5.3 互斥引用 / 「别名 XOR 可变」

我们可以利用 &T 与 &mut T 引用的互斥性，防止数据在就绪前被使用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
pub struct QueryResult;
pub struct DatabaseConnection {/* fields omitted */}

impl DatabaseConnection {
 pub fn new() -> Self {
 Self {}
 }
 pub fn results(&self) -> &[QueryResult] {
 &[] // 伪造结果
 }
}

pub struct Transaction<'a> {
 connection: &'a mut DatabaseConnection,
}

impl<'a> Transaction<'a> {
 pub fn new(connection: &'a mut DatabaseConnection) -> Self {
 Self { connection }
 }
 pub fn query(&mut self, _query: &str) {
 // 发送查询，但不等待结果。
 }
 pub fn commit(self) {
 // 完成执行事务并取回结果。
 }
}

fn main() {
 let mut db = DatabaseConnection::new();

 // 事务 `tx` 可变地借用 `db`。
 let mut tx = Transaction::new(&mut db);
 tx.query("SELECT * FROM users");

 // 这不会编译，因为 `db` 已被 `tx` 可变借用。
 // let results = db.results(); // ❌🔨

 // 对 `db` 的借用在 `tx` 被 `commit()` 消费时结束。
 tx.commit();

 // 现在可以再次借用 `db`。
 let results = db.results();
}

动机：在此数据库 API 中，查询被启动以异步执行，结果仅在整个事务完成后才可用。

3.5.4 PhantomData 与类型

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/leveraging-the-type-system/borrow-checker-invariants/phantomdata-01-types.html

3.5.4 PhantomData 与类型

Newtype 模式有时会与 DRY 原则冲突，我们该如何解决？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
pub struct UserId(u64);
impl ChatUser for UserId { /* ... */ }

pub struct PatronId(u64);
impl ChatUser for PatronId { /* ... */ }

pub struct ModeratorId(u64);
impl ChatUser for ModeratorId { /* ... */ }
impl ChatModerator for ModeratorId { /* ... */ }

pub struct AdminId(u64);
impl ChatUser for AdminId { /* ... */ }
impl ChatModerator for AdminId { /* ... */ }
impl ChatAdmin for AdminId { /* ... */ }

// 以此类推 ...
fn main() {}

问题：我们想用 newtype 模式区分权限，却不得不为相同数据一遍又一遍地实现相同的 trait。

3.5.5 PhantomData 与类型（实现）

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/leveraging-the-type-system/borrow-checker-invariants/phantomdata-02-types-implemented.html

3.5.5 PhantomData 与类型（实现）

通过添加类型参数来解决上一页的问题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
// use std::marker::PhantomData;

pub struct ChatId<T> { id: u64, tag: T }

pub struct UserTag;
pub struct AdminTag;

pub trait ChatUser {/* ... */}
pub trait ChatAdmin {/* ... */}

impl ChatUser for UserTag {/* ... */}
impl ChatUser for AdminTag {/* ... */} // 管理员也是用户
impl ChatAdmin for AdminTag {/* ... */}

// impl <T> Debug for UserTag<T> {/* ... */}
// impl <T> PartialEq for UserTag<T> {/* ... */}
// impl <T> Eq for UserTag<T> {/* ... */}
// 以此类推 ...

impl <T: ChatUser> ChatId<T> {/* 用户及以上的全部功能 */}
impl <T: ChatAdmin> ChatId<T> {/* 仅管理员的全部功能 */}

fn main() {}

这里我们使用类型参数，并将权限关在实现不同权限 trait 的「标签」类型后面。

3.5.6 PhantomData：外部资源的生命周期

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/leveraging-the-type-system/borrow-checker-invariants/phantomdata-03-lifetimes.html

3.5.6 PhantomData：外部资源的生命周期

外部资源的不变量常常与我们能用生命周期规则做的事相匹配。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
// use std::marker::PhantomData;

/// 直接到 C 中数据库库的 FFI。
/// 我们得到的就是这样的 API，无法对其施加影响。
mod ffi {
 pub type DatabaseHandle = u8; // 同时最多打开 255 个数据库

 fn database_open(name: *const std::os::raw::c_char) -> DatabaseHandle {
 unimplemented!()
 }
 // ... 等等。
}

struct DatabaseConnection(ffi::DatabaseHandle);

struct Transaction<'a>(&'a mut DatabaseConnection);

impl DatabaseConnection {
 fn new_transaction(&mut self) -> Transaction<'_> {
 Transaction(self)
 }
}

fn main() {}

回想别名 XOR 可变示例中的事务 API。

3.5.7 PhantomData：OwnedFd 与 BorrowedFd

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/leveraging-the-type-system/borrow-checker-invariants/phantomdata-04-borrowedfd.html

3.5.7 PhantomData：OwnedFd 与 BorrowedFd

BorrowedFd 是 PhantomData 实际应用的典型例子。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::marker::PhantomData;
use std::os::raw::c_int;

mod libc_ffi {
 use std::os::raw::{c_char, c_int};
 pub unsafe fn open(path: *const c_char, oflag: c_int) -> c_int {
 3
 }
 pub unsafe fn close(fd: c_int) {}
}

struct OwnedFd {
 fd: c_int,
}

impl OwnedFd {
 fn try_from_fd(fd: c_int) -> Option<Self> {
 if fd < 0 {
 return None;
 }
 Some(OwnedFd { fd })
 }

 fn as_fd<'a>(&'a self) -> BorrowedFd<'a> {
 BorrowedFd { fd: self.fd, _phantom: PhantomData }
 }
}

impl Drop for OwnedFd {
 fn drop(&mut self) {
 unsafe { libc_ffi::close(self.fd) };
 }
}

struct BorrowedFd<'a> {
 fd: c_int,
 _phantom: PhantomData<&'a ()>,
}

fn main() {
 // 用原始系统调用以只写和创建权限创建文件。
 let fd = unsafe { libc_ffi::open(c"c_str.txt".as_ptr(), 065) };
 // 将整数文件描述符的所有权交给 `OwnedFd`。
 // `OwnedFd::drop()` 关闭文件描述符。
 let owned_fd =
 OwnedFd::try_from_fd(fd).expect("Could not open file with syscall!");

 // 从 `OwnedFd` 创建 `BorrowedFd`。
 // `BorrowedFd::drop()` 不关闭文件，因为它不拥有它！
 let borrowed_fd: BorrowedFd<'_> = owned_fd.as_fd();
 // std::mem::drop(owned_fd); // ❌🔨
 std::mem::drop(borrowed_fd);
 let second_borrowed = owned_fd.as_fd();
 // owned_fd 将在此处被 drop，文件将被关闭。
}

文件描述符表示特定进程对文件的访问。