借用 Borrowing 概念
核心概念
借用(Borrowing)是 Rust 中通过引用来使用数据而不获取所有权的机制。就像从图书馆借书——你可以阅读书的内容,但书还是图书馆的,到期后要归还。在 Rust 中,创建一个引用(&T 或 &mut T)就是在借用数据,借用期间所有者仍然保持对数据的所有权。
fn main() {
let s = String::from("hello");
// 创建引用就是借用
let r = &s; // r 借用了 s 的数据
println!("借用: {}", r);
// s 仍然是所有者
println!("所有者: {}", s);
// 借用结束后(r 不再使用),s 可以自由操作
}借用 vs 所有权转移
| 方式 | 语法 | 所有权变化 | 原变量 |
|---|---|---|---|
| 移动(所有权转移) | let b = a; | a → b | a 不可用 |
| 不可变借用 | let r = &a; | a 不变 | a 可用(不可修改) |
| 可变借用 | let r = &mut a; | a 不变 | a 暂时不可用 |
| 克隆 | let b = a.clone(); | a 不变 | a 可用 |
fn main() {
// 移动:所有权转移
let s1 = String::from("move");
let s2 = s1;
// println!("{}", s1); // 编译错误:s1 已移动
// 借用:所有权不变
let s3 = String::from("borrow");
let r = &s3;
println!("借用: {}, 原始: {}", r, s3); // 两个都有效
// 克隆:创建独立副本
let s4 = String::from("clone");
let s5 = s4.clone();
println!("原始: {}, 克隆: {}", s4, s5); // 两个独立
}借用的两种形式
不可变借用 &T
不可变借用允许读取数据但不能修改。可以同时存在多个不可变借用。
fn calculate_stats(data: &Vec<f64>) -> (f64, f64, f64) {
let sum: f64 = data.iter().sum();
let mean = sum / data.len() as f64;
let min = data.iter().cloned().reduce(f64::min).unwrap_or(0.0);
let max = data.iter().cloned().reduce(f64::max).unwrap_or(0.0);
(mean, min, max)
}
fn main() {
let data = vec![10.0, 20.0, 30.0, 40.0, 50.0];
// 多个不可变借用可以同时存在
let r1 = &data;
let r2 = &data;
let r3 = &data;
println!("r1 看到: {:?}", r1);
println!("r2 看到: {:?}", r2);
println!("r3 看到: {:?}", r3);
// 传引用给函数也是借用
let (mean, min, max) = calculate_stats(&data);
println!("平均={:.1}, 最小={:.1}, 最大={:.1}", mean, min, max);
// data 始终有效
println!("原始数据: {:?}", data);
}可变借用 &mut T
可变借用允许读取和修改数据,但同一时间只能有一个可变借用。
fn add_greeting(s: &mut String) {
s.insert_str(0, "你好,");
s.push('!');
}
fn double_all(numbers: &mut Vec<i32>) {
for n in numbers.iter_mut() {
*n *= 2;
}
}
fn main() {
let mut name = String::from("张三");
add_greeting(&mut name); // 可变借用
println!("{}", name); // "你好,张三!"
let mut nums = vec![1, 2, 3, 4, 5];
double_all(&mut nums); // 可变借用
println!("{:?}", nums); // [2, 4, 6, 8, 10]
}借用的核心规则
Rust 的借用检查器在编译期强制执行以下规则:
fn main() {
let mut s = String::from("hello");
// 规则一:任意数量的不可变借用可以共存
{
let r1 = &s;
let r2 = &s;
println!("{}, {}", r1, r2); // 合法
}
// 规则二:同一时间只能有一个可变借用
{
let r1 = &mut s;
// let r2 = &mut s; // 编译错误:不能同时有两个可变借用
r1.push_str(" world");
println!("{}", r1);
}
// 规则三:不可变借用和可变借用不能同时存在
{
let r1 = &s;
// let r2 = &mut s; // 编译错误:不可变和可变引用不能同时存在
println!("{}", r1);
// NLL:r1 在这里最后使用,后面可以创建可变借用
let r2 = &mut s;
r2.push('!');
println!("{}", r2);
}
// 规则四:引用的生命周期不能超过被借用值的生命周期
// let r;
// {
// let local = String::from("temp");
// r = &local; // 编译错误:local 在作用域结束时被销毁
// }
// println!("{}", r); // r 会成为悬垂引用
}借用与函数
// 不可变借用:函数只读取数据
fn count_words(text: &str) -> usize {
text.split_whitespace().count()
}
// 可变借用:函数修改数据
fn capitalize_first(s: &mut String) {
if let Some(first) = s.chars().next() {
let upper = first.to_uppercase().to_string();
s.replace_range(..first.len_utf8(), &upper);
}
}
// 不可变借用切片:通用且高效
fn find_max(numbers: &[i32]) -> Option<&i32> {
numbers.iter().max()
}
fn main() {
let text = String::from("hello rust world");
println!("单词数: {}", count_words(&text));
// text 没有被移动
let mut greeting = String::from("hello");
capitalize_first(&mut greeting);
println!("首字母大写: {}", greeting);
let nums = vec![3, 1, 4, 1, 5, 9, 2, 6];
if let Some(max) = find_max(&nums) {
println!("最大值: {}", max);
}
println!("原始数据: {:?}", nums);
}重借用
在持有可变借用时,可以临时创建不可变借用(重借用),让其他代码临时读取数据。
fn print_info(data: &Vec<i32>) {
println!("长度: {}, 数据: {:?}", data.len(), data);
}
fn main() {
let mut data = vec![1, 2, 3];
let r = &mut data;
// 通过可变引用进行重借用(临时创建不可变引用)
print_info(r); // r 被自动重借用为 &Vec<i32>
// 可变引用仍然有效
r.push(4);
print_info(r);
println!("最终: {:?}", r);
}基本示例
用借用实现一个文本分析工具:
struct TextAnalyzer {
text: String,
}
impl TextAnalyzer {
fn new(text: &str) -> Self {
TextAnalyzer {
text: text.to_string(),
}
}
// 不可变借用 &self:只读分析方法
fn word_count(&self) -> usize {
self.text.split_whitespace().count()
}
fn char_count(&self) -> usize {
self.text.chars().count()
}
fn line_count(&self) -> usize {
self.text.lines().count()
}
fn contains(&self, pattern: &str) -> bool {
self.text.contains(pattern)
}
fn most_common_word(&self) -> Option<String> {
use std::collections::HashMap;
let mut freq: HashMap<&str, usize> = HashMap::new();
for word in self.text.split_whitespace() {
*freq.entry(word).or_insert(0) += 1;
}
freq.into_iter()
.max_by_key(|&(_, count)| count)
.map(|(word, _)| word.to_string())
}
// 不可变借用:返回文本的引用
fn text(&self) -> &str {
&self.text
}
// 可变借用 &mut self:修改文本
fn append(&mut self, extra: &str) {
self.text.push(' ');
self.text.push_str(extra);
}
fn replace_word(&mut self, from: &str, to: &str) {
self.text = self.text.replace(from, to);
}
}
fn print_stats(analyzer: &TextAnalyzer) {
println!("=== 文本统计 ===");
println!("字符数: {}", analyzer.char_count());
println!("单词数: {}", analyzer.word_count());
println!("行数: {}", analyzer.line_count());
if let Some(word) = analyzer.most_common_word() {
println!("最常见单词: {}", word);
}
}
fn main() {
let mut analyzer = TextAnalyzer::new(
"rust is fast\nrust is safe\nrust is fun"
);
// 不可变借用:多次读取
print_stats(&analyzer);
println!("包含 'safe': {}", analyzer.contains("safe"));
// 可变借用:修改文本
analyzer.append("rust is awesome");
analyzer.replace_word("fun", "powerful");
// 再次不可变借用
print_stats(&analyzer);
println!("最终文本:\n{}", analyzer.text());
}常见问题
问题一:借用和引用是一回事吗?
引用(Reference)是语法层面的概念(&T、&mut T),借用(Borrowing)是语义层面的概念。创建引用的行为就叫做"借用"。引用是工具,借用是行为。
问题二:为什么不可变引用和可变引用不能同时存在?
如果同时存在不可变引用和可变引用,通过可变引用修改数据会让持有不可变引用的代码看到"意外变化"的数据。这在多线程中就是数据竞争,在单线程中也可能导致迭代器失效等问题。
问题三:借用检查是编译期还是运行时?
完全是编译期检查。违反借用规则的代码无法通过编译。编译通过的代码在运行时不会有额外的借用检查开销。
问题四:什么时候借用会"结束"?
在 NLL(非词法生命周期)下,借用在最后一次使用引用时结束,而不是在引用变量离开作用域时。这让很多实际代码模式变得可行。
fn main() {
let mut s = String::from("hello");
let r = &s;
println!("{}", r); // r 最后一次使用 → 借用到此结束
// 借用已结束,可以可变借用了
s.push_str(" world");
println!("{}", s);
}适用场景
- 函数参数:不需要获取所有权时传引用
- 多处读取:多个代码路径需要同时读取同一数据
- 就地修改:通过可变引用修改数据而不转移所有权
- 切片操作:
&[T]和&str高效引用数据的一部分 - 方法调用:
&self和&mut self是最常见的借用场景
注意事项
- 借用不转移所有权,借用结束后所有者仍然拥有数据
- 多个不可变借用可以共存,但可变借用是独占的
- 不可变借用和可变借用不能同时存在
- NLL 让借用在最后一次使用时结束,不用等到作用域末尾
- 借用检查完全在编译期完成,无运行时开销
- 引用不能超过被引用值的生命周期(编译器保证)
- 优先用借用代替所有权转移
总结
借用是 Rust 通过引用使用数据而不获取所有权的机制。创建 &T 是不可变借用(只读),创建 &mut T 是可变借用(可读写)。核心规则是:任意数量的不可变借用可以共存,但可变借用是独占的——不能同时存在可变借用和其他任何借用。这些规则由编译器的借用检查器在编译期强制执行,运行时零开销。NLL 机制让借用在最后一次使用时就结束,使得借用规则在实际使用中更加灵活。借用是 Rust 中最常用的数据传递方式,应该优先于所有权转移和克隆。