ManuallyDrop 手动释放
核心概念
std::mem::ManuallyDrop<T> 是一个包装类型,它阻止 Rust 自动调用内部值的析构器(Drop)。正常情况下,当一个值离开作用域时,Rust 会自动调用它的 drop 方法来释放资源(如堆内存、文件句柄等)。ManuallyDrop<T> 让程序员自己决定何时、是否调用析构器。
ManuallyDrop<T> 与 T 大小和对齐完全相同(#[repr(transparent)]),是零开销的。它主要用于以下场景:union 中包含非 Copy 类型的字段、需要精确控制析构顺序的底层代码、防止双重释放、以及与 FFI 交互时管理所有权转移。
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
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 中使用
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 时正确释放所有资源
}控制析构顺序
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,
};
}
}防止双重释放
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 实现一个所有权借用系统:
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。