feat(part3): 添加Rust所有权概念详解文档和练习题
添加了完整的Rust所有权系统学习材料，包括： - 详细的所有权概念解释文档，涵盖移动、借用、切片等核心概念 - 包含基础题、填空题、编程题等多种类型的练习题 - 创建Cargo项目框架和示例代码 - 涵盖所有权规则、引用与借用、可变引用等关键知识点
This commit is contained in:
Yuhang Wu
parent
8a87daba0b
commit
73e25a8e12
|
|
@ -0,0 +1,6 @@
|
|||
[package]
|
||||
name = "part3"
|
||||
version = "0.1.0"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
fn main() {
|
||||
println!("Hello, world!");
|
||||
}
|
||||
|
|
@ -0,0 +1,440 @@
|
|||
# Rust 所有权（Ownership）概念详解
|
||||
|
||||
> 所有权是 Rust 最独特的特性，它让 Rust 无需垃圾回收器就能保证内存安全。
|
||||
|
||||
## 目录
|
||||
|
||||
- [1. 什么是所有权](#1-什么是所有权)
|
||||
- [2. 所有权规则](#2-所有权规则)
|
||||
- [3. 变量作用域](#3-变量作用域)
|
||||
- [4. String 类型与内存分配](#4-string-类型与内存分配)
|
||||
- [5. 移动（Move）](#5-移动move)
|
||||
- [6. 克隆（Clone）](#6-克隆clone)
|
||||
- [7. Copy 特征](#7-copy-特征)
|
||||
- [8. 所有权与函数](#8-所有权与函数)
|
||||
- [9. 返回值与作用域](#9-返回值与作用域)
|
||||
- [10. 引用与借用](#10-引用与借用)
|
||||
- [11. 可变引用](#11-可变引用)
|
||||
- [12. 悬垂引用](#12-悬垂引用)
|
||||
- [13. 切片类型](#13-切片类型)
|
||||
- [14. 总结](#14-总结)
|
||||
|
||||
---
|
||||
|
||||
## 1. 什么是所有权
|
||||
|
||||
所有权是一套用于管理内存的规则。在大部分编程语言中，内存管理通过以下方式处理：
|
||||
|
||||
- **手动管理**（如 C/C++）：程序员显式分配和释放内存
|
||||
- **垃圾回收**（如 Java/Go）：运行时自动回收不再使用的内存
|
||||
- **所有权系统**（Rust）：通过编译时检查的一套规则管理内存
|
||||
|
||||
### 为什么需要所有权？
|
||||
|
||||
- 无需垃圾回收，性能更高
|
||||
- 无需手动管理内存，更安全
|
||||
- 在编译期消除内存错误
|
||||
|
||||
---
|
||||
|
||||
## 2. 所有权规则
|
||||
|
||||
三条核心规则：
|
||||
|
||||
1. Rust 中的**每一个值**都有一个**所有者**（owner）
|
||||
2. 值在任一时刻**有且仅有一个**所有者
|
||||
3. 当所有者离开作用域，值会被**自动释放**（调用 `drop`）
|
||||
|
||||
---
|
||||
|
||||
## 3. 变量作用域
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
// s 在这里无效，尚未声明
|
||||
let s = "hello"; // s 从此处开始有效
|
||||
|
||||
// 可以使用 s
|
||||
println!("{}", s);
|
||||
} // 此作用域结束，s 不再有效
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 4. String 类型与内存分配
|
||||
|
||||
字符串字面量 `"hello"` 是不可变的，编译时已知，存储在二进制文件中。对于在运行时可变的字符串，使用 `String` 类型。
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let mut s = String::from("hello");
|
||||
|
||||
s.push_str(", world!"); // push_str() 追加字符串
|
||||
|
||||
println!("{}", s); // 输出: hello, world!
|
||||
}
|
||||
```
|
||||
|
||||
### 内存分配与释放
|
||||
|
||||
`String` 类型的数据存储在**堆**上：
|
||||
|
||||
- 栈：存储指针、长度、容量（固定大小，编译时已知）
|
||||
- 堆：存储实际的字符串内容（编译时大小未知，运行时动态分配）
|
||||
|
||||
```text
|
||||
栈 堆
|
||||
┌──────────┐ ┌──────────┐
|
||||
│ ptr │────────>│ h e l l o│
|
||||
│ len: 5 │ │ w o r l d│
|
||||
│ cap: 5 │ └──────────┘
|
||||
└──────────┘
|
||||
```
|
||||
|
||||
当变量离开作用域时，Rust 自动调用 `drop` 函数，将堆内存归还给操作系统。
|
||||
|
||||
---
|
||||
|
||||
## 5. 移动（Move）
|
||||
|
||||
```rust
|
||||
let x = 5;
|
||||
let y = x; // x 的值被复制到 y（栈上数据，Copy 类型）
|
||||
println!("{}", x); // ✅ 正常工作，x 仍可用
|
||||
|
||||
let s1 = String::from("hello");
|
||||
let s2 = s1; // s1 的所有权**移动**到了 s2
|
||||
// println!("{}", s1); // ❌ 编译错误！s1 已失效
|
||||
println!("{}", s2); // ✅ 正常工作
|
||||
```
|
||||
|
||||
### 为什么需要移动？
|
||||
|
||||
如果 Rust 对堆数据也做浅拷贝，当 `s1` 和 `s2` 同时离开作用域时，它们都会尝试释放同一块堆内存，导致**二次释放**错误。
|
||||
|
||||
Rust 通过**移动**解决了这个问题：赋值后旧变量失效，只有一个所有者负责释放内存。
|
||||
|
||||
```text
|
||||
移动前: 移动后:
|
||||
s1 → [堆内存] s2 → [堆内存]
|
||||
s1 已失效 ❌
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 6. 克隆（Clone）
|
||||
|
||||
如果确实需要深度复制堆数据，使用 `clone` 方法：
|
||||
|
||||
```rust
|
||||
let s1 = String::from("hello");
|
||||
let s2 = s1.clone(); // 在堆上创建一份完整副本
|
||||
|
||||
println!("s1 = {}, s2 = {}", s1, s2); // ✅ 两者都可用
|
||||
```
|
||||
|
||||
```text
|
||||
克隆后:
|
||||
s1 → [堆内存1: "hello"]
|
||||
s2 → [堆内存2: "hello"]
|
||||
```
|
||||
|
||||
- `clone` 会执行**深拷贝**，包括堆数据
|
||||
- 代价较高，仅在确实需要时使用
|
||||
|
||||
---
|
||||
|
||||
## 7. Copy 特征
|
||||
|
||||
对于**完全存储在栈上**的数据类型，Rust 提供了 `Copy` 特征：
|
||||
|
||||
```rust
|
||||
let x = 5;
|
||||
let y = x; // x 被复制，而非移动
|
||||
println!("{}", x); // ✅ 仍可使用
|
||||
```
|
||||
|
||||
### 具有 Copy 的类型
|
||||
|
||||
- 所有整数类型：`u32`、`i64` 等
|
||||
- 所有浮点类型：`f32`、`f64`
|
||||
- 布尔类型：`bool`
|
||||
- 字符类型：`char`
|
||||
- 元组（仅当所有元素都实现了 Copy）：`(i32, bool)` ✅，`(i32, String)` ❌
|
||||
|
||||
### 不具有 Copy 的类型
|
||||
|
||||
- `String`
|
||||
- `Vec<T>`
|
||||
- 任何实现了 `Drop` trait 的类型
|
||||
|
||||
---
|
||||
|
||||
## 8. 所有权与函数
|
||||
|
||||
将值传递给函数时，会发生**移动**或**复制**，规则与赋值相同：
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let s = String::from("hello");
|
||||
|
||||
takes_ownership(s); // s 的所有权移动到函数内
|
||||
// println!("{}", s); // ❌ 编译错误！s 已失效
|
||||
|
||||
let x = 5;
|
||||
|
||||
makes_copy(x); // x 被复制到函数内（i32 是 Copy 类型）
|
||||
println!("{}", x); // ✅ x 仍然可用
|
||||
} // x 离开作用域，然后 s 离开作用域（但 s 已被移动，不会发生什么）
|
||||
|
||||
fn takes_ownership(some_string: String) {
|
||||
println!("{}", some_string);
|
||||
} // some_string 离开作用域，drop 被调用，内存释放
|
||||
|
||||
fn makes_copy(some_integer: i32) {
|
||||
println!("{}", some_integer);
|
||||
} // some_integer 离开作用域，无特殊操作（栈数据）
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 9. 返回值与作用域
|
||||
|
||||
函数的返回值也可以**转移所有权**：
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let s1 = gives_ownership(); // 返回值将所有权移给 s1
|
||||
|
||||
let s2 = String::from("hello");
|
||||
|
||||
let s3 = takes_and_gives_back(s2); // s2 移入函数，函数返回后又移给 s3
|
||||
// println!("{}", s2); // ❌ s2 已失效
|
||||
|
||||
println!("s1 = {}, s3 = {}", s1, s3);
|
||||
} // s1、s3 离开作用域并被释放；s2 已被移动，不触发释放
|
||||
|
||||
fn gives_ownership() -> String {
|
||||
let some_string = String::from("hello");
|
||||
some_string // 返回 some_string，所有权移出
|
||||
}
|
||||
|
||||
fn takes_and_gives_back(a_string: String) -> String {
|
||||
a_string // 返回 a_string，所有权移出
|
||||
}
|
||||
```
|
||||
|
||||
### 元组返回多个值
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let s1 = String::from("hello");
|
||||
let (s2, len) = calculate_length(s1);
|
||||
println!("'{}' 的长度是 {}", s2, len);
|
||||
}
|
||||
|
||||
fn calculate_length(s: String) -> (String, usize) {
|
||||
let length = s.len();
|
||||
(s, length) // 返回字符串和它的长度
|
||||
}
|
||||
```
|
||||
|
||||
这种写法有些繁琐，Rust 提供了**引用**来简化。
|
||||
|
||||
---
|
||||
|
||||
## 10. 引用与借用
|
||||
|
||||
**引用**允许在不获取所有权的情况下使用值。
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let s1 = String::from("hello");
|
||||
|
||||
let len = calculate_length(&s1); // 传递引用，不转移所有权
|
||||
|
||||
println!("'{}' 的长度是 {}", s1, len); // ✅ s1 仍可使用
|
||||
}
|
||||
|
||||
fn calculate_length(s: &String) -> usize { // s 是对 String 的引用
|
||||
s.len()
|
||||
} // s 离开作用域，但由于它不拥有值的所有权，不会调用 drop
|
||||
```
|
||||
|
||||
```text
|
||||
s1 → [堆内存: "hello"]
|
||||
↑
|
||||
&s1（引用，指向 s1 的值）
|
||||
```
|
||||
|
||||
### 引用的规则
|
||||
|
||||
1. 引用**不获取**所有权
|
||||
2. 创建引用的行为称为**借用**（borrowing）
|
||||
3. 借用者离开作用域时，不会释放底层数据
|
||||
|
||||
---
|
||||
|
||||
## 11. 可变引用
|
||||
|
||||
默认情况下，引用是**不可变的**。要修改借用的值，需要使用**可变引用**：
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let mut s = String::from("hello");
|
||||
|
||||
change(&mut s); // 传递可变引用
|
||||
|
||||
println!("{}", s); // 输出：hello, world!
|
||||
}
|
||||
|
||||
fn change(some_string: &mut String) {
|
||||
some_string.push_str(", world!");
|
||||
}
|
||||
```
|
||||
|
||||
### 可变引用的限制
|
||||
|
||||
**在任意给定时间，只能拥有以下两者之一：**
|
||||
|
||||
- 一个可变引用
|
||||
- 任意数量的不可变引用
|
||||
|
||||
```rust
|
||||
let mut s = String::from("hello");
|
||||
|
||||
// ✅ 不可变引用可以同时存在多个
|
||||
let r1 = &s;
|
||||
let r2 = &s;
|
||||
println!("{} and {}", r1, r2);
|
||||
|
||||
// ✅ 不可变引用不再使用后，可以创建可变引用
|
||||
let r3 = &mut s;
|
||||
println!("{}", r3);
|
||||
```
|
||||
|
||||
```rust
|
||||
let mut s = String::from("hello");
|
||||
|
||||
let r1 = &s; // 不可变借用
|
||||
let r2 = &s; // 不可变借用
|
||||
let r3 = &mut s; // ❌ 编译错误！不能同时存在不可变和可变引用
|
||||
|
||||
println!("{}, {}, {}", r1, r2, r3);
|
||||
```
|
||||
|
||||
```rust
|
||||
let mut s = String::from("hello");
|
||||
|
||||
let r1 = &mut s;
|
||||
let r2 = &mut s; // ❌ 编译错误！不能同时存在两个可变引用
|
||||
|
||||
println!("{}, {}", r1, r2);
|
||||
```
|
||||
|
||||
**这样设计的好处：在编译时防止数据竞争！**
|
||||
|
||||
> 数据竞争发生的三个条件：
|
||||
> 1. 两个或多个指针同时访问同一数据
|
||||
> 2. 至少有一个指针用于写入
|
||||
> 3. 没有同步数据访问的机制
|
||||
|
||||
Rust 的规则直接在编译期消灭了数据竞争。
|
||||
|
||||
---
|
||||
|
||||
## 12. 悬垂引用
|
||||
|
||||
**悬垂引用**是指向已被释放内存的指针。Rust 编译器保证永远不会产生悬垂引用：
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let reference_to_nothing = dangle(); // ❌ 编译错误！
|
||||
}
|
||||
|
||||
fn dangle() -> &String {
|
||||
let s = String::from("hello");
|
||||
&s // 返回 s 的引用
|
||||
} // s 离开作用域，内存被释放；但返回的引用仍指向已释放的内存
|
||||
```
|
||||
|
||||
编译器错误信息：
|
||||
```
|
||||
error[E0106]: missing lifetime specifier
|
||||
|
|
||||
| fn dangle() -> &String {
|
||||
| ^ expected named lifetime parameter
|
||||
```
|
||||
|
||||
正确的做法是直接返回 `String`，将所有权移出去：
|
||||
|
||||
```rust
|
||||
fn no_dangle() -> String {
|
||||
let s = String::from("hello");
|
||||
s // 所有权移出
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 13. 切片类型
|
||||
|
||||
**切片**是一种不获取所有权的引用，允许引用集合中一段连续的元素。
|
||||
|
||||
### 字符串切片
|
||||
|
||||
```rust
|
||||
let s = String::from("hello world");
|
||||
|
||||
let hello = &s[0..5]; // "hello"
|
||||
let world = &s[6..11]; // "world"
|
||||
```
|
||||
|
||||
语法简写：
|
||||
|
||||
```rust
|
||||
let s = String::from("hello world");
|
||||
|
||||
let hello = &s[..5]; // 从 0 开始
|
||||
let world = &s[6..]; // 到末尾
|
||||
let whole = &s[..]; // 整个字符串
|
||||
```
|
||||
|
||||
### 字符串字面量就是切片
|
||||
|
||||
```rust
|
||||
let s = "Hello, world!"; // s 的类型是 &str，即字符串切片
|
||||
```
|
||||
|
||||
### 其他切片
|
||||
|
||||
```rust
|
||||
let a = [1, 2, 3, 4, 5];
|
||||
|
||||
let slice = &a[1..3]; // 类型是 &[i32]，包含 [2, 3]
|
||||
|
||||
assert_eq!(slice, &[2, 3]);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 14. 总结
|
||||
|
||||
| 概念 | 说明 |
|
||||
|------|------|
|
||||
| **所有权** | 每个值有且仅有一个所有者；所有者离开作用域时值被释放 |
|
||||
| **移动** | 赋值/传参时转移所有权，原变量失效 |
|
||||
| **克隆** | 深拷贝堆数据，两个变量独立 |
|
||||
| **Copy** | 栈上数据的自动复制（整数、布尔等基础类型） |
|
||||
| **引用** | 不获取所有权的指针，允许多个存在 |
|
||||
| **可变引用** | 可修改数据的引用，同时只能有一个 |
|
||||
| **切片** | 对集合局部元素的引用 |
|
||||
| **借用规则** | 任意时刻：要么一个可变引用，要么多个不可变引用 |
|
||||
|
||||
### 借用检查器保证了
|
||||
|
||||
- **内存安全**：无悬垂指针、无二次释放、无使用后释放
|
||||
- **线程安全**：无数据竞争
|
||||
- **零运行时开销**：所有检查在编译时完成
|
||||
|
||||
> 所有权系统可能会让初学者感到"Rust 编译器在跟你作对"，但请记住：**编译器不是在刁难你，而是在保护你写出的每一行代码都是内存安全的。** 当你熟悉所有权之后，这些规则会变得自然且合理。
|
||||
|
|
@ -0,0 +1,555 @@
|
|||
# Rust 所有权练习题
|
||||
|
||||
> 建议先手动写出每道题的答案，再运行代码验证。
|
||||
|
||||
## 一、基础题：判断正误
|
||||
|
||||
判断以下代码能否通过编译。如果可以，说明原因；如果不能，指出错误原因。
|
||||
|
||||
### 题目 1-1
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let s = String::from("hello");
|
||||
let t = s;
|
||||
println!("{}", s);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 1-2
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let x = 42;
|
||||
let y = x;
|
||||
println!("x = {}, y = {}", x, y);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 1-3
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let s = String::from("rust");
|
||||
let t = s.clone();
|
||||
println!("s = {}, t = {}", s, t);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 1-4
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let s1 = String::from("hello");
|
||||
let s2 = &s1;
|
||||
let s3 = &s1;
|
||||
println!("{} {} {}", s1, s2, s3);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 1-5
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let mut s = String::from("hello");
|
||||
let r1 = &mut s;
|
||||
let r2 = &mut s;
|
||||
println!("{}, {}", r1, r2);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 1-6
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let mut s = String::from("hello");
|
||||
let r1 = &s;
|
||||
let r2 = &s;
|
||||
let r3 = &mut s;
|
||||
println!("{}, {}, {}", r1, r2, r3);
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 二、填空题：补充代码
|
||||
|
||||
补全下列代码使其能通过编译。
|
||||
|
||||
### 题目 2-1：转移所有权
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let s = String::from("rustacean");
|
||||
takes_ownership(________); // 填空，使 s 的所有权进入函数
|
||||
// println!("{}", s); // 此行若取消注释会报错
|
||||
}
|
||||
|
||||
fn takes_ownership(s: String) {
|
||||
println!("{}", s);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 2-2：借用的生命周期
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let s = String::from("hello");
|
||||
let len = get_length(________); // 填空：传递引用取得长度
|
||||
println!("'{}' 的长度是 {}", s, len);
|
||||
}
|
||||
|
||||
fn get_length(s: &String) -> usize {
|
||||
s.len()
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 2-3：可变引用
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let ________ s = String::from("hello"); // 填空：声明可变变量
|
||||
append_world(________); // 填空：传递可变引用
|
||||
println!("{}", s); // 期望输出：hello, world!
|
||||
}
|
||||
|
||||
fn append_world(s: &mut String) {
|
||||
s.push_str(", world!");
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 2-4：作用域技巧
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let mut s = String::from("hello");
|
||||
|
||||
{ // 进入新作用域
|
||||
let r1 = ________; // 填空：创建不可变引用
|
||||
println!("{}", r1);
|
||||
} // r1 离开作用域
|
||||
|
||||
let r2 = ________; // 填空：现在可以创建可变引用了
|
||||
r2.push_str(" world");
|
||||
println!("{}", r2);
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 三、找出并修复错误
|
||||
|
||||
以下每段代码都有编译错误，请指出错误并写出修正后的代码。
|
||||
|
||||
### 题目 3-1
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let s1 = String::from("hello");
|
||||
let s2 = s1;
|
||||
print_both(s1, s2);
|
||||
}
|
||||
|
||||
fn print_both(a: String, b: String) {
|
||||
println!("{} and {}", a, b);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 3-2
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let s = dangle();
|
||||
println!("{}", s);
|
||||
}
|
||||
|
||||
fn dangle() -> &String {
|
||||
let s = String::from("hello");
|
||||
&s
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 3-3
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let mut s = String::from("hello");
|
||||
let r1 = &mut s;
|
||||
r1.push_str(", world");
|
||||
let r2 = &mut s;
|
||||
r2.push_str("!");
|
||||
println!("{}", r1);
|
||||
println!("{}", r2);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 3-4
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let s = String::from("hello world");
|
||||
let first = &s[0..5];
|
||||
s.clear(); // 清空字符串
|
||||
println!("first = {}", first);
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 四、编程题
|
||||
|
||||
### 题目 4-1：计算单词数量
|
||||
|
||||
编写一个函数 `count_words(s: &str) -> usize`，计算字符串中的单词数量（以空格分隔）。
|
||||
|
||||
```rust
|
||||
fn count_words(s: &str) -> usize {
|
||||
// 你的代码
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let s = String::from("hello world rust");
|
||||
let count = count_words(&s);
|
||||
println!("'{}' 有 {} 个单词", s, count); // 期望输出：3
|
||||
|
||||
// 验证 s 的所有权未被取走
|
||||
println!("原始字符串仍然可用: {}", s);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 4-2：获取首尾单词
|
||||
|
||||
编写函数 `first_and_last(s: &str) -> (&str, &str)`，返回字符串的首单词和尾单词。
|
||||
|
||||
```rust
|
||||
fn first_and_last(s: &str) -> (&str, &str) {
|
||||
// 你的代码
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let s = String::from("Rust is a systems programming language");
|
||||
let (first, last) = first_and_last(&s);
|
||||
println!("首单词: '{}', 尾单词: '{}'", first, last);
|
||||
// 期望输出：首单词: 'Rust', 尾单词: 'language'
|
||||
println!("原字符串: {}", s);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 4-3：字符串处理
|
||||
|
||||
编写一个函数，接收一个字符串，返回一个新的字符串，将其中的每个单词首字母大写，其余字母小写。
|
||||
|
||||
```rust
|
||||
fn title_case(s: &str) -> String {
|
||||
// 你的代码
|
||||
// 提示：可以使用 split_whitespace、to_uppercase、to_lowercase、collect 等方法
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let s = String::from("hello WORLD rust");
|
||||
let result = title_case(&s);
|
||||
println!("输入: {}", s);
|
||||
println!("输出: {}", result);
|
||||
// 期望输出：Hello World Rust
|
||||
|
||||
// 验证 s 的所有权未被取走
|
||||
println!("原字符串: {}", s);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 4-4：参数所有权设计
|
||||
|
||||
请合理设计以下函数的参数类型（传值 / 传引用 / 传可变引用）：
|
||||
|
||||
```rust
|
||||
// fn capitalize(s: ???) // 1. 只读取，不修改，调用后原变量还要用
|
||||
// fn consume_and_print(s: ???) // 2. 拿走所有权，调用后原变量不再使用
|
||||
// fn append_exclamation(s: ???)// 3. 修改原字符串
|
||||
|
||||
fn capitalize(s: ________) -> String {
|
||||
let mut result = s.clone();
|
||||
if let Some(c) = result.get_mut(0..1) {
|
||||
c.make_ascii_uppercase();
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn consume_and_print(s: ________) {
|
||||
println!("消费了: {}", s);
|
||||
}
|
||||
|
||||
fn append_exclamation(s: ________) {
|
||||
s.push_str("!");
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let s = String::from("hello");
|
||||
|
||||
let capitalized = capitalize(________); // 填空：调用 capitalize
|
||||
println!("{}", s); // s 仍可用
|
||||
|
||||
consume_and_print(________); // 填空：调用 consume_and_print，传入 s
|
||||
// println!("{}", s); // 若取消注释会报错
|
||||
|
||||
let mut t = String::from("hello");
|
||||
append_exclamation(________); // 填空：调用 append_exclamation
|
||||
println!("{}", t); // 期望输出：hello!
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 4-5：数组切片操作
|
||||
|
||||
编写函数实现以下功能：
|
||||
|
||||
```rust
|
||||
// 返回数组前 n 个元素的和
|
||||
fn sum_of_first_n(arr: &[i32], n: usize) -> i32 {
|
||||
// 你的代码
|
||||
// 提示：使用切片 &arr[..n]
|
||||
}
|
||||
|
||||
// 判断一个切片是否包含目标值
|
||||
fn contains(arr: &[i32], target: i32) -> bool {
|
||||
// 你的代码
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let numbers = [10, 20, 30, 40, 50];
|
||||
|
||||
println!("前 3 个元素的和: {}", sum_of_first_n(&numbers, 3)); // 期望：60
|
||||
|
||||
println!("包含 30 吗? {}", contains(&numbers, 30)); // 期望：true
|
||||
println!("包含 99 吗? {}", contains(&numbers, 99)); // 期望：false
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 五、综合思考题
|
||||
|
||||
### 题目 5-1
|
||||
|
||||
以下代码为什么不能通过编译？提出两种修复方法，并说明各自的优缺点。
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let mut data = vec![1, 2, 3];
|
||||
let first = &data[0];
|
||||
data.push(4);
|
||||
println!("first = {}", first);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 5-2
|
||||
|
||||
分析以下代码，回答：
|
||||
1. 写出每一步所有权的状态变化
|
||||
2. 最终输出是什么？
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let mut s = String::from("rust");
|
||||
let r1 = &s;
|
||||
let r2 = &s;
|
||||
println!("{} and {}", r1, r2);
|
||||
// r1, r2 此后不再使用
|
||||
|
||||
let r3 = &mut s;
|
||||
r3.push_str(" is great");
|
||||
println!("{}", r3);
|
||||
// r3 此后不再使用
|
||||
|
||||
let s2 = s; // 移动 s
|
||||
// println!("{}", s); // 若取消注释会怎样？
|
||||
println!("{}", s2);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 5-3
|
||||
|
||||
以下代码在 Rust 中是否合法？为什么？
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let x = 5;
|
||||
let y = &x;
|
||||
let z = &x;
|
||||
println!("{} {} {}", x, y, z);
|
||||
}
|
||||
```
|
||||
|
||||
如果将 `x` 的类型从 `i32` 改为 `String`，同样的结构是否仍然合法？
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
let x = String::from("hello");
|
||||
let y = &x;
|
||||
let z = &x;
|
||||
println!("{} {} {}", x, y, z);
|
||||
}
|
||||
```
|
||||
|
||||
### 题目 5-4
|
||||
|
||||
Rust 的所有权系统与 C++ 的 RAII、Java 的垃圾回收各自有什么优缺点？请简要对比分析。
|
||||
|
||||
---
|
||||
|
||||
## 参考答案
|
||||
|
||||
> 请独立完成再查看答案。
|
||||
|
||||
<details>
|
||||
<summary>点击展开答案</summary>
|
||||
|
||||
### 一、基础题
|
||||
|
||||
**1-1**：❌ 编译错误。`s` 的所有权已移动到 `t`，`s` 已失效。
|
||||
|
||||
**1-2**：✅ 通过编译。`i32` 实现了 `Copy`，赋值时自动复制。
|
||||
|
||||
**1-3**：✅ 通过编译。`clone` 创建了深拷贝，两个变量独立。
|
||||
|
||||
**1-4**：✅ 通过编译。不可变引用可以同时存在多个。
|
||||
|
||||
**1-5**：❌ 编译错误。同一作用域不能同时存在两个可变引用。
|
||||
|
||||
**1-6**：❌ 编译错误。已有不可变引用时不能创建可变引用。
|
||||
|
||||
### 二、填空题
|
||||
|
||||
**2-1**：`takes_ownership(s);`
|
||||
|
||||
**2-2**：`let len = get_length(&s);`
|
||||
|
||||
**2-3**：
|
||||
```rust
|
||||
let mut s = String::from("hello");
|
||||
append_world(&mut s);
|
||||
```
|
||||
|
||||
**2-4**：
|
||||
```rust
|
||||
let r1 = &s;
|
||||
let r2 = &mut s;
|
||||
```
|
||||
|
||||
### 三、修复错误
|
||||
|
||||
**3-1**：`s1` 已被移动给 `s2`，不能再传给函数。修复：
|
||||
```rust
|
||||
fn main() {
|
||||
let s1 = String::from("hello");
|
||||
let s2 = s1.clone(); // 克隆一份
|
||||
print_both(s1, s2);
|
||||
}
|
||||
```
|
||||
|
||||
**3-2**：返回了局部变量的引用，生命周期不够。修复：
|
||||
```rust
|
||||
fn dangle() -> String { // 返回 String 而非 &String
|
||||
let s = String::from("hello");
|
||||
s // 所有权移出
|
||||
}
|
||||
```
|
||||
|
||||
**3-3**：`r1` 和 `r2` 的可变借用时间重叠。修复：将两次借用限制在各自的作用域内，或使用 `Non-Lexical Lifetimes` 特性（Rust 2018+ 已默认启用，但此处 `r1` 在 `r2` 创建后仍被使用）。修复方法：
|
||||
```rust
|
||||
fn main() {
|
||||
let mut s = String::from("hello");
|
||||
let r1 = &mut s;
|
||||
r1.push_str(", world");
|
||||
println!("{}", r1);
|
||||
// r1 在 println! 后不再使用
|
||||
let r2 = &mut s;
|
||||
r2.push_str("!");
|
||||
println!("{}", r2);
|
||||
}
|
||||
```
|
||||
|
||||
**3-4**：`clear()` 需要一个可变引用，但 `first` 是一个不可变引用，违反了借用规则。修复：先使用 `first`，再 `clear`：
|
||||
```rust
|
||||
fn main() {
|
||||
let s = String::from("hello world");
|
||||
let first = &s[0..5];
|
||||
println!("first = {}", first); // 先使用
|
||||
let mut s = s; // 重新绑定
|
||||
s.clear();
|
||||
}
|
||||
```
|
||||
|
||||
### 四、编程题
|
||||
|
||||
**4-1**：
|
||||
```rust
|
||||
fn count_words(s: &str) -> usize {
|
||||
s.split_whitespace().count()
|
||||
}
|
||||
```
|
||||
|
||||
**4-2**：
|
||||
```rust
|
||||
fn first_and_last(s: &str) -> (&str, &str) {
|
||||
let words: Vec<&str> = s.split_whitespace().collect();
|
||||
(words[0], words[words.len() - 1])
|
||||
}
|
||||
```
|
||||
|
||||
**4-3**：
|
||||
```rust
|
||||
fn title_case(s: &str) -> String {
|
||||
s.split_whitespace()
|
||||
.map(|word| {
|
||||
let mut chars = word.chars();
|
||||
match chars.next() {
|
||||
None => String::new(),
|
||||
Some(c) => c.to_uppercase().collect::<String>() + &chars.as_str().to_lowercase(),
|
||||
}
|
||||
})
|
||||
.collect::<Vec<String>>()
|
||||
.join(" ")
|
||||
}
|
||||
```
|
||||
|
||||
**4-4**：
|
||||
```rust
|
||||
fn capitalize(s: &str) -> String { /* ... */ }
|
||||
fn consume_and_print(s: String) { /* ... */ }
|
||||
fn append_exclamation(s: &mut String) { /* ... */ }
|
||||
|
||||
// 调用方式：
|
||||
let capitalized = capitalize(&s); // 传引用
|
||||
consume_and_print(s); // 传值，所有权移入
|
||||
append_exclamation(&mut t); // 传可变引用
|
||||
```
|
||||
|
||||
**4-5**：
|
||||
```rust
|
||||
fn sum_of_first_n(arr: &[i32], n: usize) -> i32 {
|
||||
arr[..n].iter().sum()
|
||||
}
|
||||
|
||||
fn contains(arr: &[i32], target: i32) -> bool {
|
||||
arr.contains(&target)
|
||||
}
|
||||
```
|
||||
|
||||
### 五、综合思考题
|
||||
|
||||
**5-1**：`first` 是对 `data` 元素的不可变引用，`push` 需要一个可变引用，违反借用规则。
|
||||
- 方法一：调整顺序，先 push 再取引用 —— 简单但有时逻辑不允许
|
||||
- 方法二：使用索引 `let first = data[0]`（需要 Copy 类型）—— 避免了借用但只适用于 Copy 类型
|
||||
|
||||
**5-2**：
|
||||
- 步骤：创建 `s` → 两次不可变借用（r1, r2）→ 打印后 r1, r2 释放 → 一次可变借用（r3）→ 打印后 r3 释放 → 移动 `s` 到 `s2`
|
||||
- 输出：`rust and rust` / `rust is great` / `rust is great`
|
||||
- 取消注释会报错：`s` 已移动
|
||||
|
||||
**5-3**：两者都合法。创建引用不会转移 `x` 的所有权，无论 `x` 是什么类型。只要引用和原值不冲突即可（此处都是不可变引用）。
|
||||
|
||||
**5-4**（简要）：
|
||||
- **C++ RAII**：灵活、性能极高，但依赖程序员自觉，容易出现野指针、重复释放
|
||||
- **Java GC**：使用方便，不会出现悬挂指针，但存在运行时开销、不可预测的停顿
|
||||
- **Rust 所有权**：编译期零成本抽象，保证内存安全/线程安全，但学习曲线陡峭
|
||||
|
||||
</details>
|
||||
Loading…
Reference in New Issue