我在 Rust 书籍中看到，您可以使用相同的名称定义两个不同的变量：
let hello = "Hello";
let hello = "Goodbye";
println!("My variable hello contains: {}", hello);
这将打印出：
My variable hello contains: Goodbye
第一个“hello”会发生什么？它会被释放吗？我该如何访问它？
我知道给两个变量起相同的名称是不好的，但如果这种情况发生在我在100行之后声明它时，则可能会很麻烦。
Rust是否会释放被覆盖变量的内存？
是的，否则将会导致内存泄漏，这将是一个非常糟糕的设计决策。当变量被重新赋值时，内存将被释放：
struct Noisy;
impl Drop for Noisy {
fn drop(&mut self) {
eprintln!("Dropped")
}
}
fn main() {
eprintln!("0");
let mut thing = Noisy;
eprintln!("1");
thing = Noisy;
eprintln!("2");
}
0
1
Dropped
2
Dropped
第一个hello会发生什么
它被隐藏了。
除了你无法再访问它之外，与变量引用的数据没有任何“特殊”之处。当变量超出范围时，它仍然会被删除：
struct Noisy;
impl Drop for Noisy {
fn drop(&mut self) {
eprintln!("Dropped")
}
}
fn main() {
eprintln!("0");
let thing = Noisy;
eprintln!("1");
let thing = Noisy;
eprintln!("2");
}
0
1
2
Dropped
Dropped
另请参阅：
我知道给两个变量起相同的名字是不好的。
这并不是“不好”，而是一种设计决策。我认为像这样使用遮蔽是一个坏主意：
let x = "Anna";
println!("User's name is {}", x);
let x = 42;
println!("The tax rate is {}", x);
我认为像这样使用阴影是合理的：
let name = String::from(" Vivian ");
let name = name.trim();
println!("User's name is {}", name);
参见：
但如果这是意外发生的，因为我在它之下声明了100行，那将是真正的痛苦。
不要编写太大的函数，以至于你会“意外”做某些事情。这适用于任何编程语言。
有没有手动清理内存的方法？
您可以调用 drop：
eprintln!("0");
let thing = Noisy;
drop(thing);
eprintln!("1");
let thing = Noisy;
eprintln!("2");
0
Dropped
1
2
Dropped
drop的讨论都需要展示其（非常复杂的）实现：fn drop<T>(_: T) {}
在涉及到drop顺序时，对于变量的阴影和重新分配（覆盖）之间存在差异。
所有局部变量通常在作用域结束时按照声明的相反顺序被删除（请参见The Rust Programming Language的Drop章节）。这包括被遮蔽的变量。可以通过将值包装在一个简单的包装结构中来轻松检查此内容，当该包装结构被删除时（就在值本身被删除之前），它会打印出一些东西：
use std::fmt::Debug;
struct NoisyDrop<T: Debug>(T);
impl<T: Debug> Drop for NoisyDrop<T> {
fn drop(&mut self) {
println!("dropping {:?}", self.0);
}
}
fn main() {
let hello = NoisyDrop("Hello");
let hello = NoisyDrop("Goodbye");
println!("My variable hello contains: {}", hello.0);
}
My variable hello contains: Goodbye
dropping "Goodbye"
dropping "Hello"
这是因为作用域中的新let绑定不会覆盖先前的绑定，所以就好像你写了
let hello1 = NoisyDrop("Hello");
let hello2 = NoisyDrop("Goodbye");
println!("My variable hello contains: {}", hello2.0);
请注意，这个行为与下面的代码（playground）表面上非常相似，但实际上是不同的：
fn main() {
let mut hello = NoisyDrop("Hello");
hello = NoisyDrop("Goodbye");
println!("My variable hello contains: {}", hello.0);
}
这段代码不仅将值按相反顺序丢弃，而且在打印消息之前丢弃第一个值！这是因为当您将变量赋值给一个变量（而不是使用新变量隐藏它）时，原始值会在新值移入之前被丢弃。
我开始说局部变量在超出范围时“通常”会被删除。因为您可以将值移入和移出变量，所以有时候需要在运行时才能确定何时需要删除变量，此时编译器实际上插入代码来跟踪“活动状态”，并在必要时删除这些值，因此您不能通过覆盖值而意外地导致泄漏。（但是，仍然可能通过调用mem::forget或创建具有内部可变性的Rc-循环来安全地泄漏内存。）
fn main(){
let hello = "Hello xxxxxxxxxxxxxxxx"; // Added for searching more easily.
let hello = "Goodbye";
println!("My variable hello contains: {}", hello);
}
$ rustc ./stackoverflow.rs
$ cat stackoverflow | grep "xxx"
# No results
$ cat stackoverflow | grep "Goodbye"
Binary file (standard input) matches
$ cat stackoverflow | grep "My variable hello contains"
Binary file (standard input) matches
fn main(){
// Added the type to make it more clear.
let hello: &str = "Hello";
let hello: &str = "Goodbye";
// This is wrong (does not compile):
// let hello: String = "Goodbye";
println!("My variable hello contains: {}", hello);
}
hello指向的内存地址位置会改变，但内存仍然被静态字符串使用。String类型，情况会有所不同，请参考其他答案。
- Rust甚至没有垃圾回收机制。
- 这应该在书中解释Shadowing。
- E net4