rust - 使结构比给该结构的方法的参数存活时间更长

Question

我正在寻找一种方法来确保结构比给该结构的方法的参数更有效。
即使结构在离开方法后不持有对该数据的引用。

这是用于提供给 FFI 的包装原始指针。我想保证实现 FFI 的结构比 Option<&'a Any> 生命周期更长。我用来将 Rust 对象提供给指针包装器。
Context是 FFI 包装器。Data保存映射到 FFI 类型的不同类型。 FFI 函数在返回之前立即复制所有这些类型。

除了原始指针。

所以我给 Context 添加了一个生命周期说明符仅用于那些并在 send_data() 中使用它.

但不知何故，这还不够。我希望下面的代码无法编译。

编辑:Rust Discord 的某个人建议制作 &self mut能够在 send_data() .这具有预期的效果，但我的 FFI 是线程安全的(和无状态的)和 send_data()时间紧迫。所以我非常想避免这种情况。

use std::any::Any;
use std::marker::PhantomData;

struct IntegerArray<'a> {
    data: &'a [i32],
}

struct WrappedRawPointer<'a> {
    ptr: *const std::ffi::c_void,
    _marker: PhantomData<&'a ()>,
}

impl<'a> WrappedRawPointer<'a> {
    fn new(data: Option<&'a dyn Any>) -> Self {
        Self {
            ptr: data
                .map(|p| p as *const _ as *const std::ffi::c_void)
                .unwrap_or(std::ptr::null()),
            _marker: PhantomData,
        }
    }
}

enum Data<'a, 'b> {
    IntegerArray(IntegerArray<'a>),
    WrappedRawPointer(WrappedRawPointer<'b>),
}

struct Context<'a> {
    ctx: u32,
    _marker: PhantomData<&'a ()>,
}

impl<'a> Context<'a> {
    fn new() -> Self {
        Self {
            ctx: 0, // Call FFI to initialize context
            _marker: PhantomData,
        }
    }

    fn send_data(&self, data: Data<'_, 'a>) {
        match data {
            Data::IntegerArray(_i) => (),      // Call FFI function
            Data::WrappedRawPointer(_p) => (), // Call FFI function
        }
    }
}

fn main() {
    let ctx = Context::new();

    {
        let some_float: f32 = 42.0;
        ctx.send_data(
            Data::WrappedRawPointer(
                WrappedRawPointer::new(
                    Some(&some_float)
                )
            )
        );

        // I would like rustc to complain 
        // here that some_float does not
        // outlive ctx
    }

    // Explicitly drop outside
    // the previous block to 
    // prevent rustc from being
    // clever
    drop(ctx);
}

Answer 1

制作 send_data取 &mut self而不是 &self有效，因为它使 self 的类型参数相对于类型不变 Self . Subtyping and Variance在 Rustonomicon 以及 Stack Overflow 上的其他问题中有描述(见下文)。

既然你想要不变性，即使 self是一个不可变的引用，这表明 Context<'a> 的方差本身是错误的:它在 'a 中是协变的，但它应该是不变的。您可以通过将类型参数更改为 PhantomData 来解决此问题。到在 'a 中也是不变的东西:

struct Context<'a> {
    ctx: u32,
    _marker: PhantomData<*mut &'a ()>,  // or Cell<&'a ()>, or fn(&'a ()) -> &'a (), etc.
}

PhantomData不仅仅是你为了让编译器不会对你大喊大叫而机械地添加的东西。 PhantomData的类型参数的具体形式告诉编译器你的结构是如何与它的类型和生命周期参数相关的(当编译器自己无法弄清楚时)。在这种情况下，您想告诉编译器 Context<'some_long_lifetime>不能代替 Context<'a_much_shorter_lifetime>即使它的字段都允许这种替换。

关于方差的更多问题

How can this instance seemingly outlive its own parameter lifetime?

Why does linking lifetimes matter only with mutable references?

How do I share a struct containing a phantom pointer among threads? (如果 Context 应该是 Send 或 Sync，则可能相关)