为什么 Rust 允许使用不可变绑定通过引用字段进行突变？

Question

如果我有一个绑定到结构的不可变变量，Rust 通常不允许我改变结构的字段或拥有的子结构的字段。

但是，如果该字段是可变引用，Rust将允许我改变引用的对象，尽管我的绑定是不可变的。

为什么允许这样做？是不是不符合 Rust 的正常不变性规则？

Rust 不会让我通过不可变引用来做同样的事情，因此不可变引用与不可变绑定具有不同的行为。

代码示例：

struct Bar {
    val: i32,
}

struct Foo<'a> {
    val: i32,
    bar: Bar,
    val_ref: &'a mut i32,
}

fn main() {
    let mut x = 5;

    {
        let foo = Foo { 
            val: 6, 
            bar: Bar { val: 15 },
            val_ref: &mut x
        };

        // This is illegal because binding is immutable
        // foo.val = 7;

        // Also illegal to mutate child structures
        // foo.bar.val = 20;

        // This is fine though... Why?
        *foo.val_ref = 10;

        let foo_ref = &foo;

        // Also illegal to mutate through an immutable reference
        //*foo_ref.val_ref = 10;
    }

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

Answer 1

解释这一点的简短方法是 references 中的可变性和 变量 中的可变性是相互正交的。这两种形式的可变性是相关的，因为我们只能从可变变量（或绑定）中可变地借用某些东西。除此之外，Rust 中的每个二进制组合都是可能的：

               reference mutability
            -----------------------------
variable   |     x: &T  |      x: &mut T |
mutability |------------+----------------|
           | mut x: &T  |  mut x: &mut T |
            -----------------------------

我们可以想出许多代码示例来举例说明使用这样的变量 x 可以做什么。例如，可变引用的不可变变量可以修改另一个元素，但不能修改自身：

let mut a = 5;
let mut b = 3;
let x: &mut i32 = &mut a;

*x = 10; // ok

x = &mut b; // nope! [E0384]
*x = 6;

即使作为结构中的字段，这也不会与 Rust 的安全保证冲突。如果变量不可变地绑定到结构值，则每个字段也将是不可变的。在这个例子中：

let mut x = 5;
let foo = Foo { 
    val: 6, 
    bar: Bar { val: 15 },
    val_ref: &mut x
};
*foo.val_ref = 10;

这里没有对foo 应用任何突变：foo.val_ref 仍然指向x。前者可以变异，因为它是可变借用的。 引用被独立地借用检查。Foo 中的生命周期参数'a 使编译器能够跟踪借用。

第二个示例（如下所示）不起作用，因为从&Foo，我们只能检索对其字段的引用（例如val_ref: &mut i32）。反过来，为了防止混叠，&&mut i32 只能强制转换为 &i32。不能通过不可变引用可变地借用数据。

let foo_ref = &foo;
*foo_ref.val_ref = 10; // error[E0389]

Rust 不允许我通过不可变引用来做同样的事情。因此，不可变引用与不可变绑定具有不同的行为。

没错！

另请参阅：

• What's the difference between placing "mut" before a variable name and after the ":"?

• How to mutably borrow reference from &&mut Foo?

• Mutable borrow automatically changes to immutable?