Rust 作为参数传递的引用未移动

编译此文件时会出现以下错误：

fn t(x: &mut u8) -> &mut u8 {
    x
}

fn main() {
    let mut x = 5u8;
    let y = & mut x;
    let z = t(y);
    println!("{}", y);
}

我本以为

y

在调用

t

然后返回到

z

的过程中会被移动，导致

错误：使用移动的值

为什么我会收到此错误消息

当引用作为函数参数提供时，Rust是否会自动创建新的借用而不是传递所有权

这种行为的目的是什么

---

您正在从函数返回参数的可变引用。但是，Rust不知道该方法没有保存该指针的副本，也不返回该指针的子部分，如果它是一个结构。这意味着，在任何时候，指向的值都可能发生变化，这是一个很大的不生锈问题；如果允许，则很容易导致内存错误

锈蚀是否会自动创建新的借用

是的，Rust“重新借用”了参考资料

更好的示例需要更复杂的一点：

main.rs:9:20: 9:21 error: cannot borrow `y` as immutable because `*y` is also borrowed as mutable
main.rs:9     println!("{}", y);

---

这里，

t

返回指向结构子集的可变指针。这意味着整个结构是借用的，我们不能更改它（除非通过

z

）。Rust将此逻辑应用于所有函数，并且不会试图识别您的

t

函数只返回相同的指针。

通过使用

rustc--pretty=expanded

编译程序，我们可以看到

println宏借用其参数：

struct Thing { a: u8, b: u8 }

fn t(x: &mut Thing) -> &mut u8 {
    &mut x.a
}

fn main() {
    let mut x = Thing { a: 5, b: 6 };
    let z = t(&mut x);
    *z = 0;
    // x.a = 0; // cannot assign to `x.a` because it is borrowed
}

#！[无标准]
#[宏_使用]
外部板条箱“标准”为标准；
#[开场白]
使用std:：prelude:：v1:：*；
fn t（x:&mut u8）->&mut u8{x}
fn main（）{
设mut x=5u8；
设y=&mut x；
设z=t（y）；
：：std:：io:：stdio:：println_args（：：std:：fmt:：Arguments:：new({
#[内联]
#[允许（死代码）]
静态\uuuu静态\uFMTSTR：
&'static[&'static str]
=
&[""];
__静态FMTSTR
},
&匹配（&y，）{//
[：：std:：fmt:：argument（：：std:：fmt:：String:：fmt，
__arg0]，
}));
}
另请参见
Rust不知道该方法没有保留该指针的副本
-由于函数已过，它不能推断调用后会释放其中的任何内容吗？
t
的签名导致只要
z
存在，
y
就会被可变地借用。而
z
一直存在，直到
main
@JV I更新了答案并删除了您引用的误导性部分。
#![no_std]
#[macro_use]
extern crate "std" as std;
#[prelude_import]
use std::prelude::v1::*;
fn t(x: &mut u8) -> &mut u8 { x }

fn main() {
    let mut x = 5u8;
    let y = &mut x;
    let z = t(y);
    ::std::io::stdio::println_args(::std::fmt::Arguments::new({
                                                                  #[inline]
                                                                  #[allow(dead_code)]
                                                                  static __STATIC_FMTSTR:
                                                                         &'static [&'static str]
                                                                         =
                                                                      &[""];
                                                                  __STATIC_FMTSTR
                                                              },
                                                              &match (&y,) { // <----- y is borrowed here
                                                                   (__arg0,)
                                                                   =>
                                                                   [::std::fmt::argument(::std::fmt::String::fmt,
                                                                                         __arg0)],
                                                               }));
}