&符号'&'的含义并在 Rust 中标出“*"符号

本文介绍了&符号'&'的含义并在 Rust 中标出“*"符号的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

尽管彻底阅读了文档，但我对 Rust 中 & 和 * 符号的含义以及更一般的关于什么是 Rust 引用感到困惑正是.

Despite thoroughly reading the documentation, I'm rather confused about the meaning of the & and * symbol in Rust, and more generally about what is a Rust reference exactly.

在这个例子中，它似乎类似于一个 C++ 引用(即使用时自动解除引用的地址):

In this example, it seems to be similar to a C++ reference (that is, an address that is automatically dereferenced when used):

fn main() {
    let c: i32 = 5;
    let rc = &c;
    let next = rc + 1;
    println!("{}", next); // 6
}

但是，以下代码的工作原理完全相同:

However, the following code works exactly the same:

fn main() {
    let c: i32 = 5;
    let rc = &c;
    let next = *rc + 1;
    println!("{}", next); // 6
}

使用 * 取消引用引用在 C++ 中是不正确的.所以我想了解为什么这在 Rust 中是正确的.

Using * to dereference a reference wouldn't be correct in C++. So I'd like to understand why this is correct in Rust.

到目前为止，我的理解是，在 Rust 引用前插入 * 会取消引用它，但是 * 无论如何都是隐式插入的，因此您不需要添加它(而在 C++ 中，它是隐式插入的，如果插入它，则会出现编译错误).

My understanding so far, is that, inserting * in front of a Rust reference dereferences it, but the * is implicitly inserted anyway so you don't need to add it (while in C++, it's implicitly inserted and if you insert it you get a compilation error).

但是，这样的东西不能编译:

However, something like this doesn't compile:

fn main() {
    let mut c: i32 = 5;
    let mut next: i32 = 0;
    {
        let rc = &mut c;
        next = rc + 1;
    }
    println!("{}", next);
}

error[E0369]: binary operation `+` cannot be applied to type `&mut i32`
 --> src/main.rs:6:16
  |
6 |         next = rc + 1;
  |                ^^^^^^
  |
  = note: this is a reference to a type that `+` can be applied to; you need to dereference this variable once for this operation to work
  = note: an implementation of `std::ops::Add` might be missing for `&mut i32`

但这有效:

fn main() {
    let mut c: i32 = 5;
    let mut next: i32 = 0;
    {
        let rc = &mut c;
        next = *rc + 1;
    }
    println!("{}", next);  // 6
}

似乎隐式解除引用(a la C++)对于不可变引用是正确的，但对于可变引用则不然.这是为什么?

It seems that implicit dereferencing (a la C++) is correct for immutable references, but not for mutable references. Why is this?

i32

&符号'&amp;'的含义并在 Rust 中标出“*"符号

问题描述

推荐答案

&符号'&'的含义并在 Rust 中标出“*"符号