不可变引用 &T ​

核心概念 ​

不可变引用 &T 是 Rust 中最常用的引用形式,它允许你读取数据但不能修改数据。不可变引用本身是 Copy 的——复制引用只是复制指针,不复制数据。在同一时间可以存在任意数量的不可变引用,这让多处代码能同时安全地读取同一份数据。

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

    // 创建不可变引用
    let r1 = &s;
    let r2 = &s;
    let r3 = &s;

    // 多个不可变引用同时存在,完全合法
    println!("{}, {}, {}", r1, r2, r3);

    // 通过引用不能修改数据
    // r1.push_str(" world");  // 编译错误

    // 原始变量仍然有效
    println!("原始: {}", s);
}

不可变引用作为函数参数 ​

函数参数使用 &T 是最常见的数据传递方式——读取数据但不获取所有权。

rust
// 接受 String 的不可变引用
fn string_info(s: &String) {
    println!("内容: '{}', 长度: {}, 容量: {}", s, s.len(), s.capacity());
}

// 接受字符串切片(更通用)
fn word_count(text: &str) -> usize {
    text.split_whitespace().count()
}

// 接受 Vec 的不可变引用
fn sum_of(numbers: &Vec<i32>) -> i32 {
    numbers.iter().sum()
}

// 接受切片引用(更通用)
fn average(data: &[f64]) -> f64 {
    if data.is_empty() {
        return 0.0;
    }
    let total: f64 = data.iter().sum();
    total / data.len() as f64
}

fn main() {
    let s = String::from("hello world foo bar");
    string_info(&s);
    println!("单词数: {}", word_count(&s));
    println!("s 仍然有效: {}", s);

    let nums = vec![10, 20, 30, 40];
    println!("总和: {}", sum_of(&nums));

    let scores = vec![85.0, 92.5, 78.0, 95.0, 88.5];
    println!("平均分: {:.1}", average(&scores));
    println!("scores 仍然有效: {:?}", scores);
}

自动解引用 Deref ​

Rust 的自动解引用(Deref coercion)让引用的使用非常自然——在很多地方你不需要手动解引用。

rust
fn main() {
    let s = String::from("Hello, Rust!");
    let r: &String = &s;

    // 自动解引用:通过 &String 直接调用 String 的方法
    println!("长度: {}", r.len());         // 等同于 (*r).len()
    println!("大写: {}", r.to_uppercase());
    println!("包含: {}", r.contains("Rust"));

    // Deref coercion:&String 自动转为 &str
    let r2: &str = &s;  // String → &str(通过 Deref)
    println!("切片: {}", r2);

    // 多层引用也能自动解引用
    let r3 = &&&&s;
    println!("多层引用: {}", r3.len());  // 自动解引用到 String

    // 比较运算也自动解引用
    let a = String::from("hello");
    let b = String::from("hello");
    assert_eq!(&a, &b);  // 比较的是内容,不是地址
}

&String vs &str ​

函数参数推荐使用 &str 而不是 &String,因为 &str 更通用。

rust
// 不推荐:只接受 &String
fn greet_string(name: &String) {
    println!("你好, {}!", name);
}

// 推荐:接受 &str,更通用
fn greet_str(name: &str) {
    println!("你好, {}!", name);
}

fn main() {
    let owned = String::from("张三");
    let literal = "李四";
    let slice = &owned[..2];

    // &String 版本只能接受 &String
    greet_string(&owned);
    // greet_string(literal);  // 编译错误:类型不匹配
    // greet_string(slice);    // 编译错误

    // &str 版本都能接受
    greet_str(&owned);    // &String 自动 Deref 为 &str
    greet_str(literal);   // &str 直接传
    greet_str(slice);     // &str 直接传
}
参数类型能接受 &String能接受 &str能接受字面量推荐度
&String能不能不能不推荐
&str能(自动 Deref)能能推荐

同理:

参数类型能接受 &Vec能接受 &[T]推荐度
&Vec<T>能不能不推荐
&[T]能(自动 Deref)能推荐

引用的生命周期 ​

不可变引用不能超过被引用数据的生命周期。

rust
fn main() {
    // 正确:引用在数据有效范围内
    let s = String::from("hello");
    let r = &s;
    println!("{}", r);

    // 错误示例(无法编译):
    // let r;
    // {
    //     let s = String::from("hello");
    //     r = &s;  // s 在这个块结束时被销毁
    // }
    // println!("{}", r);  // r 成了悬垂引用

    // 正确:返回输入的引用
    let s1 = String::from("hello");
    let s2 = String::from("hi");
    let longer = longest(&s1, &s2);
    println!("更长: {}", longer);
}

fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() > b.len() { a } else { b }
}

基本示例 ​

用不可变引用实现一个学生成绩查询系统:

rust
#[derive(Debug)]
struct Student {
    name: String,
    scores: Vec<(String, f64)>,  // (科目, 分数)
}

impl Student {
    fn new(name: &str) -> Self {
        Student {
            name: name.to_string(),
            scores: Vec::new(),
        }
    }

    fn add_score(&mut self, subject: &str, score: f64) {
        self.scores.push((subject.to_string(), score));
    }
}

// 以下函数全部使用不可变引用,不影响原数据

