Rust 2026 经验谈 - 所有权模型经验谈

1
// Copy 类型：赋值 = 按位复制，原变量仍可用
2
let x: i32 = 42;
3
let y = x;     // i32 是 Copy，y 得到 x 的副本
4
println!("{}", x);  // ✅ x 仍可用
5

6
// 非 Copy 类型：赋值 = 移动所有权
7
let s1: String = String::from("hello");
8
let s2 = s1;    // String 不是 Copy，所有权从 s1 移动到 s2
9
// println!("{}", s1);  // ❌ s1 已被移动，不可用
10
println!("{}", s2);     // ✅ s2 持有所有权

1
栈                          堆
2
┌──────────┐               ┌───────────────┐
3
│ s1       │ ──移动──→     │ "hello"       │
4
│ (ptr,len)│               │               │
5
└──────────┘               └───────────────┘
6
     ↓ 移动后
7
┌──────────┐
8
│ s1       │  (已失效)
9
└──────────┘
10
┌──────────┐
11
│ s2       │ ──指向──→ 同一块堆内存
12
│ (ptr,len)│
13
└──────────┘

1
let mut list = vec![1, 2, 3];
2
for item in &list {
3
    if *item == 2 {
4
        list.push(4);  // ❌ 不能在不可变借用期间修改
5
    }
6
}

1
struct Game {
2
    score: i32,
3
    players: Vec<String>,
4
}
5

6
impl Game {
7
    fn update(&mut self) {
8
        // 想同时读 score 和写 players
9
        let current_score = self.score;  // ❌ 借用整个 &mut self
10
        self.players.push(format!("Player {}", current_score));
11
    }
12
}

1
impl Game {
2
    fn update(&mut self) {
3
        let current_score = self.score;       // 借用 &self.score (Copy)
4
        self.players.push(format!("Player {}", current_score));  // 借用 &mut self.players
5
    }
6
}

1
fn get_item(items: &Vec<String>, idx: Option<usize>) -> &String {
2
    if let Some(i) = idx {
3
        &items[i]       // 返回对 items 中元素的引用
4
    } else {
5
        &items[0]       // 也返回对 items 中元素的引用
6
    }
7
    // ✅ 两个分支返回的引用的生命周期相同（都来自 items）
8
}

1
fn get_item(items: &Vec<String>, fallback: &String, idx: Option<usize>) -> &String {
2
    if let Some(i) = idx {
3
        &items[i]
4
    } else {
5
        fallback       // 如果 idx 为 None，返回 fallback 的引用
6
    }
7
    // ❌ 编译器无法确定返回值的生命周期来自 items 还是 fallback
8
}

1
fn get_item<'a>(items: &'a Vec<String>, fallback: &'a String, idx: Option<usize>) -> &'a String {
2
    if let Some(i) = idx {
3
        &items[i]
4
    } else {
5
        fallback
6
    }
7
}

1
struct Parser {
2
    input: String,
3
}
4

5
impl Parser {
6
    fn peek(&self) -> &str {
7
        // ❌ 返回对临时值的引用
8
        // self.input.split_whitespace().next().unwrap_or("")
9
        // 如果 split_whitespace() 的迭代器是临时的...
10

11
        // ✅ 正确：返回对 self.input 子串的引用
12
        self.input.split_whitespace().next().unwrap_or("")
13
    }
14
}

1
impl Parser {
2
    fn peek(&self) -> &str {
3
        let result = self.input.trim();  // result: &str，借用 self.input
4
        result  // 直接返回 &str
5
    }
6

7
    fn peek_owned(&self) -> &str {
8
        let result = format!("prefix-{}", self.input);  // 新分配的 String
9
        &result  // ❌ result 是局部变量，函数返回后释放
10
    }
11
}

1
impl Parser {
2
    fn peek_owned(&self) -> String {
3
        format!("prefix-{}", self.input)
4
    }
5
}

1
// Edition 2021
2
fn first_or_second<'a, 'b>(a: &'a str, b: &'b str, use_first: bool) -> impl Iterator<Item = char> {
3
    if use_first { a.chars() } else { b.chars() }
4
    // 2021: 编译通过，返回类型隐式捕获 'a 和 'b
5
}
6

7
// Edition 2024
8
fn first_or_second<'a, 'b>(a: &'a str, b: &'b str, use_first: bool) -> impl Iterator<Item = char> + 'a + 'b {
9
    if use_first { a.chars() } else { b.chars() }
10
    // 2024: 必须显式 + 'a + 'b
11
}

1
fn reborrow_example(data: &mut Vec<i32>) {
2
    // data 是 &mut Vec<i32>
3
    data.push(1);  // 通过 data 可变借用
4

5
    let inner: &mut Vec<i32> = &mut **data;  // reborrow
6
    inner.push(2);
7

8
    // inner 的可变借用结束，data 恢复可用
9
    data.push(3);  // ✅
10
}

1
fn main() {
2
    let mut v = vec![1, 2, 3];
3
    let x = &mut v;      // x 获得 v 的可变借用
4

5
    let y = &mut *x;     // y reborrow x 的权限
6
    y.push(4);
7
    // x 在此期间不可用
8

9
    // y 离开作用域，x 恢复可用
10
    x.push(5);           // ✅
11
}

1
fn push_val(v: &mut Vec<i32>, val: i32) {
2
    v.push(val);
3
}
4

5
fn main() {
6
    let mut v = vec![1, 2, 3];
7
    let r = &mut v;
8

9
    push_val(r, 4);     // r 被 reborrow 为函数参数
10
    push_val(r, 5);     // ✅ r 在上一个调用结束后恢复可用
11
    r.push(6);           // ✅
12
}

1
// ❌ 不必要地获取所有权
2
fn process(data: String) -> usize {
3
    data.len()
4
}
5

6
// ✅ 用引用，调用者保留所有权
7
fn process(data: &str) -> usize {
8
    data.len()
9
}

1
// 返回输入的子串 → 引用
2
fn first_word(s: &str) -> &str {
3
    s.split_whitespace().next().unwrap_or("")
4
}
5

6
// 返回新构造的数据 → 所有权
7
fn greeting(name: &str) -> String {
8
    format!("Hello, {}!", name)
9
}

1
struct Cache {
2
    data: std::cell::RefCell<Option<String>>,  // 内部可变性
3
}
4

5
impl Cache {
6
    // &self 但内部修改：RefCell 在运行时检查借用规则
7
    fn get(&self) -> String {
8
        self.data.borrow_mut().get_or_insert_with(|| {
9
            "computed".to_string()  // 占位：实际为耗时计算
10
        }).clone()
11
    }
12
}

1
use std::borrow::Cow;
2

3
// 过度使用 Cow：调用者困惑
4
fn process(data: Cow<'_, str>) { /* ... */ }
5

6
// 更清晰：两个函数
7
fn process_ref(data: &str) { /* ... */ }
8
fn process_owned(data: String) { /* ... */ }