926 字

5 分钟

rust study 4day

2025-11-03

rust

🦀 Rust 借用（References & Borrowing）教程#

目录#

借用概念
不可变引用（&T）
可变引用（&mut T）
引用规则
函数中的借用
生命周期与引用
综合示例
总结

1️⃣ 借用概念#

**借用（Borrowing）**是指：

不获取数据的所有权，而是“借用”原数据的访问权
借用可以读取或修改数据（取决于是不可变引用还是可变引用）
借用不会触发所有权移动，所以原变量在借用结束后依然有效

1
fn main() {
2
    let s = String::from("Hello");
3
    let r = &s; // 借用 s，r 是引用
4
    println!("r = {}", r);
5
    println!("s = {}", s); // s 仍然可用
6
}

借用分为两类：不可变借用和可变借用。

2️⃣ 不可变引用（&T）#

语法：&变量名
特性：
1. 只能读取数据
2. 可以同时有多个不可变引用

1
fn main() {
2
    let s = String::from("Rust");
3

4
    let r1 = &s;
5
    let r2 = &s;
6

7
    println!("r1 = {}, r2 = {}", r1, r2);
8
    println!("s = {}", s);
9
}

输出：

1
r1 = Rust, r2 = Rust
2
s = Rust

多个不可变引用不会导致数据竞争。

3️⃣ 可变引用（&mut T）#

语法：&mut 变量名
特性：
1. 可以修改原数据
2. 同一时间只能有一个可变引用

1
fn main() {
2
    let mut s = String::from("Hello");
3

4
    let r = &mut s;
5
    r.push_str(", world");
6

7
    println!("{}", r); // Hello, world
8
}

如果在可变引用存在时尝试创建不可变引用或另一个可变引用，编译器会报错。

1
let mut s = String::from("Hello");
2
let r1 = &s;
3
let r2 = &mut s; // ❌ 编译错误：不能同时有不可变和可变引用

4️⃣ 引用规则（Borrowing Rules）#

Rust 借用规则保证数据安全：

任意时刻可以有多个不可变引用（读取）
或者一个可变引用（写入）
不可同时存在可变引用和不可变引用
引用必须始终有效（避免悬垂指针）

5️⃣ 函数中的借用#

借用使函数能在 不获取所有权 的情况下访问或修改数据。

不可变引用作为参数#

1
fn print_length(s: &String) {
2
    println!("长度 = {}", s.len());
3
}
4

5
fn main() {
6
    let s = String::from("Rustacean");
7
    print_length(&s); // 借用，不移动
8
    println!("原字符串仍可用: {}", s);
9
}

可变引用作为参数#

1
fn add_exclamation(s: &mut String) {
2
    s.push_str("!");
3
}
4

5
fn main() {
6
    let mut s = String::from("Hello");
7
    add_exclamation(&mut s);
8
    println!("{}", s); // Hello!
9
}

6️⃣ 生命周期与引用#

引用的有效期必须 ≤ 被引用数据的生命周期
Rust 编译器通过 生命周期分析 检查引用安全性

1
fn invalid_reference() -> &String {
2
    let s = String::from("Hello");
3
    &s // ❌ s 会在函数结束被释放
4
}

正确做法：返回数据所有权或返回已有引用（函数参数引用）。

7️⃣ 综合示例#

1
fn main() {
2
    let mut s = String::from("Rust");
3

4
    // 不可变引用
5
    let r1 = &s;
6
    let r2 = &s;
7
    println!("r1={}, r2={}", r1, r2);
8

9
    // r1, r2 使用完毕后，可创建可变引用
10
    let r3 = &mut s;
11
    r3.push_str("acean");
12
    println!("{}", r3);
13

14
    // 函数借用示例
15
    print_length(&s);
16
    add_exclamation(&mut s);
17
    println!("最终字符串: {}", s);
18
}
19

20
fn print_length(s: &String) { println!("长度: {}", s.len()); }
21
fn add_exclamation(s: &mut String) { s.push('!'); }

输出：

1
r1=Rust, r2=Rust
2
Rustacean
3
长度: 9
4
最终字符串: Rustacean!

8️⃣ 总结#

借用允许函数或变量访问数据而 不转移所有权
不可变引用（&T）可同时存在多个，只读
可变引用（&mut T）一次只能有一个，可修改
借用规则保证内存安全和避免数据竞争
生命周期与引用密切相关，Rust 编译器会检查引用有效性

💡 练习建议：

编写函数接受多个不可变引用，打印内容
编写函数接受可变引用，修改数据
尝试同时创建可变引用和不可变引用，观察编译器报错
练习在函数返回值中安全传递引用

rust study 4day

https://iqwq.com/posts/rust/study-4day/

作者

Xiaolin

发布于

2025-11-03

许可协议

CC BY-NC-SA 4.0

study 2day

rust study 5day

1

🦀 Rust 借用（References & Borrowing）教程

1️⃣ 借用概念

2️⃣ 不可变引用（&T）

3️⃣ 可变引用（&mut T）

4️⃣ 引用规则（Borrowing Rules）