可变引用 &mut T
核心概念
可变引用 &mut T 允许你通过引用修改被引用的数据,同时不获取数据的所有权。可变引用是独占的——同一时间对同一数据只能存在一个可变引用,并且可变引用存在时不能有任何不可变引用。这种独占性从编译期就杜绝了数据竞争。
fn main() {
let mut s = String::from("hello");
// 创建可变引用
let r = &mut s;
// 通过可变引用修改数据
r.push_str(" world");
println!("修改后: {}", r);
// 可变引用结束后,原变量可以再次使用
println!("原始变量: {}", s);
}可变引用的独占规则
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);
}可变引用作为函数参数
// 通过可变引用就地修改字符串
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 来修改自身状态,这是可变引用最常见的使用场景。
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());
}可变引用与切片
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);
}可变引用的重借用
持有可变引用时,可以临时"重借用"为不可变引用。
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);
}基本示例
用可变引用实现一个待办事项管理器:
#[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 借用了整个结构体。
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 机制让可变引用在最后一次使用后就结束,增加了实际编码的灵活性。