【rust】mut用法

mut用法

Rust 中的 `mut` 表示“可变（mutable）”。Rust 默认变量不可修改，只有显式加上 `mut` 后，才允许修改该变量绑定的值。

1. 可变变量

Rust 默认变量是不可变的：

fn main() {
    let a = 10;

    // a = 20; // 编译错误
}

如果需要修改变量，就在变量绑定前加 `mut`：

fn main() {
    let mut a = 10;

    a = 20;

    println!("{}", a);
}

输出：

20

可以简单理解为：`let mut a` 表示变量 `a` 后续允许被重新赋值或修改。

2. 可变引用 &mut

如果希望函数修改调用者传入的数据，需要使用可变引用 `&mut`。

fn add_one(value: &mut i32) {
    *value += 1;
}

fn main() {
    let mut a = 10;

    add_one(&mut a);

    println!("{}", a);
}

这里有三个关键点：

let mut a = 10;

表示 `a` 本身允许修改。

&mut a

表示创建一个指向 `a` 的可变引用，把修改 `a` 的权限借给其他代码。

value: &mut i32

表示函数参数接收一个 `i32` 的可变引用，因此函数内部可以通过 `*value` 修改原值。

3. struct 整体可变

如果一个结构体变量需要修改字段，通常需要让整个变量绑定可变。

struct User {
    age: u32,
}

fn main() {
    let mut user = User {
        age: 18,
    };

    user.age = 20;
}

如果没有 `mut`：

let user = User {
    age: 18,
};

// user.age = 20; // 编译错误

struct User {
    age: u32,
}

fn main() {
    let mut user = User {
        age: 18,
    };

    user.age = 20;
}

如果没有 `mut`：

let user = User {
    age: 18,
};

// user.age = 20; // 编译错误

4. Vec、HashMap 等容器修改

会修改容器内容的方法，例如 `Vec::push()`、`HashMap::insert()`，要求容器变量本身是可变的。

let mut v = Vec::new();

v.push(1);
v.push(2);

use std::collections::HashMap;

let mut map = HashMap::new();

map.insert("a", 1);
map.insert("b", 2);

5. mut 与变量遮蔽（shadowing）的区别

下面代码虽然没有 `mut`，但仍然合法：

let a = 10;
let a = 20;

这是变量遮蔽（shadowing）：第二个 `let a` 创建了一个新的变量绑定，并不是修改原来的变量。

而下面才是修改同一个变量：

let mut a = 10;
a = 20;

对比

写法	含义	是否同一变量
let a = 10; let a = 20;	变量遮蔽，创建新的 a	否
let mut a = 10; a = 20;	修改原来的 a	是

6. mut 在 match / if let 中

在模式匹配中，`mut` 可以让匹配出来的新变量绑定变成可变。

let value = Some(10);

if let Some(mut x) = value {
    x += 1;
    println!("{}", x);
}

这里的 `Some(mut x)` 表示取出的 `x` 可以被修改。对于 `i32` 这种实现了 `Copy` 的类型，`x` 是复制出来的新值，所以修改 `x` 不会修改原来的 `value`。

7. 最容易混淆的三个写法

let mut a = 10;

含义：`a` 可以修改。

let r = &mut a;

含义：`r` 是指向 `a` 的可变引用，可以通过 `r` 修改 `a`。

fn foo(a: &mut i32)

含义：`foo` 接收一个可变引用，因此可以修改调用者传入的 `i32`。

完整示例

fn modify(value: &mut i32) {
    *value = 100;
}

fn main() {
    let mut a = 10;

    modify(&mut a);

    println!("{}", a);
}

最终输出 `100`。

8. 一句话记忆

mut = 允许修改；&mut = 借出去，并允许对方修改。

进一步学习 Rust 时，建议把 `mut` 和所有权、借用规则一起理解，尤其是“为什么同一时间通常不能存在两个指向同一数据的 `&mut` 引用”。