rust 移动语义实际上是如何工作的

Question

在写了一些代码和阅读了一些文章之后，我对 rust 中的移动语义有点困惑，我想在值移动之后，应该释放它，应该使内存无效。所以我试着写一些代码来作证。

第一个例子

#[derive(Debug)]
struct Hello {
    field: u64,
    field_ptr: *const u64,
}

impl Hello {
    fn new() -> Self {
        let h = Hello {
            field: 100,
            field_ptr: std::ptr::null(),
        };
        h
    }

    fn init(&mut self) {
        self.field_ptr = &self.field as *const u64;
    }
}
fn main(){
    let mut h = Hello::new();
    h.init();
    println!("=================");
    println!("addr of h: ({:?}) \naddr of field ({:?})\nfield_ptr: ({:?}) \nptr value {:?}", &h as *const Hello, &h.field as *const u64, h.field_ptr, unsafe {*h.field_ptr});

    let c = &h.field as *const u64;
    let e = &h as *const Hello;
    let a = h;
    let d = &a.field as *const u64;

    println!("=================");
    println!("addr of a: ({:?}) \naddr of field ({:?})\nfield_ptr: ({:?}) \nptr value {:?}", &a as *const Hello, &a.field as *const u64, a.field_ptr, unsafe {*a.field_ptr});
    println!("=================");
    println!("addr of c {:?}\nvalue {:?}", c, unsafe {*c});
    println!("addr of d {:?}\nvalue {:?}", d, unsafe {*d});
    println!("addr of e {:?}\nvalue {:?}", e, unsafe {&*e});
}

上面代码的结果是

=================
addr of h: (0x7ffee9700628) 
addr of field (0x7ffee9700628)
field_ptr: (0x7ffee9700628) 
ptr value 100
=================
addr of a: (0x7ffee9700720) 
addr of field (0x7ffee9700720)
field_ptr: (0x7ffee9700628) 
ptr value 100
=================
addr of c 0x7ffee9700628
value 100
addr of d 0x7ffee9700720
value 100
addr of e 0x7ffee9700628
value Hello { field: 100, field_ptr: 0x7ffee9700628 }

所以，我创建了一个自引用结构Hello 并使field_ptr 指向u64 字段，并使用原始点来保存结构的地址和字段的地址，并将h 移动到a 以使h 变量，但我仍然可以通过原始点获取 IMO 不应该存在的原始变量的值？

第二个例子

struct Boxed {
    field: u64,
}
fn main(){

   let mut f = std::ptr::null();
    {
        let boxed = Box::new(Boxed{field: 123});
        f = &boxed.field as *const u64;
    }
    println!("addr of f {:?}\nvalue {:?}", f, unsafe {&*f});
}

结果

addr of f 0x7fc1f8c05d30
value 123

我创建一个装箱值并在使用原始点保存它的地址后将其删除，我仍然可以通过原始点读取它的字段值。

所以我的困惑是

1. rust 中的移动实际上是 memcpy 吗？而原始变量只是被编译器“隐藏”了？
2. rust 何时真正释放堆上变量的内存？ （第二个例子）

谢谢

我读过的 How does Rust provide move semantics?

Answer 1

所以你的输出的第一块应该是清楚的，对吧？结构的地址只是该结构在内存中所在位置的内存的第一位，与它的第一个字段的地址相同。

现在是您的第二个区块。您将一些原始指针抓取到结构中，然后通过let a = h 移动结构。

这样做是：在堆栈上，我们现在有了一个新变量a，它是变量h 的旧堆栈布局的内存副本。这就是a 和a.field 都有一个新地址的原因。当然，原始指针仍然指向旧的h.field 地址，这就是您仍然可以访问该数据的原因。

请注意，您只能通过 unsafe 块执行此操作，因为您所做的 不安全。没有保证无论你的字段指针指向什么都将保持有效。

如果您删除所有使用 unsafe 构造，将无法通过 h.field 访问 a.field。

同样的想法也适用于第二个例子。如果你不使用原始指针和不安全的块，你就无法得到丢弃的东西，那是因为这段代码非常可疑。在您的简单示例中，它仍然有效，因为 Rust 不只是继续打乱已删除值的内存。除非您的程序中的其他东西重新利用了该内存，否则它将保持您离开它的方式。