fn get_average(student: &Student) -> f64 {
    if student.scores.is_empty() {
        return 0.0;
    }
    let total: f64 = student.scores.iter().map(|(_, s)| s).sum();
    total / student.scores.len() as f64
}

fn get_highest(student: &Student) -> Option<(&str, f64)> {
    student.scores.iter()
        .max_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
        .map(|(subj, score)| (subj.as_str(), *score))
}

fn get_lowest(student: &Student) -> Option<(&str, f64)> {
    student.scores.iter()
        .min_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
        .map(|(subj, score)| (subj.as_str(), *score))
}

fn is_pass(student: &Student, threshold: f64) -> bool {
    student.scores.iter().all(|(_, s)| *s >= threshold)
}

fn print_report(student: &Student) {
    println!("\n=== {} 的成绩单 ===", student.name);
    for (subject, score) in &student.scores {
        let grade = match *score as u32 {
            90..=100 => "优秀",
            80..=89 => "良好",
            70..=79 => "中等",
            60..=69 => "及格",
            _ => "不及格",
        };
        println!("  {}: {:.1} ({})", subject, score, grade);
    }
    println!("  平均分: {:.1}", get_average(student));
    if let Some((subj, score)) = get_highest(student) {
        println!("  最高: {} ({:.1})", subj, score);
    }
    if let Some((subj, score)) = get_lowest(student) {
        println!("  最低: {} ({:.1})", subj, score);
    }
    println!("  全部及格: {}", if is_pass(student, 60.0) { "是" } else { "否" });
}

// 比较两个学生的平均分
fn compare_students(a: &Student, b: &Student) {
    let avg_a = get_average(a);
    let avg_b = get_average(b);
    println!("\n{} 平均 {:.1} vs {} 平均 {:.1}",
        a.name, avg_a, b.name, avg_b);
    if avg_a > avg_b {
        println!("{} 的平均分更高", a.name);
    } else if avg_b > avg_a {
        println!("{} 的平均分更高", b.name);
    } else {
        println!("两人平均分相同");
    }
}

fn main() {
    let mut alice = Student::new("Alice");
    alice.add_score("数学", 95.0);
    alice.add_score("语文", 88.0);
    alice.add_score("英语", 92.0);

    let mut bob = Student::new("Bob");
    bob.add_score("数学", 78.0);
    bob.add_score("语文", 85.0);
    bob.add_score("英语", 55.0);

    // 多次不可变借用:同时传两个引用
    print_report(&alice);
    print_report(&bob);
    compare_students(&alice, &bob);

    // 原数据始终有效
    println!("\nAlice 的科目数: {}", alice.scores.len());
    println!("Bob 的科目数: {}", bob.scores.len());
}

常见问题 ​

问题一:不可变引用的大小是多少?

普通引用 &T 是一个指针大小(64 位系统上 8 字节)。胖引用(&[T]、&str、&dyn Trait)是两个指针大小(16 字节),包含数据指针和元数据(长度或 vtable)。

问题二:不可变引用存在时能移动原值吗?

不能。不可变引用存在期间,被引用的值不能被移动或销毁,因为这会导致引用悬垂。

rust
fn main() {
    let s = String::from("hello");
    let r = &s;
    // let s2 = s;  // 编译错误:s 被借用中,不能移动
    println!("{}", r);
    // r 不再使用后(NLL),s 可以被移动
    let s2 = s;
    println!("{}", s2);
}

问题三:引用可以存储在结构体中吗?

可以,但需要标注生命周期,保证引用不会超过被引用数据的生命周期。

rust
struct Excerpt<'a> {
    text: &'a str,  // 存储引用,需要生命周期标注
}

fn main() {
    let novel = String::from("很久以前。有一个国王。");
    let excerpt = Excerpt { text: &novel[..12] };
    println!("摘录: {}", excerpt.text);
}

问题四:&T 是线程安全的吗?

&T 是 Send 和 Sync 的(只要 T 是 Sync 的),可以安全地在线程之间共享。多个线程同时只读地访问同一数据是安全的。

适用场景 ​

  • 函数参数:只需要读取数据时传 &T 或 &str/&[T]
  • 多处共享:多个变量或函数同时读取同一数据
  • 结构体字段:存储对外部数据的引用(需要生命周期标注)
  • 方法 &self:不修改对象状态的方法

注意事项 ​

  • 不可变引用不能修改被引用的数据
  • 多个不可变引用可以同时存在
  • 不可变引用存在时不能创建可变引用
  • 不可变引用本身是 Copy 的
  • 函数参数优先用 &str 而不是 &String
  • 函数参数优先用 &[T] 而不是 &Vec<T>
  • 引用不能超过被引用值的生命周期

总结 ​

不可变引用 &T 允许读取数据而不获取所有权,是 Rust 中使用最频繁的引用形式。它的核心特点是:可以同时存在任意数量的不可变引用,但不能通过不可变引用修改数据。函数参数推荐使用更通用的切片形式(&str 代替 &String、&[T] 代替 &Vec<T>)。不可变引用本身是 Copy 的,复制引用不复制数据。Rust 的自动解引用机制让使用引用的体验和直接使用值几乎一样自然。