Rust中如何让Basket销毁时自动销毁关联Apple？（不可改目标函数）

可以通过构建自引用容器结构体来满足需求，让容器同时持有Apple的所有权和依赖它的Basket，利用Rust的Drop trait确保容器销毁时两者被一同清理。以下提供两种实现方式：

一、手动unsafe实现（无外部依赖） #

适合不想引入第三方库的场景，需手动保证内存安全：

use std::ptr;
use std::marker::PhantomData;

// 模拟外部包的类型与函数
struct Apple;
struct Basket<'a>(&'a mut Apple);
fn basket_from_apple(apple: &mut Apple) -> Basket<'_> { Basket(apple) }

// 自定义容器：持有Apple所有权和Basket的自引用
struct AppleBasket {
    // 私有字段：Apple的所有权由Box持有
    apple: Box<Apple>,
    // 用裸指针存储Basket，绕开Rust的自引用生命周期检查
    basket: *mut Basket<'static>,
    // 标记持有Apple所有权，避免编译器警告
    _phantom: PhantomData<Apple>,
}

impl AppleBasket {
    // 创建容器：传入Apple，生成绑定的Basket
    fn new(apple: Apple) -> Self {
        let mut boxed_apple = Box::new(apple);
        let basket = basket_from_apple(&mut *boxed_apple);
        // 将Basket装箱后转为裸指针，剥离生命周期约束
        let basket_ptr = Box::into_raw(Box::new(basket));

        AppleBasket {
            apple: boxed_apple,
            basket: basket_ptr,
            _phantom: PhantomData,
        }
    }

    // 提供不可变访问Basket的接口，外部只能通过引用操作
    fn basket(&self) -> &Basket<'_> {
        // 安全断言：容器存活期间，Apple不会被移动或销毁，Basket指针始终有效
        unsafe { &*self.basket }
    }
}

// 实现Drop：先销毁Basket，再销毁Apple，避免悬垂引用
impl Drop for AppleBasket {
    fn drop(&mut self) {
        unsafe {
            // 恢复Basket的Box并销毁
            let _ = Box::from_raw(self.basket);
        }
        // Apple会被Box自动销毁
    }
}

// 禁止容器跨线程移动/共享，避免裸指针引发的线程安全问题
impl !Send for AppleBasket {}
impl !Sync for AppleBasket {}

关键特性说明 #

• Apple是私有字段，外部无法直接访问或修改
• Basket仅能通过basket()方法获取不可变引用，无法被移动或修改
• 容器销毁时，Drop trait保证先清理Basket再释放Apple，完全无需手动持有Apple

二、使用第三方库简化实现（更安全） #

借助ouroboros库（专门处理自引用结构体的proc-macro库），无需手动编写unsafe代码：

use ouroboros::self_referencing;

// 模拟外部包的类型与函数
struct Apple;
struct Basket<'a>(&'a mut Apple);
fn basket_from_apple(apple: &mut Apple) -> Basket<'_> { Basket(apple) }

// 用宏生成安全的自引用容器
#[self_referencing]
struct AppleBasket {
    apple: Box<Apple>,
    // 标记basket borrows自mut apple，自动处理生命周期
    #[borrows(mut apple)]
    basket: Basket<'this>,
}

impl AppleBasket {
    fn new(apple: Apple) -> Self {
        AppleBasketBuilder {
            apple: Box::new(apple),
            // 传入闭包生成绑定的Basket
            basket_builder: |apple| basket_from_apple(apple),
        }.build()
    }

    // 提供不可变访问Basket的接口
    fn basket(&self) -> &Basket<'_> {
        self.basket()
    }
}

优势 #

• 库自动处理自引用的生命周期安全，无需手动写unsafe
• 天然禁止容器移动（自引用结构体被宏限制了移动语义）
• 完全满足需求：Apple私有、Basket仅可通过不可变引用访问、销毁时一同清理

内容的提问来源于stack exchange，提问作者enigmaticPhysicist