在 Rust 中，当一个值隐藏另一个值时，堆栈上会发生什么？ [复制]

我在读掌握 Rust https://www.packtpub.com/application-development/mastering-rust-second-edition。第一章末尾有一个练习，其中提供了示例代码，任务是修复它，通过使用通常非常有用的编译器错误消息进行迭代。

I was 期待以下是一个错误，但它is not:

for line in reader.lines() {
    let line = line.expect("Could not read line.");

对于完整的上下文，我有整个代码的要点 https://gist.github.com/rust-play/eaf785475b173c44db0aeb897d31d85f。这是我修复问题后的代码，相关行是 37 和 38。但是它需要提供一个文本文件作为参数。

我本来以为会出现错误，因为line位于堆栈上（至少指针位于）。是不是还可以销毁并更换毫无怨言？

关于内存管理和堆栈，幕后发生了什么？我presume that line实际上是对字符串的引用（a&str类型）。那么，这很好，因为无论哪种情况，指针本身 - 堆栈上的对象 - 只是一个usize，这样两个line堆栈上的对象大小相同。

我可以用不同尺寸的东西来做这个吗？第二行可以说：

let line: f64 = 3.42;

在这种情况下，对象本身位于堆栈上，并且它可能大于usize.

每当变量声明为let，它是一个全新的变量，与之前的任何变量分开。即使同名变量已经存在，原始变量仍然是shadowed https://en.wikipedia.org/wiki/Variable_shadowing当新变量在范围内时。如果变量被隐藏，则通常无法访问它。

在新变量超出范围后旧变量仍在范围内的情况下，或者如果旧变量具有Drop执行。

我们可以在下面的示例中看到这一点。

#[derive(Debug)]
struct DroppedU32(u32);

impl Drop for DroppedU32 {
    fn drop(&mut self) {
        eprintln!("Dropping u32: {}", self.0);
    }
}

fn main() {
    let x = 5;
    dbg!(&x); // the original value
    {
        let x = 7;
        dbg!(&x); // the new value
    }
    dbg!(&x); // the original value again

    let y = DroppedU32(5);
    dbg!(&y); // the original value
    let y = DroppedU32(7);
    dbg!(&y); // the new value

    // down here, when the variables are dropped in
    // reverse order of declaration,
    // the original value is accessed again in the `Drop` impl.
}

这并不是说原始变量保证仍然存在。编译器优化可能会导致原始变量被覆盖，尤其是在不再访问原始变量的情况下。

The code

pub fn add_three(x: u32, y: u32, z: u32) -> u32 {
    let x = x + y;
    let x = x + z;
    x
}

编译为 https://rust.godbolt.org/z/5M3Su6

example::add_three:
        lea     eax, [rdi + rsi]
        add     eax, edx
        ret

如果您像我一样并且不太熟悉汇编代码，这基本上是

1. 将 x 和 y 相加并将结果放入变量中（称为 w）。
2. 将 z 添加到 w 并用结果覆盖 w。
3. 返回w。

因此（除了输入参数之外），即使我们使用了，也只使用了一个变量let x = ...两次。中间结果let x = x + y;被覆盖。