Rust：如果我知道只有一个实例，那么将可变borrow 转换为指针并返回(以安抚borrow 判断器)是否安全

让我们从这一点开始:您的代码是安全的，而且非常可靠.

不安全代码获取指向数据的指针的副本，取消对它的引用，并创建对该数据的新borrow .(同样，如果我错了，请纠正我).因为这使用的是复制而不是移动，所以编译器允许borrow和new_borrow同时存在.

这是不准确的.borrow和new_borrow可以同时存在的原因不是因为在移动引用时复制原始指针，而是因为当您将引用转换为原始指针时，您分离了生存期链-编译器不再能够跟踪new_borrow的源代码.

它不会让我在一个循环中两次推入mut_borrowed_data，因为new_borrow在第一次插入后会移动.

是的，但也不是:

'_outer: loop {
    mut_borrowed_data.clear();
    '_inner: for borrow in &mut owned_data {
        let ptr = borrow as *mut A;
        let new_borrow = unsafe { &mut *ptr };
        mut_borrowed_data.push(new_borrow);
        mut_borrowed_data.push(new_borrow);
    }
}
// Does not compile:
// error[E0382]: borrow of moved value: `new_borrow`
//   --> src/lib.rs:12:32
//    |
// 10 |         let new_borrow = unsafe { &mut *ptr };
//    |             ---------- move occurs because `new_borrow` has type `&mut A`, which does not implement the `Copy` trait
// 11 |         mut_borrowed_data.push(new_borrow);
//    |                                ---------- value moved here
// 12 |         mut_borrowed_data.push(new_borrow);
//    |                                ^^^^^^^^^^ value borrowed here after move

// However, this does compile, and it is still Undefined Behavior:
'_outer: loop {
    mut_borrowed_data.clear();
    '_inner: for borrow in &mut owned_data {
        let ptr = borrow as *mut A;
        let new_borrow = unsafe { &mut *ptr };
        mut_borrowed_data.push(new_borrow);
        eprintln!("{borrow}"); // Use the old `borrow`.
    }
}

您可以通过隐藏原来的borrow使其更安全一些，这样它就不能再使用了:

'_outer: loop {
    mut_borrowed_data.clear();
    '_inner: for borrow in &mut owned_data {
        let borrow = unsafe { &mut *(borrow as *mut A) };
        mut_borrowed_data.push(borrow);
    }
}

但它仍然不是完美的.原因是，由于您分离了生存期，您将获得一个无限的引用，实质上是'static个引用.这意味着它的使用时间可以超过允许的时间，例如:

use std::sync::Mutex;

#[derive(Debug)]
struct A;

static EVIL: Mutex<Option<&'static mut A>> = Mutex::new(None);

fn main() {
    let mut owned_data = vec![A, A, A];
    let mut mut_borrowed_data = vec![];
    
    '_outer: loop {
        if let Some(evil) = EVIL.lock().unwrap().as_deref_mut() {
            eprintln!("HaHa! We got two overlapping mutable references! {evil:?}");
        }
        
        mut_borrowed_data.clear();
        '_inner: for borrow in &mut owned_data {
            let borrow = unsafe { &mut *(borrow as *mut A) };
            mut_borrowed_data.push(borrow);
        }
        
        *EVIL.lock().unwrap() = mut_borrowed_data.pop();
    }
}

这并不意味着这种方法不好(这可能是我会使用的方法)，但您需要小心.