mut 可变性修饰
什么是 mut
mut 是 Rust 中的可变性修饰关键字,放在变量名前面,表示这个变量绑定的值允许被修改。因为 Rust 的变量默认是不可变的,当你确实需要改变一个变量的值时,必须在声明时显式加上 mut。
这不是 Rust 在刁难你,而是一种"显式声明意图"的设计。当你在代码里看到 let mut x = 5;,一眼就能知道 x 后面会被修改;看到 let x = 5;,就知道 x 从头到尾不会变。这种信息对阅读和理解代码非常有价值。
fn main() {
// 不可变变量:绑定后不能修改
let x = 5;
// x = 10; // 编译错误:cannot assign twice to immutable variable
// 可变变量:加了 mut,允许修改值
let mut y = 5;
println!("修改前 y = {}", y);
y = 10; // 合法,因为 y 声明为 mut
println!("修改后 y = {}", y);
y += 5; // 复合赋值也可以
println!("再次修改 y = {}", y);
}mut 的作用范围
mut 只影响变量本身的可变性,不影响值的类型。你可以修改值,但不能改变类型。
fn main() {
let mut count = 0;
// 可以修改值
count = 1;
count = 2;
// 但不能改变类型
// count = "hello"; // 编译错误:expected integer, found &str
// mut 也可以用在更复杂的类型上
let mut name = String::from("hello");
println!("修改前:{}", name);
// String 类型有很多修改自身的方法,需要 mut 才能调用
name.push_str(", world"); // push_str 要求 &mut self
println!("修改后:{}", name);
// Vec 也是一样,push 需要 mut
let mut numbers = vec![1, 2, 3];
numbers.push(4);
numbers.push(5);
println!("数组:{:?}", numbers);
}mut 与方法调用
很多类型的方法分为两类:需要 &self(不可变引用)的方法和需要 &mut self(可变引用)的方法。后者只能在 mut 变量上调用。
fn main() {
// 不可变的 String
let s = String::from("hello");
println!("长度:{}", s.len()); // len() 只需要 &self,没问题
// s.push('!'); // 编译错误:push() 需要 &mut self,但 s 不是 mut
// 可变的 String
let mut s = String::from("hello");
s.push('!'); // 现在可以了
s.push_str(" world");
println!("{}", s);
// 不可变的 Vec
let v = vec![1, 2, 3];
println!("第一个元素:{}", v[0]); // 索引访问只需要 &self
// v.push(4); // 编译错误
// 可变的 Vec
let mut v = vec![1, 2, 3];
v.push(4);
v.pop();
v.sort();
println!("{:?}", v);
}函数参数中的 mut
函数参数也可以声明为 mut,表示在函数体内可以修改这个参数的值。注意,这不会影响调用者的原始数据——参数是按值传递的副本(对于 Copy 类型)或者是所有权转移过来的值。
// 参数 n 声明为 mut,可以在函数内部修改
fn countdown(mut n: i32) {
while n > 0 {
println!("{}...", n);
n -= 1; // 修改参数值
}
println!("发射!");
}
// 参数 s 获取了 String 的所有权,声明为 mut 后可以修改
fn append_greeting(mut s: String) -> String {
s.push_str(", 你好!");
s // 返回修改后的 String
}
fn main() {
let num = 3;
countdown(num);
// num 本身没有被修改(i32 是 Copy 类型,传的是副本)
println!("num 仍然是:{}", num);
let name = String::from("Rust");
let greeting = append_greeting(name);
// name 的所有权已经移走了,这里不能再用 name
println!("{}", greeting);
}mut 与引用
mut 在引用中有两层含义,容易搞混:
fn main() {
let mut x = 5;
// &x:不可变引用,只能读不能改
let r1 = &x;
println!("通过不可变引用读取:{}", r1);
// &mut x:可变引用,可以通过引用修改原始值
let r2 = &mut x;
*r2 = 10; // 通过可变引用修改 x 的值
println!("修改后 x = {}", x);
// 注意区分:
// let mut r = &x; -> r 本身可变(可以指向别的值),但不能通过 r 修改 x
// let r = &mut x; -> r 本身不可变,但可以通过 r 修改 x
// let mut r = &mut x; -> r 本身可变,也可以通过 r 修改 x
}| 声明方式 | 能否重新绑定引用 | 能否通过引用修改值 |
|---|---|---|
let r = &x | 不能 | 不能 |
let mut r = &x | 能 | 不能 |
let r = &mut x | 不能 | 能 |
let mut r = &mut x | 能 | 能 |
基本示例
一个实际的例子——统计文本中单词的出现次数:
use std::collections::HashMap;
fn main() {
let text = "hello world hello rust hello world";
// 需要 mut,因为要不断往 HashMap 里插入数据
let mut word_count: HashMap<&str, i32> = HashMap::new();
// 遍历每个单词
for word in text.split_whitespace() {
// entry() 返回一个入口,or_insert() 在键不存在时插入默认值
// 返回的是值的可变引用
let count = word_count.entry(word).or_insert(0);
*count += 1; // 通过可变引用增加计数
}
println!("单词统计:{:?}", word_count);
// 输出类似:{"hello": 3, "world": 2, "rust": 1}
}常见问题
问题一:什么时候该加 mut,什么时候不该加?
原则很简单:只在你确实需要修改变量值的时候才加 mut。如果一个变量从声明到最后一次使用都不会改变,就不要加。编译器会在你忘记加 mut 时报错,也会在你多加了 mut 但实际没修改时给出警告(warning: variable does not need to be mutable)。
问题二:let mut x = 5; 和 let x = 5; let x = 10;(遮蔽)有什么区别?
| 对比 | let mut x | 变量遮蔽 let x |
|---|---|---|
| 本质 | 同一个变量,修改值 | 创建全新变量,覆盖旧的 |
| 类型改变 | 不能改变类型 | 可以改变类型 |
| 旧值处理 | 被覆盖 | 如果有堆数据,旧值会被 Drop |
| 语义 | "这个值会变" | "重新计算一个新值" |
问题三:编译器提示 help: consider changing this to be mutable 是什么意思?
这说明你试图修改一个不可变变量。按照提示在变量声明时加上 mut 就行。Rust 编译器的错误提示通常都很准确,跟着改就对了。
适用场景
- 循环计数器:
let mut i = 0; while i < 10 { i += 1; } - 累加器:
let mut sum = 0; for n in numbers { sum += n; } - 动态构建集合:
let mut vec = Vec::new(); vec.push(item); - 状态机:变量表示当前状态,随着程序运行不断变化
- 缓冲区:读取数据到可变缓冲区
let mut buf = String::new(); - 迭代修改:需要在遍历过程中修改数据结构
注意事项
- 不必要的
mut会触发编译器警告,保持代码整洁应该去掉多余的mut mut是浅层的——let mut v = vec![vec![1]];里外层 Vec 可变,但不代表内层 Vec 自动可变- 函数参数的
mut只影响函数内部,不影响调用者 - 引用的
mut要区分"引用本身可变"和"引用指向的值可变"两种情况 - 在并发编程中,
mut变量不能直接跨线程共享,需要配合Mutex等同步原语 - 方法签名中
&self和&mut self决定了方法能否修改结构体的字段
总结
mut 是 Rust 中显式声明变量可变性的关键字。Rust 变量默认不可变,只有加了 mut 的变量才能在声明后修改值。这种设计让代码的意图更加清晰——看到 mut 就知道这个变量后面会被修改。mut 可以用在局部变量、函数参数、引用等多种场景中。在引用上下文中需要注意区分"引用本身是否可变"和"引用指向的值是否可变"两个维度。遵循"需要时才加 mut"的原则,写出的代码会更安全、更容易理解。