ManuallyDrop 手动释放 ​

核心概念 ​

std::mem::ManuallyDrop<T> 是一个包装类型,它阻止 Rust 自动调用内部值的析构器(Drop)。正常情况下,当一个值离开作用域时,Rust 会自动调用它的 drop 方法来释放资源(如堆内存、文件句柄等)。ManuallyDrop<T> 让程序员自己决定何时、是否调用析构器。

ManuallyDrop<T> 与 T 大小和对齐完全相同(#[repr(transparent)]),是零开销的。它主要用于以下场景:union 中包含非 Copy 类型的字段、需要精确控制析构顺序的底层代码、防止双重释放、以及与 FFI 交互时管理所有权转移。

rust
use std::mem::ManuallyDrop;

fn main() {
    // 普通 String:离开作用域时自动 drop
    {
        let s = String::from("自动释放");
        println!("{}", s);
    }
    // s 的堆内存已被自动释放

    // ManuallyDrop<String>:不会自动 drop
    {
        let s = ManuallyDrop::new(String::from("手动控制"));
        println!("{}", *s);  // 可以通过 Deref 访问内部值
    }
    // s 离开作用域,但 String 的 drop 不会被调用
    // 堆内存泄漏了!

    // 正确用法:手动 drop
    {
        let mut s = ManuallyDrop::new(String::from("正确释放"));
        println!("{}", *s);

        // SAFETY: s 只被 drop 一次,之后不再使用
        unsafe { ManuallyDrop::drop(&mut s); }
        // 现在堆内存已释放
        // 不要再使用 s!
    }
}

ManuallyDrop 的 API ​

rust
use std::mem::ManuallyDrop;

fn main() {
    // === new(value):包装值 ===
    let md = ManuallyDrop::new(vec![1, 2, 3]);
    println!("new: {:?}", *md);

    // === into_inner(slot):解包,恢复自动 Drop ===
    let md = ManuallyDrop::new(String::from("取出"));
    let s = ManuallyDrop::into_inner(md);
    // s 是普通的 String,离开作用域时会自动 drop
    println!("into_inner: {}", s);

    // === Deref / DerefMut:透明访问内部值 ===
    let mut md = ManuallyDrop::new(vec![10, 20, 30]);
    md.push(40);             // 通过 DerefMut 访问 Vec 的方法
    println!("len: {}", md.len());  // 通过 Deref 访问
    println!("内容: {:?}", *md);

    // === drop(&mut slot):手动调用析构器 ===
    let mut md = ManuallyDrop::new(String::from("手动 drop"));
    // SAFETY: 只 drop 一次
    unsafe { ManuallyDrop::drop(&mut md); }
    // md 之后不能再使用(内部值已被析构)

    // === take(&mut slot):取出值(unsafe)===
    // 从 ManuallyDrop 中移出值,之后 ManuallyDrop 不能再使用
    let mut md = ManuallyDrop::new(String::from("取走"));
    // SAFETY: 只 take 一次
    let taken = unsafe { ManuallyDrop::take(&mut md) };
    println!("take: {}", taken);
    // md 不能再使用

    // 大小验证
    println!("\n大小:");
    println!("String: {} 字节", std::mem::size_of::<String>());
    println!("ManuallyDrop<String>: {} 字节", std::mem::size_of::<ManuallyDrop<String>>());
    // 大小完全相同
}
方法安全性效果
new(val)安全包装值,禁止自动 Drop
into_inner(md)安全解包,恢复自动 Drop
drop(&mut md)unsafe手动调用析构器
take(&mut md)unsafe移出值,ManuallyDrop 变无效
Deref / DerefMut安全透明访问内部值

在 union 中使用 ​

rust
use std::mem::ManuallyDrop;

// union 的字段必须是 Copy 类型或 ManuallyDrop 包装的类型
// 因为 union 不知道当前活跃字段,不能自动 Drop

union StringOrVec {
    s: ManuallyDrop<String>,
    v: ManuallyDrop<Vec<i32>>,
    n: i32,
}

impl StringOrVec {
    fn from_string(s: String) -> Self {
        StringOrVec { s: ManuallyDrop::new(s) }
    }

    fn from_vec(v: Vec<i32>) -> Self {
        StringOrVec { v: ManuallyDrop::new(v) }
    }

    fn from_int(n: i32) -> Self {
        StringOrVec { n }
    }
}

// 带标签的安全封装
enum TaggedValue {
    Str(StringOrVec),
    Vec(StringOrVec),
    Int(StringOrVec),
}

impl TaggedValue {
    fn new_str(s: String) -> Self {
        TaggedValue::Str(StringOrVec::from_string(s))
    }

    fn new_vec(v: Vec<i32>) -> Self {
        TaggedValue::Vec(StringOrVec::from_vec(v))
    }

    fn new_int(n: i32) -> Self {
        TaggedValue::Int(StringOrVec::from_int(n))
    }

    fn as_str(&self) -> Option<&str> {
        match self {
            TaggedValue::Str(u) => {
                // SAFETY: 标签为 Str,s 字段有效
                Some(unsafe { &u.s })
            }
            _ => None,
        }
    }

    fn as_vec(&self) -> Option<&[i32]> {
        match self {
            TaggedValue::Vec(u) => {
                // SAFETY: 标签为 Vec,v 字段有效
                Some(unsafe { &u.v })
            }
            _ => None,
        }
    }

    fn as_int(&self) -> Option<i32> {
        match self {
            TaggedValue::Int(u) => {
                // SAFETY: 标签为 Int,n 字段有效
                Some(unsafe { u.n })
            }
            _ => None,
        }
    }
}

impl Drop for TaggedValue {
    fn drop(&mut self) {
        match self {
            TaggedValue::Str(u) => {
                // SAFETY: s 字段有效,只 drop 一次
                unsafe { ManuallyDrop::drop(&mut u.s); }
            }
            TaggedValue::Vec(u) => {
                // SAFETY: v 字段有效,只 drop 一次
                unsafe { ManuallyDrop::drop(&mut u.v); }
            }
            TaggedValue::Int(_) => {
                // i32 是 Copy,不需要 drop
            }
        }
    }
}

fn main() {
    let values = vec![
        TaggedValue::new_str(String::from("Hello")),
        TaggedValue::new_vec(vec![1, 2, 3]),
        TaggedValue::new_int(42),
    ];

    for v in &values {
        if let Some(s) = v.as_str() {
            println!("Str: {}", s);
        } else if let Some(vec) = v.as_vec() {
            println!("Vec: {:?}", vec);
        } else if let Some(n) = v.as_int() {
            println!("Int: {}", n);
        }
    }
    // values drop 时正确释放所有资源
}

控制析构顺序 ​

rust
use std::mem::ManuallyDrop;

struct Resource {
    name: String,
}

impl Resource {
    fn new(name: &str) -> Self {
        println!("  创建: {}", name);
        Resource { name: name.to_string() }
    }
}

impl Drop for Resource {
    fn drop(&mut self) {
        println!("  释放: {}", self.name);
    }
}

fn main() {
    // === 默认析构顺序:字段按声明顺序 drop ===
    println!("=== 默认顺序 ===");
    {
        struct Container {
            first: Resource,
            second: Resource,
        }

        let _c = Container {
            first: Resource::new("第一"),
            second: Resource::new("第二"),
        };
        // 先 drop first,后 drop second(声明顺序)
    }

    // === 用 ManuallyDrop 自定义顺序 ===
    println!("\n=== 自定义顺序 ===");
    {
        struct CustomOrder {
            first: ManuallyDrop<Resource>,
            second: ManuallyDrop<Resource>,
        }

        impl Drop for CustomOrder {
            fn drop(&mut self) {
                // 先释放 second,再释放 first(反序)
                // SAFETY: 每个字段只 drop 一次
                unsafe {
                    ManuallyDrop::drop(&mut self.second);
                    ManuallyDrop::drop(&mut self.first);
                }
            }
        }

        let _c = CustomOrder {
            first: ManuallyDrop::new(Resource::new("第一")),
            second: ManuallyDrop::new(Resource::new("第二")),
        };
        // 先 drop second,后 drop first
    }

    // === 条件性 drop ===
    println!("\n=== 条件性 drop ===");
    {
        struct ConditionalDrop {
            resource: ManuallyDrop<Resource>,
            should_drop: bool,
        }

        impl Drop for ConditionalDrop {
            fn drop(&mut self) {
                if self.should_drop {
                    // SAFETY: 只在 should_drop 为 true 时 drop
                    unsafe { ManuallyDrop::drop(&mut self.resource); }
                } else {
                    println!("  跳过释放: {} (所有权已转移)", *self.resource.name);
                }
            }
        }

        let _a = ConditionalDrop {
            resource: ManuallyDrop::new(Resource::new("会释放")),
            should_drop: true,
        };

        let _b = ConditionalDrop {
            resource: ManuallyDrop::new(Resource::new("不释放")),
            should_drop: false,
        };
    }
}

防止双重释放 ​

rust
use std::mem::ManuallyDrop;

fn main() {
    // 场景:将值的所有权转移给外部代码(如 FFI)
    // 需要防止 Rust 的自动 Drop

    // 模拟将 String 传递给 C 代码
    fn transfer_to_c(s: String) -> *mut u8 {
        let mut md = ManuallyDrop::new(s);
        // 获取内部数据的指针
        let ptr = md.as_mut_ptr();
        // ManuallyDrop 不会 drop String
        // 所有权转移给了 C(通过 ptr)
        ptr
    }

    // 模拟从 C 代码取回所有权
    fn take_back_from_c(ptr: *mut u8, len: usize, capacity: usize) -> String {
        // SAFETY: ptr, len, capacity 来自之前的 String
        unsafe { String::from_raw_parts(ptr, len, capacity) }
    }

    let original = String::from("跨 FFI 传递");
    let len = original.len();
    let cap = original.capacity();
    println!("原始: {}", original);

    // 转移给 C
    let ptr = transfer_to_c(original);
    println!("已转移,ptr: {:p}", ptr);
    // original 已被移动,不会被 drop

    // 从 C 取回
    let recovered = take_back_from_c(ptr, len, cap);
    println!("取回: {}", recovered);
    // recovered 正常 drop

    // === 用 into_inner 代替 take ===
    println!("\n=== into_inner ===");
    let md = ManuallyDrop::new(String::from("安全取出"));
    let s = ManuallyDrop::into_inner(md);  // 安全!不需要 unsafe
    println!("into_inner: {}", s);
    // s 正常 drop
}

基本示例 ​

用 ManuallyDrop 实现一个所有权借用系统:

rust
use std::mem::ManuallyDrop;
use std::ops::{Deref, DerefMut};

/// 借出的资源:持有值但不负责 drop
/// 当借用结束时,值会被归还给原始所有者
struct Borrowed<T> {
    value: ManuallyDrop<T>,
}

impl<T> Borrowed<T> {
    /// 创建一个借出的资源(unsafe:调用者负责确保值最终被归还或释放)
    unsafe fn new(value: T) -> Self {
        Borrowed {
            value: ManuallyDrop::new(value),
        }
    }

    /// 归还资源,恢复所有权
    fn return_value(mut self) -> T {
        // SAFETY: value 有效,只取出一次
        let val = unsafe { ManuallyDrop::take(&mut self.value) };
        std::mem::forget(self);  // 防止 Borrowed 的 drop 被调用
        val
    }
}

impl<T> Deref for Borrowed<T> {
    type Target = T;
    fn deref(&self) -> &T {
        &self.value
    }
}

impl<T> DerefMut for Borrowed<T> {
    fn deref_mut(&mut self) -> &mut T {
        &mut self.value
    }
}

impl<T> Drop for Borrowed<T> {
    fn drop(&mut self) {
        // 如果 Borrowed 被 drop 而没有归还值,打印警告
        // 在实际项目中可能要 panic 或记录错误
        eprintln!("警告:借出的资源未归还,将被释放");
        // SAFETY: value 有效
        unsafe { ManuallyDrop::drop(&mut self.value); }
    }
}

/// 资源池
struct ResourcePool {
    items: Vec<Option<String>>,
}

impl ResourcePool {
    fn new(items: Vec<String>) -> Self {
        ResourcePool {
            items: items.into_iter().map(Some).collect(),
        }
    }

    /// 借出一个资源
    fn borrow(&mut self, index: usize) -> Option<Borrowed<String>> {
        if index >= self.items.len() {
            return None;
        }

        self.items[index].take().map(|item| {
            // SAFETY: 我们会通过 return_item 归还
            unsafe { Borrowed::new(item) }
        })
    }

    /// 归还资源
    fn return_item(&mut self, index: usize, item: Borrowed<String>) {
        if index < self.items.len() {
            self.items[index] = Some(item.return_value());
        }
    }

    fn status(&self) {
        for (i, item) in self.items.iter().enumerate() {
            match item {
                Some(s) => println!("  [{}] 可用: {}", i, s),
                None => println!("  [{}] 已借出", i),
            }
        }
    }
}

fn main() {
    let mut pool = ResourcePool::new(vec![
        String::from("资源A"),
        String::from("资源B"),
        String::from("资源C"),
    ]);

    println!("=== 初始状态 ===");
    pool.status();

    // 借出资源
    println!("\n=== 借出 ===");
    let mut borrowed = pool.borrow(1).unwrap();
    println!("借出: {}", *borrowed);
    pool.status();

    // 使用借出的资源
    borrowed.push_str(" (已修改)");
    println!("使用: {}", *borrowed);

    // 归还资源
    println!("\n=== 归还 ===");
    pool.return_item(1, borrowed);
    pool.status();

    // 再次借出(验证修改保留)
    println!("\n=== 再次借出 ===");
    let borrowed2 = pool.borrow(1).unwrap();
    println!("再次借出: {}", *borrowed2);

    // 归还
    pool.return_item(1, borrowed2);

    // 重复借出同一资源会返回 None
    println!("\n=== 重复借出 ===");
    let _b1 = pool.borrow(0).unwrap();
    let b2 = pool.borrow(0);
    println!("重复借出: {:?}", b2.is_none());

    // _b1 被 drop 但没有归还 → 会触发警告
    println!("\n=== 结束 ===");
}

常见问题 ​

问题一:ManuallyDrop 和 mem::forget 有什么区别?

mem::forget(val) 消耗值并阻止其析构器运行,但之后你无法再访问这个值。ManuallyDrop::new(val) 包装值并阻止自动析构,但你仍然可以通过 Deref 访问内部值,也可以稍后手动 drop。ManuallyDrop 更灵活。

问题二:ManuallyDrop::drop 后还能使用内部值吗?

不能。drop 后内部值已被析构,再次访问是未定义行为。这就是为什么 ManuallyDrop::drop 是 unsafe 的——调用者必须保证之后不再使用。

问题三:ManuallyDrop 有运行时开销吗?

没有。ManuallyDrop<T> 是 #[repr(transparent)],与 T 大小和对齐完全相同。编译器会优化掉包装层。

问题四:什么时候应该用 ManuallyDrop 而不是 Option?

当你需要在 union 中存储非 Copy 类型、需要精确控制析构顺序、或者需要将所有权转移到 FFI 而不触发 drop 时。如果只是需要"可能有值/可能没值",用 Option 更好。

适用场景 ​

  • union 字段:非 Copy 类型必须用 ManuallyDrop 包装
  • FFI 所有权转移:将 Rust 值传给 C 代码而不触发 drop
  • 自定义析构顺序:覆盖默认的字段 drop 顺序
  • 防止双重释放:在所有权转移后阻止自动 drop
  • 底层集合实现:管理未初始化或部分初始化的内存

注意事项 ​

  • ManuallyDrop::drop 是 unsafe,只能调用一次
  • drop 后不能再访问内部值
  • 忘记 drop 会导致资源泄漏
  • into_inner 是安全的,优先使用
  • ManuallyDrop<T> 与 T 大小完全相同
  • union 中的非 Copy 字段必须用 ManuallyDrop

总结 ​

ManuallyDrop<T> 阻止 Rust 自动调用内部值的析构器,让程序员手动控制资源释放的时机。它与 T 大小完全相同(零开销),通过 Deref/DerefMut 透明访问内部值。ManuallyDrop::drop(&mut md) 手动调用析构器(unsafe,只能一次),into_inner(md) 解包恢复自动 Drop(安全),take(&mut md) 移出值(unsafe)。主要用途包括:union 中的非 Copy 字段、FFI 所有权转移(防止 Rust 自动释放传给 C 的内存)、自定义析构顺序、防止双重释放。忘记手动 drop 会导致资源泄漏,drop 后再访问是 UB。