非常好的Rust自动管理内存的例子

1.核心机制：所有权系统 (Ownership System)

A.所有权规则

rust 复制代码

fn main() {
    // 规则 1: 每个值都有一个所有者
    let s1 = String::from("hello");  // s1 是 "hello" 的所有者
    
    // 规则 2: 同一时间只能有一个所有者
    let s2 = s1;  // 所有权转移到 s2，s1 不再有效
    // println!("{}", s1);  // ❌ 编译错误！s1 已失效
    println!("{}", s2);     // ✅ s2 是新的所有者
    
    // 规则 3: 当所有者离开作用域，值被自动释放
}  // s2 在这里离开作用域，内存自动释放（调用 drop）

B.Drop trait - 自动析构

rust 复制代码

struct MyData {
    data: Vec<u8>,
}

impl Drop for MyData {
    fn drop(&mut self) {
        println!("释放 MyData，大小: {} bytes", self.data.len());
        // Vec 的 drop 会自动调用，释放内存
    }
}

fn main() {
    {
        let data = MyData {
            data: vec![0; 100],
        };
        println!("MyData 创建");
    }  // 作用域结束，自动调用 drop
    println!("MyData 已释放");
}

输出：

复制代码

MyData 创建
释放 MyData，大小: 100 bytes
MyData 已释放

2. 内存管理的三种方式

A. 栈分配（编译时已知大小）

rust 复制代码

fn main() {
    let x = 42;           // 栈上
    let y = [1, 2, 3];    // 栈上
    let z = (10, 20);     // 栈上
    
    // 函数结束，栈自动清理
}

B. 堆分配（运行时动态大小）

rust 复制代码

fn main() {
    // String 在堆上分配
    let s = String::from("hello");
    
    // Vec 在堆上分配
    let v = vec![1, 2, 3, 4, 5];
    
    // Box 在堆上分配
    let b = Box::new(42);
    
    println!("栈上的指针: {:p}", &s);
    println!("堆上的数据: {:p}", s.as_ptr());
    
    // 作用域结束，Drop trait 自动调用，释放堆内存
}

C. 借用（不转移所有权）

rust 复制代码

fn print_length(s: &String) {  // 借用，不获取所有权
    println!("长度: {}", s.len());
}  // 不释放，因为不是所有者

fn main() {
    let s = String::from("hello");
    print_length(&s);  // 借用
    println!("{}", s); // ✅ s 仍然有效
}  // s 在这里释放