From a7aa274be34add192eb78c805e776747074486dd Mon Sep 17 00:00:00 2001 From: Yuhang Wu Date: Mon, 13 Jul 2026 15:01:35 +0800 Subject: [PATCH] =?UTF-8?q?feat(part3):=20=E6=B7=BB=E5=8A=A0=E6=89=80?= =?UTF-8?q?=E6=9C=89=E6=9D=83=E7=BB=83=E4=B9=A0=E9=A2=98=E7=AD=94=E6=A1=88?= =?UTF-8?q?=E5=92=8C=E8=AF=A6=E7=BB=86=E8=A7=A3=E6=9E=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 在main.rs中添加了引用相关的代码示例，演示x、y、z三个变量的使用 - 在练习题文档中补充了题目1-1到1-6的正确答案，解释了所有权和借用规则 - 详细分析了题目2-1到2-4关于借用生命周期的问题，提供了正确的代码修复方案 - 解决了悬垂引用(dangling reference)问题，修正了函数返回引用的错误做法 - 完善了字符串操作相关练习的答案，包括count_words、first_and_last等函数实现 - 补充了切片操作练习的完整代码和逻辑说明 - 修正了所有权转移和引用借用的概念性错误，提供了准确的解析 - 更新了Rust所有权系统与其他语言内存管理机制的对比分析 --- part3/src/main.rs | 5 +- part3/所有权关键概念梳理.md | 262 ++++++++++++++++++++++++++++++++++++ part3/所有权练习题.md | 121 ++++++++++++++++- part4/Cargo.lock | 7 + 4 files changed, 387 insertions(+), 8 deletions(-) create mode 100644 part3/所有权关键概念梳理.md create mode 100644 part4/Cargo.lock diff --git a/part3/src/main.rs b/part3/src/main.rs index e7a11a9..239d046 100644 --- a/part3/src/main.rs +++ b/part3/src/main.rs @@ -1,3 +1,6 @@ fn main() { - println!("Hello, world!"); + let x = String::from("hello"); + let y = &x; + let z = &x; + println!("{} {} {}", x, y, z); } diff --git a/part3/所有权关键概念梳理.md b/part3/所有权关键概念梳理.md new file mode 100644 index 0000000..2f1e5ee --- /dev/null +++ b/part3/所有权关键概念梳理.md @@ -0,0 +1,262 @@ +# Rust 所有权关键概念梳理 + +> 基于练习题作答中的误区整理，配合纠正说明。 + +--- + +## 1. 三条核心规则 + +| 规则 | 说明 | +|------|------| +| 每个值有且只有一个**所有者** | 变量绑定 = 所有权 | +| 同一时刻只能有**一个可变引用**，或**任意多个不可变引用** | 读写互斥 | +| 所有者离开作用域，值被 `drop` | RAII 式自动释放 | + +--- + +## 2. Move（所有权转移） + +```rust +let s1 = String::from("hello"); +let s2 = s1; // s1 的所有权移动给 s2 +// println!("{}", s1); // ❌ s1 已失效 +``` + +**常见误区：** 认为 move 之后还能继续用原变量。堆数据（`String`、`Vec`、`Box` 等）的赋值/传参默认是 move，源变量立即失效。 + +--- + +## 3. Copy 类型（自动复制） + +```rust +let x = 42; +let y = x; // i32 实现了 Copy，自动复制 +println!("{}", x); // ✅ x 仍然有效 +``` + +实现了 `Copy` 的类型（`i32`、`bool`、`f64`、`char`、`&T` 等）赋值时会自动复制，不发生 move。 +**注意：** 包含堆数据的类型（`String`、`Vec` 等）**不实现** `Copy`。 + +--- + +## 4. Clone（显式深拷贝） + +```rust +let s1 = String::from("hello"); +let s2 = s1.clone(); // 显式深拷贝，两个变量各自独立 +println!("{} {}", s1, s2); // ✅ +``` + +与 Copy 的区别：clone 是显式的、可能有开销；Copy 是隐式的、按位复制、无开销。 + +--- + +## 5. 引用（Borrow）—— 不转移所有权 ⚠️ 关键 + +> **`&` 就是借用，从！不！转！移！所！有！权！** + +```rust +let x = String::from("hello"); +let y = &x; // y 只是借用了 x，x 仍然是所有者 +println!("{}", x); // ✅ x 仍然可用 +println!("{}", y); // ✅ y 可以通过引用读取 +``` + +**原答误以为** `let y = &x` 会转移所有权 → **完全错误**。与下面对比： + +```rust +let x = String::from("hello"); +let y = x; // ← 没有 &，这是 move！x 失效 +let z = &x; // ← 有 &，引用，x 仍在 +``` + +| 写法 | 行为 | +|------|------| +| `let y = x;` | move，所有权转移 | +| `let y = &x;` | borrow，借用，x 不动 | +| `let y = x.clone();` | 深拷贝，各自独立 | + +--- + +## 6. 不可变引用（`&T`） + +```rust +let s = String::from("hello"); +let r1 = &s; +let r2 = &s; // ✅ 允许多个不可变引用共存 +println!("{} {} {}", s, r1, r2); // ✅ 全部可用 +``` + +规则：**多个不可变引用可以同时存在**，原值也可以被读取。 + +--- + +## 7. 可变引用（`&mut T`） + +```rust +let mut s = String::from("hello"); +let r1 = &mut s; // 可变引用 +r1.push_str(" world"); +// let r2 = &mut s; // ❌ 同一作用域不能有两个可变引用 +``` + +规则：**同一时刻只能有一个可变引用**。 + +--- + +## 8. 不可变引用与可变引用互斥 ⚠️ 1-6 错误点 + +```rust +let mut s = String::from("hello"); +let r1 = &s; // 不可变借用 +let r2 = &s; // 不可变借用 +let r3 = &mut s; // ❌ 已有不可变借用时，不能创建可变借用 +println!("{} {} {}", r1, r2, r3); +``` + +**原答认为能编译 → 不能。** 不可变和可变引用不能共存于重叠的作用域中。 + +--- + +## 9. NLL（Non-Lexical Lifetimes）—— 3-3 的修复原理 + +Rust 2018+ 引入 NLL：**引用的生命周期结束于它最后一次被使用的语句，而非作用域末尾。** + +```rust +let mut s = String::from("hello"); + +let r1 = &mut s; +r1.push_str(", world"); +println!("{}", r1); // ← r1 最后一次使用，NLL 在此结束其借用 + +let r2 = &mut s; // ✅ r1 已失效，可以创建新的可变引用 +r2.push_str("!"); +println!("{}", r2); +``` + +同一段代码在 `let r1 = &mut s;` 和 `let r2 = &mut s;` 之间如果没有 NLL，按词法作用域会冲突。NLL 使借用更短、更精确。 + +**但 NLL 不破坏规则**：如果 r1 在 r2 创建后仍然被使用（比如 println 在最后），编译仍然失败。 + +--- + +## 10. 悬垂引用（Dangling Reference）—— 3-2 真正原因 + +```rust +fn dangle() -> &String { // ❌ 返回引用 + let s = String::from("hello"); + &s // s 在函数结束时被 drop，引用悬垂 +} +``` + +**原答写"返回值被移动了" → 不准确。** 真正原因：返回的引用指向一个即将被释放的局部变量。Rust 编译期拒绝这种代码。 + +修复： + +```rust +fn dangle() -> String { // ✅ 返回所有权 + let s = String::from("hello"); + s +} +``` + +--- + +## 11. 切片与借用冲突 —— 3-4 + +```rust +let s = String::from("hello world"); +let first = &s[0..5]; // first 是切片引用（不可变借用） +s.clear(); // ❌ clear() 需要 &mut self，与 first 冲突 +println!("{}", first); +``` + +**核心冲突：不可变引用（切片）和可变引用（clear）不能共存。** 修复方法： + +```rust +let s = String::from("hello world"); +let first = &s[0..5]; +println!("first = {}", first); // 先使用 first +let mut s = s; // 重新绑定，first 的借用已结束 +s.clear(); +``` + +--- + +## 12. `str` vs `String` —— 4-4 错误点 + +| 类型 | 说明 | +|------|------| +| `String` | 堆上分配、可增长的字符串。有所有权。`Sized`。 | +| `&str` | 字符串切片引用。借用。`Sized`（引用本身是指针+长度）。 | +| `str` | **动态大小类型（DST）**，编译期大小未知。**不能直接作为参数/变量类型。** | + +```rust +fn consume_and_print(s: str) { } // ❌ str 是 DST +fn consume_and_print(s: String) { } // ✅ 拿走所有权 +fn consume_and_print(s: &str) { } // ✅ 借用（推荐用于只读场景） + +fn append_exclamation(s: &mut str) { } // ❌ str 是 DST +fn append_exclamation(s: &mut String) {} // ✅ 可变引用 +``` + +--- + +## 13. `&str` 是借用，不会转移所有权 —— 5-3 核心纠正 + +```rust +let x = String::from("hello"); +let y = &x; // 不可变引用，x 仍然拥有 String +let z = &x; // 另一个不可变引用 +println!("{} {} {}", x, y, z); // ✅ 全部合法 +``` + +**原答说"所有权被转移给 y 和 z" → 彻底错误。** + +所有权转移只有两种方式： +1. **赋值没有 `&`**：`let y = x;` +2. **传参没有 `&`**：`fn foo(s: String)` + `foo(x);` + +有 `&` 就是借用，不是转移。 + +--- + +## 14. 借用后修改的影响 —— 5-2 输出纠正 + +```rust +let mut s = String::from("rust"); +let r3 = &mut s; +r3.push_str(" is great"); // ⚠️ 通过可变引用修改了 s 的内容 +println!("{}", r3); // "rust is great" +// r3 不再使用 + +let s2 = s; // s 现在是 "rust is great"，移动给 s2 +println!("{}", s2); // "rust is great" +``` + +**原答认为最后输出是 "rust" → 忽视了 r3 对 s 的修改。** + +--- + +## 15. 常见错误速查 + +| 错误类型 | 示例 | 编译器信息 | +|----------|------|-----------| +| use after move | `let y = x; println!("{}", x);` | `E0382: use of moved value` | +| 两个可变引用 | `let r1 = &mut s; let r2 = &mut s;` | `E0499: cannot borrow as mutable more than once` | +| 不可变+可变冲突 | `let r = &s; let rm = &mut s;` | `E0502: cannot borrow as mutable, immutable borrow exists` | +| 悬垂引用 | `fn f() -> &String { &s }` | `E0106: missing lifetime specifier` / `E0515` | +| 返回局部引用 | `fn f() -> &String { &s }` where s is local | 生命周期错误 | +| DST 作参数 | `fn f(s: str) { }` | `E0277: the size is not known at compile time` | + +--- + +## 16. 决策总结 + +| 需求 | 签名 | +|------|------| +| 只读取，原值还要用 | `fn f(s: &str)` 或 `fn f(s: &String)` | +| 只读取，可能存下来 | `fn f(s: &str) -> String` 返回新值 | +| 修改原值 | `fn f(s: &mut String)` | +| 拿走所有权 | `fn f(s: String)` | +| 函数只读 | 优先用 `&str`（比 `&String` 更通用） | diff --git a/part3/所有权练习题.md b/part3/所有权练习题.md index 94a39f4..644b283 100644 --- a/part3/所有权练习题.md +++ b/part3/所有权练习题.md @@ -15,6 +15,7 @@ fn main() { println!("{}", s); } ``` +> 答: 不能 ### 题目 1-2 @@ -25,6 +26,7 @@ fn main() { println!("x = {}, y = {}", x, y); } ``` +> 答: 能 ### 题目 1-3 @@ -35,6 +37,7 @@ fn main() { println!("s = {}, t = {}", s, t); } ``` +> 答: 能 ### 题目 1-4 @@ -46,6 +49,7 @@ fn main() { println!("{} {} {}", s1, s2, s3); } ``` +> 答: 能 ### 题目 1-5 @@ -57,6 +61,7 @@ fn main() { println!("{}, {}", r1, r2); } ``` +> 答: 不能 ### 题目 1-6 @@ -69,6 +74,9 @@ fn main() { println!("{}, {}, {}", r1, r2, r3); } ``` +> **[批注] 原答"能"错误 —— 该代码无法通过编译。** +> r1、r2 是不可变引用，r3 是可变引用。Rust 不允许在已有不可变借用的作用域内再创建可变借用。`println!` 同时使用了三者，借用范围重叠，编译器报错： +> `error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable` --- @@ -89,6 +97,7 @@ fn takes_ownership(s: String) { println!("{}", s); } ``` +> 答: s ### 题目 2-2：借用的生命周期 @@ -103,6 +112,7 @@ fn get_length(s: &String) -> usize { s.len() } ``` +> 答: &s ### 题目 2-3：可变引用 @@ -117,6 +127,7 @@ fn append_world(s: &mut String) { s.push_str(", world!"); } ``` +> 答: mut, &mut s ### 题目 2-4：作用域技巧 @@ -134,6 +145,7 @@ fn main() { println!("{}", r2); } ``` +> 答: &s, &mut s --- @@ -150,6 +162,18 @@ fn main() { print_both(s1, s2); } +fn print_both(a: String, b: String) { + println!("{} and {}", a, b); +} +``` +> **[批注] 原错误分析有误：** 错误原因是 `let s2 = s1;` 将 s1 的所有权移动给了 s2，此后 s1 已失效，不能继续用于 `print_both(s1, s2)`。原答写的修复代码语法也有问题（`fn print_both(a: String, &b: String)` 不是合法签> 名）。正确修复：clone 一份。 +```rust +fn main() { + let s1 = String::from("hello"); + let s2 = s1.clone(); + print_both(s1, s2); +} + fn print_both(a: String, b: String) { println!("{} and {}", a, b); } @@ -168,6 +192,18 @@ fn dangle() -> &String { &s } ``` +> **[批注] 原错误分析不精确。** 真正原因：`dangle()` 返回 `&String`，但引用指向的是函数内的局部变量 `s`。函数结束时 `s` 被释放，返回的引用变成悬垂引用（dangling reference）。Rust 编译器在编译期阻止了这种行为。修复方法：直接返回 `String` 让所有权移出。 +```rust +fn main() { + let s = dangle(); + println!("{}", s); +} + +fn dangle() -> String { + let s = String::from("hello"); + s +} +``` ### 题目 3-3 @@ -182,6 +218,18 @@ fn main() { println!("{}", r2); } ``` +> **[批注] 原分析"同时只能存在一个可变引用"基本正确，但未给出修复代码。** 由于 r1 在 `println!("{}", r1)` 之后不再使用，Rust 的 NLL（Non-Lexical Lifetimes）可在该点结束 r1 的借用。修复：将 println! 移到 r2 创建之前。 +```rust +fn main() { + let mut s = String::from("hello"); + let r1 = &mut s; + r1.push_str(", world"); + println!("{}", r1); // r1 在此之后不再使用，NLL 结束其借用 + let r2 = &mut s; // 此时 r1 已失效，可以创建新的可变引用 + r2.push_str("!"); + println!("{}", r2); +} +``` ### 题目 3-4 @@ -193,6 +241,16 @@ fn main() { println!("first = {}", first); } ``` +> **[批注] 原分析不精确，原修复代码 `let first = s[0..5];` 仍是切片引用，与 `s.clear()` 的 `&mut self` 冲突，同样无法编译。** 真正原因：`first` 是对 `s` 内容的不可变引用，而 `clear()` 需要 `&mut self`（可变引用），两者不能同时存在。正确修复：先使用 first，再 clear。 +```rust +fn main() { + let s = String::from("hello world"); + let first = &s[0..5]; + println!("first = {}", first); // 先使用 first + let mut s = s; // 重新绑定为可变的 + s.clear(); // 此时 first 的借用已结束 +} +``` --- @@ -205,6 +263,7 @@ fn main() { ```rust fn count_words(s: &str) -> usize { // 你的代码 + return s.split_whitespace().count(); } fn main() { @@ -224,6 +283,8 @@ fn main() { ```rust fn first_and_last(s: &str) -> (&str, &str) { // 你的代码 + let words: Vec<&str> = s.split_whitespace().collect(); + return (words[0], words[words.len() - 1]); } fn main() { @@ -243,6 +304,19 @@ fn main() { fn title_case(s: &str) -> String { // 你的代码 // 提示：可以使用 split_whitespace、to_uppercase、to_lowercase、collect 等方法 +> **[批注] 原代码未完成。** 只 collect 了 words 但没有做大小写转换。补全如下： +```rust +fn title_case(s: &str) -> String { + s.split_whitespace() + .map(|word| { + let mut chars = word.chars(); + match chars.next() { + Some(c) => c.to_uppercase().collect::() + &chars.as_str().to_lowercase(), + None => String::new(), + } + }) + .collect::>() + .join(" ") } fn main() { @@ -266,33 +340,33 @@ fn main() { // fn consume_and_print(s: ???) // 2. 拿走所有权，调用后原变量不再使用 // fn append_exclamation(s: ???)// 3. 修改原字符串 -fn capitalize(s: ________) -> String { - let mut result = s.clone(); +fn capitalize(s: &str) -> String { + let mut result = s.to_string(); // &str -> String if let Some(c) = result.get_mut(0..1) { c.make_ascii_uppercase(); } result } -fn consume_and_print(s: ________) { +fn consume_and_print(s: String) { // [批注] 原写了 str，str 是 DST 不能直接作参数 println!("消费了: {}", s); } -fn append_exclamation(s: ________) { +fn append_exclamation(s: &mut String) { // [批注] 原写了 &mut str，应为 &mut String s.push_str("!"); } fn main() { let s = String::from("hello"); - let capitalized = capitalize(________); // 填空：调用 capitalize + let capitalized = capitalize(&s); // 填空：调用 capitalize println!("{}", s); // s 仍可用 - consume_and_print(________); // 填空：调用 consume_and_print，传入 s + consume_and_print(s); // 填空：调用 consume_and_print，传入 s // println!("{}", s); // 若取消注释会报错 let mut t = String::from("hello"); - append_exclamation(________); // 填空：调用 append_exclamation + append_exclamation(&mut t); // 填空：调用 append_exclamation println!("{}", t); // 期望输出：hello! } ``` @@ -306,11 +380,13 @@ fn main() { fn sum_of_first_n(arr: &[i32], n: usize) -> i32 { // 你的代码 // 提示：使用切片 &arr[..n] + return arr[..n].iter().sum(); } // 判断一个切片是否包含目标值 fn contains(arr: &[i32], target: i32) -> bool { // 你的代码 + return arr.contains(&target); } fn main() { @@ -339,6 +415,7 @@ fn main() { println!("first = {}", first); } ``` +> 答: ### 题目 5-2 @@ -364,6 +441,26 @@ fn main() { println!("{}", s2); } ``` +> **[批注] 原答最终输出写错了。** r3 通过 `push_str(" is great")` 修改了 s 的内容，s 此时已经是 `"rust is great"`。之后 s 移动给 s2，s2 也是 `"rust is great"`。 +> +> 正确的逐步分析： +> 1. `let mut s = String::from("rust")` — s 拥有 "rust" +> 2. `let r1 = &s` — 不可变借用，s 仍持有所有权 +> 3. `let r2 = &s` — 第二个不可变借用（允许多个） +> 4. `println!("{} and {}", r1, r2)` — 输出 `rust and rust`，此后 r1、r2 不再使用 +> 5. `let r3 = &mut s` — 可变借用（r1、r2 已失效，允许） +> 6. `r3.push_str(" is great")` — 通过可变引用修改 s +> 7. `println!("{}", r3)` — 输出 `rust is great` +> 8. `let s2 = s` — s 的所有权移动到 s2 +> 9. `println!("{}", s2)` — 输出 `rust is great` +> +> 最终输出： +> ``` +> rust and rust +> rust is great +> rust is great +> ``` + ### 题目 5-3 @@ -377,6 +474,11 @@ fn main() { println!("{} {} {}", x, y, z); } ``` +> **[批注] 原分析对引用的理解有严重错误：引用（`&`）不会转移所有权！** +> +> **对于 `i32`：** `y = &x` 创建的是指向 x 的引用，并没有发生 Copy 或所有权转移。`x` 始终拥有那个 `5`，`y` 和 `z` 只是借用它。代码合法，因为多个不可变引用可以共存，且原值本身也可以在引用存在时使用（前提是 `x` 实现了 `Copy` 或本身没有被移动）。这里 `println!` 读取 `x` 也是合法的，因为 i32 是 Copy，会自动复制。 +> +> **对于 `String`：** 同样，`y = &x` 和 `z = &x` 创建的是不可变引用，没有转移所有权。`x` 仍然持有该 String。代码合法，因为多个不可变引用可以同时存在。原答说"所有权被转移给y和z，x不再有变量所有权"是完全错误的——引用和所有权转移（move）是两回事。 如果将 `x` 的类型从 `i32` 改为 `String`，同样的结构是否仍然合法？ @@ -388,10 +490,15 @@ fn main() { println!("{} {} {}", x, y, z); } ``` +> **[批注] 同上一问，引用不会转移所有权。** String 版本同样合法。x 持有 String 的所有权，y 和 z 只是不可变借用。但注意这里 `println!` 中直接使用 `x` 与 String 的情况，由于 `x` 不可变，`println!` 只需要 `&T`，所以编译器会自动将 `x` 视为 `&x`，不会发生移动。如果此处是 `let y = x;`（不带 & 的移动），那 x 的所有权才真正被转移，编译才会失败。 ### 题目 5-4 Rust 的所有权系统与 C++ 的 RAII、Java 的垃圾回收各自有什么优缺点？请简要对比分析。 +> **[批注] 原答过于简略且有概念偏差："C++ RAII和Java的垃圾回收在运行时检查"不够准确。** +> - **C++ RAII**：所有权由程序员显式管理（构造/析构、拷贝/移动语义），C++11 引入 `std::unique_ptr` 等智能指针提供了类似 Rust 的部分保护，但编译器不强制检查，野指针、重复释放、use-after-move 等错误仍可能静默通过编译。优点：灵活性极高，零运行时开销。 +> - **Java GC**：完全无所有权概念，所有对象在堆上分配，由 GC 自动追踪引用并回收。程序员完全不用操心释放。缺点：运行时开销（GC 暂停），无法在编译期保证资源及时释放，内存占用不可预测。 +> - **Rust 所有权**：编译期静态检查所有权、移动、借用，零运行时开销。内存安全和数据竞争在编译期得到保证。缺点：学习曲线陡峭，某些合法但需要复杂生命周期的模式难以表达。 --- diff --git a/part4/Cargo.lock b/part4/Cargo.lock new file mode 100644 index 0000000..94113e5 --- /dev/null +++ b/part4/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "part4" +version = "0.1.0"