rust - 什么是重新借用，它如何影响编译器生成的代码？

Question

assert_eq宏代码的一部分是:

    ($left:expr, $right:expr, $($arg:tt)+) => ({
        match (&($left), &($right)) {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    // The reborrows below are intentional. Without them, the stack slot for the
                    // borrow is initialized even before the values are compared, leading to a
                    // noticeable slow down.
                    $crate::panic!(r#"assertion failed: `(left == right)`
  left: `{:?}`,
 right: `{:?}`: {}"#, &*left_val, &*right_val,
                           $crate::format_args!($($arg)+))
                }
            }
        }
    });

评论说重借是有意的，它将以某种方式影响堆栈的使用方式。
什么是重新借用，它如何影响编译器生成的代码？

Answer 1

我不确定它如何影响编译，但是重新借用是当您取消引用某些内容然后直接借用它时。
例如:

fn main() {
    let mut vec: Vec<u8> = vec![1, 2, 3];
    let mut_ref: &mut Vec<u8> = &mut vec;
    let reborrow: &Vec<u8> = &*mut_ref;
}

它可以用于:

从可变引用(上面的代码)中获得不可变的引用

获得生命周期较短的引用

在智能指针

中获得对某些东西的引用

从指针

获取引用

以及其他可能的事情..(我对Rust😃还是很陌生的)

缩短生命周期的示例用法(非常人为，但这过于简单了):

fn main() {
    let mut outer_vec = vec![1, 2, 3];
    let outer_ref = &mut outer_vec;

    {
        // shorten lifetime of outer_ref
        // not doing this causes an error
        let mut outer_ref = &mut *outer_ref; // mutable reborrow

        let mut inner_vec = vec![1, 2, 3];
        let inner_ref = &mut inner_vec;

        // imagine a real condition
        if true {
            outer_ref = inner_ref;
        }

        // use outer_ref which could point to the outer_vec or inner_vec
        println!("{:?}", outer_ref);
    }

    println!("{:?}", outer_ref);
}

获取对智能指针后面的内容的引用(在这种情况下为Box):

fn main() {
    let vec = vec![1, 2, 3];
    let boxed = Box::new(vec);

    let reborrow: &Vec<u8> = &*boxed;

    println!("{:?}", reborrow);
}

指针引用:

fn main() {
    let num: u8 = 10;
    let pointer: *const u8 = &num as *const u8;

    unsafe {
        let ref_from_ptr: &u8 = &*pointer;
    }
}

不确定是否将所有这些严格地视为“借入”。