可变引用 &mut T ​

核心概念 ​

可变引用 &mut T 允许你通过引用修改被引用的数据,同时不获取数据的所有权。可变引用是独占的——同一时间对同一数据只能存在一个可变引用,并且可变引用存在时不能有任何不可变引用。这种独占性从编译期就杜绝了数据竞争。

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

    // 创建可变引用
    let r = &mut s;

    // 通过可变引用修改数据
    r.push_str(" world");
    println!("修改后: {}", r);

    // 可变引用结束后,原变量可以再次使用
    println!("原始变量: {}", s);
}

可变引用的独占规则 ​

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

    // 规则一:同一时间只能有一个可变引用
    let r1 = &mut data;
    // let r2 = &mut data;  // 编译错误:不能同时有两个可变引用
    r1.push_str("!");
    println!("{}", r1);

    // r1 不再使用(NLL),可以创建新的可变引用
    let r2 = &mut data;
    r2.push_str("!");
    println!("{}", r2);

    // 规则二:可变引用存在时不能有不可变引用
    let mut s = String::from("world");
    // let r_imm = &s;
    // let r_mut = &mut s;  // 编译错误:不能同时存在
    // println!("{}", r_imm);

    // NLL 允许的情况:不可变引用使用结束后再创建可变引用
    let r_imm = &s;
    println!("不可变: {}", r_imm);
    // r_imm 最后一次使用,借用结束
    let r_mut = &mut s;
    r_mut.push_str("!");
    println!("可变: {}", r_mut);
}

可变引用作为函数参数 ​

rust
// 通过可变引用就地修改字符串
fn to_uppercase_in_place(s: &mut String) {
    *s = s.to_uppercase();
}

// 向 Vec 中添加元素
fn push_even_numbers(v: &mut Vec<i32>, limit: i32) {
    for i in 0..=limit {
        if i % 2 == 0 {
            v.push(i);
        }
    }
}

// 通过可变引用排序
fn sort_descending(data: &mut Vec<i32>) {
    data.sort_by(|a, b| b.cmp(a));
}

// 修改结构体的字段
struct Counter {
    value: i32,
}

fn increment(counter: &mut Counter, amount: i32) {
    counter.value += amount;
}

fn main() {
    let mut name = String::from("rust");
    to_uppercase_in_place(&mut name);
    println!("大写: {}", name);

    let mut numbers = vec![1, 3, 5];
    push_even_numbers(&mut numbers, 10);
    println!("添加偶数后: {:?}", numbers);

    sort_descending(&mut numbers);
    println!("降序排列: {:?}", numbers);

    let mut counter = Counter { value: 0 };
    increment(&mut counter, 5);
    increment(&mut counter, 3);
    println!("计数器: {}", counter.value);
}

&mut self 方法 ​

结构体的方法中使用 &mut self 来修改自身状态,这是可变引用最常见的使用场景。

rust
struct BankAccount {
    owner: String,
    balance: f64,
}

impl BankAccount {
    fn new(owner: &str, initial: f64) -> Self {
        BankAccount {
            owner: owner.to_string(),
            balance: initial,
        }
    }

    // &self:只读方法
    fn balance(&self) -> f64 {
        self.balance
    }

    fn owner(&self) -> &str {
        &self.owner
    }

    // &mut self:修改方法
    fn deposit(&mut self, amount: f64) {
        if amount > 0.0 {
            self.balance += amount;
            println!("[{}] 存入 {:.2},余额 {:.2}", self.owner, amount, self.balance);
        }
    }

    fn withdraw(&mut self, amount: f64) -> Result<f64, String> {
        if amount <= 0.0 {
            return Err(String::from("金额必须大于零"));
        }
        if amount > self.balance {
            return Err(format!("余额不足(余额 {:.2},请求 {:.2})", self.balance, amount));
        }
        self.balance -= amount;
        println!("[{}] 取出 {:.2},余额 {:.2}", self.owner, amount, self.balance);
        Ok(amount)
    }

    fn transfer(&mut self, to: &mut BankAccount, amount: f64) -> Result<(), String> {
        self.withdraw(amount)?;
        to.deposit(amount);
        Ok(())
    }
}

fn main() {
    let mut alice = BankAccount::new("Alice", 1000.0);
    let mut bob = BankAccount::new("Bob", 500.0);

    alice.deposit(200.0);
    bob.deposit(100.0);

    match alice.withdraw(300.0) {
        Ok(amount) => println!("成功取出 {:.2}", amount),
        Err(e) => println!("取款失败: {}", e),
    }

    // 转账:同时可变借用两个不同的账户
    // 注意:不能用 alice.transfer(&mut bob, 100.0)
    // 因为 transfer 的 &mut self 已经借用了 alice
    // 这里直接调用方法是合法的,因为 alice 和 bob 是不同的变量

    println!("\nAlice 余额: {:.2}", alice.balance());
    println!("Bob 余额: {:.2}", bob.balance());
}

可变引用与切片 ​

rust
fn main() {
    let mut data = vec![5, 3, 8, 1, 9, 2, 7, 4, 6];

    // 可变切片引用
    let slice = &mut data[..5];  // 前 5 个元素的可变切片
    slice.sort();
    println!("前5排序: {:?}", data);

    // 通过可变引用修改切片中的元素
    let slice2 = &mut data[..];
    for item in slice2.iter_mut() {
        *item *= 2;  // 每个元素翻倍
    }
    println!("翻倍后: {:?}", data);

    // split_at_mut:安全地获取两个不重叠的可变切片
    let (left, right) = data.split_at_mut(4);
    left.sort();
    right.sort();
    println!("分别排序: {:?}", data);
}

可变引用的重借用 ​

持有可变引用时,可以临时"重借用"为不可变引用。

