mut 可变性修饰 ​

什么是 mut ​

mut 是 Rust 中的可变性修饰关键字,放在变量名前面,表示这个变量绑定的值允许被修改。因为 Rust 的变量默认是不可变的,当你确实需要改变一个变量的值时,必须在声明时显式加上 mut。

这不是 Rust 在刁难你,而是一种"显式声明意图"的设计。当你在代码里看到 let mut x = 5;,一眼就能知道 x 后面会被修改;看到 let x = 5;,就知道 x 从头到尾不会变。这种信息对阅读和理解代码非常有价值。

rust
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 只影响变量本身的可变性,不影响值的类型。你可以修改值,但不能改变类型。

rust
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 变量上调用。

rust
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 类型)或者是所有权转移过来的值。

rust
// 参数 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 在引用中有两层含义,容易搞混:

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

基本示例 ​

一个实际的例子——统计文本中单词的出现次数:

rust
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"的原则,写出的代码会更安全、更容易理解。