---

0 引言：为什么 Rust 不需要 finally

在 C++/Java/Go 中，资源清理通常依赖：

• 显式 free / close
• try { ... } finally { ... }
• 运行时 GC 回收

Rust 选择了另一条路：把资源清理纳入类型系统。
核心就是 Drop trait —— 它把 “何时释放” 从运行时策略变成 编译期可证明的线性逻辑。

---

1 Drop trait 的三层语义

层级	作用	代码体现
语言规则	值离开作用域 → 自动调用 drop	线性类型
类型系统	Drop trait 提供析构钩子	impl Drop for T
代码生成	MIR 插入 drop_in_place	LLVM 无运行时调度

---

2 最小示例：从创建到销毁的完整生命周期

struct FileDesc(i32);

impl FileDesc {
    fn open(path: &str) -> Self {
        let fd = unsafe { libc::open(path.as_ptr() as _, libc::O_RDONLY) };
        assert!(fd >= 0);
        Self(fd)
    }
}

impl Drop for FileDesc {
    fn drop(&mut self) {
        let _ = unsafe { libc::close(self.0) };
        println!("closed fd {}", self.0);
    }
}

fn main() {
    {
        let _f = FileDesc::open("/etc/passwd");
    } // <- 自动关闭
    println!("after inner scope");
}

输出：

closed fd 3
after inner scope

即使 main 提前 return、panic!，析构仍被保证。

---

3 编译器视角：MIR 如何插入 drop

3.1 MIR 片段

let v = vec![1, 2, 3];

生成（简化）：

bb0:
    _1 = Vec::<i32>::new();
    _2 = _1;
    drop(_2) -> bb1;      // <- 插入点

• drop elaboration 遍历所有路径，确保 每条路径恰好一次 drop
• 若提前 move，MIR 会把变量标记为 uninit，后续 drop 被 静默消除

---

4 手动控制：mem::drop、ManuallyDrop、MaybeUninit

工具	场景	是否运行析构
mem::drop	提前释放	✅
ManuallyDrop<T>	需要手动调用	❌（默认不 drop）
MaybeUninit<T>	未初始化内存	❌

4.1 ManuallyDrop 实现 defer

use std::mem::ManuallyDrop;

struct Defer<F: FnOnce()>(ManuallyDrop<F>);

impl<F: FnOnce()> Defer<F> {
    fn new(f: F) -> Self { Self(ManuallyDrop::new(f)) }
}

impl<F: FnOnce()> Drop for Defer<F> {
    fn drop(&mut self) {
        unsafe { ManuallyDrop::take(&mut self.0)() }
    }
}

fn main() {
    let _d = Defer::new(|| println!("defer!"));
    println!("body");
}

---

5 实战：自研 zero-cost RAII 内存池

需求：

• 零额外开销（与 malloc/free 汇编级等价）
• 支持 批量回收 与 异常安全

5.1 数据结构

use std::ptr::NonNull;
use std::alloc::{Layout, alloc, dealloc};

pub struct Arena {
    ptr: NonNull<u8>,
    layout: Layout,
    offset: usize,
}

impl Arena {
    pub fn new(cap: usize) -> Self {
        let layout = Layout::from_size_align(cap, 8).unwrap();
        let ptr = NonNull::new(unsafe { alloc(layout) }).unwrap();
        Self { ptr, layout, offset: 0 }
    }

    pub fn alloc<T>(&mut self, value: T) -> &mut T {
        let size = std::mem::size_of::<T>();
        let align = std::mem::align_of::<T>();
        let align_mask = align - 1;
        self.offset = (self.offset + align_mask) & !align_mask;
        assert!(self.offset + size <= self.layout.size());
        let dst = unsafe { self.ptr.as_ptr().add(self.offset) as *mut T };
        unsafe { dst.write(value) };
        self.offset += size;
        unsafe { &mut *dst }
    }
}

impl Drop for Arena {
    fn drop(&mut self) {
        unsafe { dealloc(self.ptr.as_ptr(), self.layout) }
    }
}

5.2 使用示例

#[derive(Debug)]
struct Node { x: i32, y: f64 }

fn main() {
    let mut arena = Arena::new(1024);
    let n1 = arena.alloc(Node { x: 1, y: 2.0 });
    let n2 = arena.alloc(Node { x: 3, y: 4.0 });
    println!("{:?} {:?}", n1, n2);
} // <- 整块内存一次性释放

与 malloc/free 汇编对比：

• 无 逐个节点 free
• 无 arena 自身 泄漏
• 最终生成 一条 free 指令

---

6 异常安全：Drop 与 panic=unwind

fn may_panic() {
    let _f = FileDesc::open("/etc/passwd");
    panic!("boom"); // 自动关闭 fd
}

• 当 panic=unwind，栈回溯 自动调用 drop
• 当 panic=abort，操作系统回收资源（仍安全，但无析构）

---

7 跨 FFI 边界：把 Drop 契约导出给 C

7.1 头文件

// mylib.h
typedef struct MyString MyString;
MyString* my_string_new(const char* s);
void my_string_free(MyString* s);

7.2 Rust 实现

#[repr(C)]
pub struct MyString {
    ptr: *mut u8,
    len: usize,
}

#[no_mangle]
pub extern "C" fn my_string_new(s: *const c_char) -> *mut MyString {
    let cstr = unsafe { CStr::from_ptr(s) };
    let bytes = cstr.to_bytes();
    let len = bytes.len();
    let ptr = bytes.as_ptr() as *const u8 as *mut u8;
    let boxed = Box::new(MyString { ptr, len });
    Box::into_raw(boxed)
}

#[no_mangle]
pub extern "C" fn my_string_free(ptr: *mut MyString) {
    if ptr.is_null() { return; }
    unsafe { drop(Box::from_raw(ptr)); } // 调用 Drop
}

• C 侧 无法二次 free：所有权唯一
• Rust 侧 不会泄漏：Box 的 Drop 保证

---

8 常见误区 & 工具链速查表

场景	正确做法	工具
忘记释放	使用 RAII 包装	clippy::drop_ref
提前 drop	mem::drop 显式调用	-Zdrop-tracking
FFI 二次 free	Box::into_raw + from_raw	Miri
析构 panic	用 std::panic::catch_unwind	cargo miri

---

9 结语：把资源管理变成类型系统的一部分

Rust 的 Drop trait 不是「析构函数」那么简单，它是：

• 线性逻辑的编译器实现
• 零成本抽象的终点
• 异常安全的基石
• FFI 边界的安全契约

当你用 RAII 写业务代码时，请记住：
析构逻辑已在编译期被证明正确，运行期只剩一条 call drop_in_place 指令。