rust-course/contents/pitfalls/the-disabled-mutability.md

失效的可变性

众所周知 Rust 是一门安全性非常强的系统级语言，其中，显式的设置变量可变性，是安全性的重要组成部分。按理来说，变量可变不可变在设置时就已经决定了，但是你遇到过可变变量在某些情况失效，变成不可变吗？

先来看段正确的代码：

#[derive(Debug)]
struct A {
    f1: u32,
    f2: u32,
    f3: u32
}

#[derive(Debug)]
struct B<'a> {
    f1: u32,
    a: &'a mut A,
}

fn main() {
    let mut a: A = A{ f1: 0, f2: 1, f3: 2 };
    // b不可变
    let b: B = B{ f1: 3, a: &mut a };
    // 但是b中的字段a可以变
    b.a.f1 += 1;
    
    println!("b is {:?} ", &b);
}

在这里，虽然变量b被设置为不可变，但是b的其中一个字段a被设置为可变的结构体，因此我们可以通过b.a.f1 += 1来修改a的值。

也许有人还不知道这种部分可变性的存在，不过没关系，因为马上就不可变了：)

• 结构体可变时，里面的字段都是可变的，例如&mut a
• 结构体不可变时，里面的某个字段可以单独设置为可变，例如b.a

在理解了上面两条简单规则后，来看看下面这段代码:

#[derive(Debug)]
struct A {
    f1: u32,
    f2: u32,
    f3: u32
}

#[derive(Debug)]
struct B<'a> {
    f1: u32,
    a: &'a mut A,
}


impl B<'_> {
    // this will not work
    pub fn changeme(&self) {
        self.a.f1 += 1;
    }
}

fn main() {
    let mut a: A = A{ f1: 0, f2: 1, f3: 2 };
    // b is immutable
    let b: B = B{ f1: 3, a: &mut a };
    b.changeme();
    
    println!("b is {:?} ", &b);
}

这段代码，仅仅做了一个小改变，不再直接修改b.a，而是通过调用b上的方法去修改其中的a，按理说不会有任何区别。因此我预言：通过方法调用跟直接调用不应该有任何区别，运行验证下：

error[E0594]: cannot assign to `self.a.f1`, which is behind a `&` reference
  --> src/main.rs:18:9
   |
17 |     pub fn changeme(&self) {
   |                     ----- help: consider changing this to be a mutable reference: `&mut self`
18 |         self.a.f1 += 1;
   |         ^^^^^^^^^^^^^^ `self` is a `&` reference, so the data it refers to cannot be written

啪，又被打脸了。我说我是大意了，没有闪，大家信不？反正马先生应该是信的:D

简单分析

观察第一个例子，我们调用的b.a实际上是用b的值直接调用的，在这种情况下，由于所有权规则，编译器可以认定，只有一个可变引用指向了a，因此这种使用是非常安全的。

但是，在第二个例子中，b被藏在了&后面，根据所有权规则，同时可能存在多个b的借用，那么就意味着可能会存在多个可变引用指向a,因此编译器就拒绝了这段代码。

事实上如果你将第一段代码的调用改成:

let b: &B = &B{ f1: 3, a: &mut a };
b.a.f1 += 1;

一样会报错！

一个练习

结束之前再来一个练习，稍微有点绕，大家品味品味：

#[derive(Debug)]
struct A {
    f1: u32,
    f2: u32,
    f3: u32
}

#[derive(Debug)]
struct B<'a> {
    f1: u32,
    a: &'a mut A,
}

fn main() {
    let mut a: A = A{ f1: 0, f2: 1, f3: 2 };
    let b: B = B{ f1: 3, a: &mut a };
    b.a.f1 += 1;
    a.f1 = 10;
    
    println!("b is {:?} ", &b);
}

小提示：这里b.a.f1 += 1和a.f1 = 10只能有一个存在，否则就会报错。

总结

根据之前的观察和上面的小提示，可以得出一个结论：可变性的真正含义是你对目标对象的独占修改权。在实际项目中，偶尔会遇到比上述代码更复杂的可变性情况，记住这个结论，有助于我们拨云见日，直达本质。

学习，就是不断接近和认识事物本质的过程，对于 Rust 语言的学习亦是如此。