关于引用的可变性和引用所引用的值的可变性有些困惑

如何解决关于引用的可变性和引用所引用的值的可变性有些困惑

我知道Rust引用很像C指针，而且我一直认为Rust引用是C指针。经过一些实验和搜索，我很困惑。

我熟悉C语言，并且已经读过What's the difference between placing “mut” before a variable name and after the “:”?，其中提供了下表：

// Rust          C/C++
    a: &T     == const T* const a; // can't mutate either
mut a: &T     == const T* a;       // can't mutate what is pointed to
    a: &mut T == T* const a;       // can't mutate pointer
mut a: &mut T == T* a;             // can mutate both

帖子已被投票，所以我认为它是正确的。

我编写了以下Rust代码

fn main() {
    let mut x = 10;
    let x1 = &mut x;
    let x2 = &x1;
    let x3 = &x2;
    ***x3 = 20;
}

希望它等同于以下C代码

int main() {
    int x = 10;
    int *const x1 = &x;
    int *const *const x2 = &x1;
    int *const *const *const x3 = &x2;
    ***x3 = 20;
    return 0;
}

Rust代码无法编译：

error[E0594]: cannot assign to `***x3` which is behind a `&` reference
 --> src/main.rs:6:5
  |
6 |     ***x3 = 20;
  |     ^^^^^^^^^^ cannot assign

这是怎么了？

奇怪的是，下面的代码可以编译！

fn main() {
    let mut x = 10;
    let mut x1 = &mut x;
    let mut x2 = &mut x1;
    let mut x3 = &mut x2;
    ***x3 = 20;
}

为什么应该使用let mut x1/2/3而不是let x1/2/3？我认为let x1 = &mut x是指向可变变量x的常量指针，但是在Rust中似乎并不正确。是Stack Overflow发布不准确还是我误会了？

解决方法

Rust和C之间有一些区别，这些区别没有出现在您所引用的表格中。

1. 在Rust中，mutability is a property of the binding rather than of the type。

2. Rust具有严格的别名规则，因此一次对任何变量的可变引用不能超过一个。

您的问题（简化）是：为什么我不能对可变变量进行不可更改的引用，并通过该变量对其进行变异。但是，如果可以这样做，您可能还会有两个引用可用于修改变量，如下所示：

let mut x = 10;
let x1 = &mut x;

let x2 = &x1;     // Non mutable reference to x1,ok
let x3 = &x1;     // Another non mutable reference to x1,ok

**x2 = 20;        // uhoh,now I can mutate 'x' via two references ... !
**x3 = 30;

---

关于相当于给定Rust代码的C语言-您尚未根据表格进行翻译。考虑一下：

let x2 = &x1;

在您引用的答案中的表格中：

a: &T == const T* const a; // Can't modify either

在这种情况下，T为const int*。因此，它将是：

const int* const* const x2 = &x1;

您的整个程序将是：

int main() {
    // let mut x = 10;
    int x = 10;

    // let x1 = &mut x;
    // a: &mut T == T* const a with T=int
    int* const x1 = &x;

    // let x2 = &x1;
    // a: &T     == const T* const a with T = int* const
    const int* const* const x2 = (const int* const* const) &x1;

    // let x3 = &x2;
    // a: &T     == const T* const a with T = const int* const* const
    const const int* const* const* const x3 = &x2;

    ***x3 = 20;
    return 0;
}

请注意，需要进行强制转换以避免在x2分配中出现警告。这是一条重要线索：我们正在为指向对象的对象有效地添加常量性。

如果您尝试编译，则会得到：

t.c: In function ‘main’:
t.c:17:11: error: assignment of read-only location ‘***x3’
     ***x3 = 20;
           ^

,

在Rust中有点不同。 ＆符号表示对某物的引用，而*符号表示对某物的取消引用。如果我的记忆正确，则C / C ++语法会使用'->'符号（这是一种取消引用的符号），该符号不会出现在Rust中。

Rust中最难的部分是跟踪谁借用了什么。一旦了解了它的工作原理，并了解了哪些数据类型利用了哪些数据类型（例如，Vec！利用了堆）：您应该非常精通Rust！