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

如何解决什么是重新借用以及它如何影响编译器生成的代码？

部分 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)+))
                }
            }
        }
    });

评论说重新借用是有意的，它会以某种方式影响堆栈的使用方式。

什么是重借以及它如何影响编译器生成的代码？

解决方法

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

例如：

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,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,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,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;
    }
}

顺便说一下，不确定所有这些是否都被严格视为“再借用”。