rust
fn display(data: &[i32]) {
    println!("当前数据: {:?}", data);
}

fn main() {
    let mut numbers = vec![3, 1, 4, 1, 5];
    let r = &mut numbers;

    // 可变引用可以临时重借用为不可变引用
    display(r);  // r 被自动重借用为 &[i32]

    // 重借用结束后,可变引用继续有效
    r.push(9);
    r.sort();
    display(r);

    println!("最终: {:?}", r);
}

基本示例 ​

用可变引用实现一个待办事项管理器:

rust
#[derive(Debug)]
enum Priority {
    High,
    Medium,
    Low,
}

#[derive(Debug)]
struct Todo {
    title: String,
    done: bool,
    priority: Priority,
}

struct TodoList {
    items: Vec<Todo>,
}

impl TodoList {
    fn new() -> Self {
        TodoList { items: Vec::new() }
    }

    // &mut self:添加待办
    fn add(&mut self, title: &str, priority: Priority) {
        self.items.push(Todo {
            title: title.to_string(),
            done: false,
            priority,
        });
    }

    // &mut self:标记完成
    fn complete(&mut self, index: usize) -> Result<(), String> {
        if let Some(item) = self.items.get_mut(index) {
            item.done = true;
            println!("已完成: {}", item.title);
            Ok(())
        } else {
            Err(format!("索引 {} 超出范围", index))
        }
    }

    // &mut self:删除已完成的待办
    fn clear_done(&mut self) -> usize {
        let before = self.items.len();
        self.items.retain(|item| !item.done);
        let removed = before - self.items.len();
        println!("清除了 {} 条已完成的待办", removed);
        removed
    }

    // &mut self:修改标题
    fn rename(&mut self, index: usize, new_title: &str) -> Result<(), String> {
        if let Some(item) = self.items.get_mut(index) {
            let old = item.title.clone();
            item.title = new_title.to_string();
            println!("重命名: '{}' -> '{}'", old, new_title);
            Ok(())
        } else {
            Err(format!("索引 {} 超出范围", index))
        }
    }

    // &self:只读显示
    fn display(&self) {
        println!("\n=== 待办列表 ({} 项) ===", self.items.len());
        for (i, item) in self.items.iter().enumerate() {
            let status = if item.done { "[x]" } else { "[ ]" };
            let priority = match item.priority {
                Priority::High => "高",
                Priority::Medium => "中",
                Priority::Low => "低",
            };
            println!("  {} {} [{}] {}", i, status, priority, item.title);
        }
    }

    // &self:统计
    fn stats(&self) -> (usize, usize) {
        let done = self.items.iter().filter(|i| i.done).count();
        (done, self.items.len() - done)
    }
}

fn main() {
    let mut list = TodoList::new();

    // 添加待办(可变借用 &mut self)
    list.add("学习 Rust 所有权", Priority::High);
    list.add("写项目文档", Priority::Medium);
    list.add("整理代码", Priority::Low);
    list.add("提交代码审查", Priority::High);

    // 显示(不可变借用 &self)
    list.display();

    // 修改操作(可变借用 &mut self)
    let _ = list.complete(0);
    let _ = list.complete(2);
    let _ = list.rename(1, "完善项目文档");

    list.display();

    let (done, pending) = list.stats();
    println!("\n已完成: {}, 待处理: {}", done, pending);

    list.clear_done();
    list.display();
}

常见问题 ​

问题一:为什么可变引用是独占的?

如果同时存在多个可变引用,两段代码可以同时修改同一份数据,导致不可预测的结果。在多线程环境中这就是数据竞争。Rust 通过独占可变引用在编译期杜绝这个问题。

问题二:&mut T 是 Copy 的吗?

不是。&mut T 不能 Copy。如果可变引用能复制,就会出现多个可变引用同时存在的情况,违反独占规则。

问题三:变量需要先声明为 mut 才能创建可变引用吗?

是的。只有 let mut x 声明的变量才能创建 &mut x。对不可变变量创建可变引用会编译错误。

问题四:能同时可变借用结构体的不同字段吗?

编译器通常能识别对不同字段的借用是不冲突的,允许同时可变借用不同字段。但通过方法调用(&mut self)无法做到这一点,因为 &mut self 借用了整个结构体。

rust
struct Pair {
    first: String,
    second: String,
}

fn main() {
    let mut pair = Pair {
        first: String::from("hello"),
        second: String::from("world"),
    };

    // 直接借用不同字段:合法
    let r1 = &mut pair.first;
    let r2 = &mut pair.second;
    r1.push('!');
    r2.push('!');
    println!("{}, {}", r1, r2);
}

适用场景 ​

  • 就地修改:修改集合内容、更新字段值
  • &mut self 方法:修改结构体自身状态
  • 排序和变换:sort()、retain()、dedup() 等方法
  • 可变切片操作:批量修改数组/向量的元素
  • 累加器/构建器:逐步构建数据

注意事项 ​

  • 同一时间只能有一个可变引用
  • 可变引用存在时不能有不可变引用
  • 创建 &mut T 要求变量本身是 mut 的
  • &mut T 不是 Copy 的
  • NLL 让可变引用在最后一次使用后结束
  • 对不同字段的可变借用不冲突
  • 可变引用可以临时重借用为不可变引用

总结 ​

可变引用 &mut T 允许通过引用修改数据而不获取所有权。它的核心特点是独占性——同一时间对同一数据只能有一个可变引用,并且不能与不可变引用共存。这种独占规则在编译期就消除了数据竞争的可能性。可变引用最常见的使用场景是结构体方法中的 &mut self、函数参数中的就地修改、以及可变切片操作。&mut T 不是 Copy 的(保证独占性),但可以临时重借用为不可变引用。NLL 机制让可变引用在最后一次使用后就结束,增加了实际编码的灵活性。