Reference 符号'的含义&'；和star'*'；锈迹斑斑的符号_Reference_Rust_Dereference_Ampersand

Reference 符号'的含义&'；和star'*'；锈迹斑斑的符号

reference rust

Reference 符号'的含义&'；和star'*'；锈迹斑斑的符号,reference,rust,dereference,ampersand,Reference,Rust,Dereference,Ampersand,尽管仔细阅读了文档，但我还是对Rust中的&和*符号的含义感到困惑，更一般地说，什么是Rust参考在这个例子中，它看起来类似于C++引用（即，当使用时自动撤销引用的地址）：但是，以下代码的工作原理完全相同： fn main() { let c: i32 = 5; let rc = &c; let next = *rc + 1; println!("{}", next); // 6 } p1.distance(&p2); (&p1).d

尽管仔细阅读了文档，但我还是对Rust中的

和

符号的含义感到困惑，更一般地说，什么是Rust参考

在这个例子中，它看起来类似于C++引用（即，当使用时自动撤销引用的地址）：

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

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

p1.distance(&p2);
(&p1).distance(&p2);

使用<代码> */COD>引用引用在C++中是不正确的。所以我想了解为什么这在Rust中是正确的

我目前的理解是，在Read引用前面插入<代码> */COD>，但是<代码> */COD>无论如何都隐式插入，这样就不需要添加它（而C++中，它是隐式插入的，如果插入它，就会得到编译错误）。但是，类似这样的内容无法编译：

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

error[E0369]：二进制操作“+”不能应用于类型“%mut i32”`
-->src/main.rs:6:16
|
6 | next=rc+1；
|                ^^^^^^
|
=注意：这是对`+`可应用于的类型的引用；您需要取消引用此变量一次，此操作才能工作
=注意：`&mut i32可能缺少`std:：ops:：Add`的实现`

但这是可行的：

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++）似乎适用于不可变引用，但不适用于可变引用。为什么会这样

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

< C++中的引用与锈中的引用不相同。Rust的引用更接近C++的指针（在用法上，而不是语义上）。关于内存表示，Rust的引用通常只是一个指针，而C++的引用应该是同一对象的替代名称（因此没有内存表示）

< C++指针与锈迹引用的区别在于，RIST的引用从来都不是<代码> null <代码>，从不未初始化，也不会悬空。

为以下对和所有其他数字原语实现特征（参见文档页面底部）：

```
&i32
```
+
```
i32
```
```
i32
```
+
```
&i32
```
```
&i32
```
+
```
&i32
```

这只是std-lib开发人员实现的一件方便的事情。编译器可以计算出

&mut i32

可以在任何可以使用

&i32

的地方使用，但这对泛型不起作用（还没有），因此std库开发人员还需要为以下组合（以及所有原语）实现

添加

特征：

```
&mut i32
```
+
```
i32
```
```
i32
```
+
```
&mut i32
```
```
&mut i32
```
+
```
&mut i32
```
```
&mut i32
```
+
```
&i32
```
```
&i32
```
+
```
&mut i32
```

正如你所看到的，这可能会失控。我相信这会在将来消失。在此之前，请注意，很少有人最终使用

&mut i32

并尝试将其用于数学表达式中。

来自

std:：ops:：Add的文档：
impl<'a, 'b> Add<&'a i32> for &'b i32
impl<'a> Add<&'a i32> for i32
impl<'a> Add<i32> for &'a i32
impl Add<i32> for i32

i32的impl Add
impl这个答案适用于那些寻找基础知识的人（例如来自谷歌）
从铁锈书中：
这些符号是引用，它们允许您引用某些价值，而无需获得所有权[即借用]
与使用&
进行引用相反的是取消引用，这是通过取消引用操作符*
完成的
还有一个基本的例子：
let x = 5;
let y = &x; //set y to a reference to x

assert_eq!(5, x);
assert_eq!(5, *y); // dereference y

如果我们试图写assert\u eq！（5，y）无法将`{integer}`与`&{integer}`
进行比较
（您可以在中阅读更多。）
和来自：
Rust有一个称为自动引用和取消引用的功能。调用方法是Rust中少数几个具有这种行为的地方之一
它的工作原理如下：当您使用对象.something（）
调用方法时，Rust会自动添加&
、&mut
或*
，以便对象与方法的签名匹配。换句话说，以下内容是相同的：
fn main() {
    let c: i32 = 5;
    let rc = &c;
    let next = *rc + 1;
    println!("{}", next); // 6
}

p1.distance(&p2);
(&p1).distance(&p2);

谢谢，我现在明白了。事实上，我本以为可能是这样的，但我放弃了这个想法，认为用一个整数的地址来定义一个整数的和是非常奇怪的。也许应该强调，在DOC中，生锈引用被认为是地址，而不是混淆与C++引用。再次感谢您的详细解释。