关于引用的可变性和引用引用的值的可变性的一些混淆

Question

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

我熟悉 C 并且我读过，它给出了以下 table：

// 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

post 已投票，所以我认为它是正确的。

我写了下面的 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 是一个指向 mutable 变量 x 的常量指针，但它在 Rust 中似乎并不正确。是 Stack Overflow post 不准确还是我误解了它？

Answer 1

Rust 和 C 之间存在一些差异，这些差异没有出现在您在问题中引用的 table 中。

在 Rust 中，。
Rust 有严格的别名规则，这样你不能同时对任何变量有超过一个 mutable 引用。

你的问题（简化）是：为什么我不能有一个非 mutable 引用到 mutable 变量，并通过它改变那个变量。但是，如果你能做到这一点，你也可以有两个可用于修改变量的引用，如下所示：

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;

关于你的 C 等价于给定的 Rust 代码 - 你没有根据 table 翻译它。考虑一下：

let x2 = &x1;

来自您引用的答案中的table：

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 时出现警告。这是一个重要的线索：我们有效地将 const-ness 添加到指向的对象。

如果你尝试编译你得到：

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

Answer 2

在 Rust 中有点不同。 & 符号表示引用某物，* 符号表示取消引用某物。如果我没记错的话，C/C++ 语法使用了 '->' 符号（这是一种取消引用的方式），它在 Rust 中没有出现。

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

关于引用的可变性和引用引用的值的可变性的一些混淆

Some confusion about the mutability of a reference and the mutability of the value a reference refers to

reference

mutability

rust