借用 Borrowing 概念 ​

核心概念 ​

借用(Borrowing)是 Rust 中通过引用来使用数据而不获取所有权的机制。就像从图书馆借书——你可以阅读书的内容,但书还是图书馆的,到期后要归还。在 Rust 中,创建一个引用(&T 或 &mut T)就是在借用数据,借用期间所有者仍然保持对数据的所有权。

rust
fn main() {
    let s = String::from("hello");

    // 创建引用就是借用
    let r = &s;  // r 借用了 s 的数据
    println!("借用: {}", r);

    // s 仍然是所有者
    println!("所有者: {}", s);

    // 借用结束后(r 不再使用),s 可以自由操作
}

借用 vs 所有权转移 ​

方式语法所有权变化原变量
移动(所有权转移)let b = a;a → ba 不可用
不可变借用let r = &a;a 不变a 可用(不可修改)
可变借用let r = &mut a;a 不变a 暂时不可用
克隆let b = a.clone();a 不变a 可用
rust
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 ​

不可变借用允许读取数据但不能修改。可以同时存在多个不可变借用。

rust
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 ​

可变借用允许读取和修改数据,但同一时间只能有一个可变借用。

rust
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 的借用检查器在编译期强制执行以下规则:

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 会成为悬垂引用
}

借用与函数 ​

rust
// 不可变借用:函数只读取数据
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);
}

重借用 ​

在持有可变借用时,可以临时创建不可变借用(重借用),让其他代码临时读取数据。

rust
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);
}

基本示例 ​

用借用实现一个文本分析工具:

rust
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(非词法生命周期)下,借用在最后一次使用引用时结束,而不是在引用变量离开作用域时。这让很多实际代码模式变得可行。

rust
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 中最常用的数据传递方式,应该优先于所有权转移和克隆。