错误：`line`的寿命不够长（但我确实知道）

Question

我试图用C编写的库来制作某种ffi，但是卡住了。 这是一个测试用例：

extern crate libc;
use libc::{c_void, size_t};

// this is C library api call
unsafe fn some_external_proc(_handler: *mut c_void, value: *const c_void,
                             value_len: size_t) {
    println!("received: {:?}" , std::slice::from_raw_buf(
             &(value as *const u8), value_len as usize));
}

// this is Rust wrapper for C library api
pub trait MemoryArea {
    fn get_memory_area(&self) -> (*const u8, usize);
}

impl MemoryArea for u64 {
    fn get_memory_area(&self) -> (*const u8, usize) {
        (unsafe { std::mem::transmute(self) }, std::mem::size_of_val(self))
    }
}

impl <'a> MemoryArea for &'a str {
    fn get_memory_area(&self) -> (*const u8, usize) {
        let bytes = self.as_bytes();
        (bytes.as_ptr(), bytes.len())
    }
}

#[allow(missing_copy_implementations)]
pub struct Handler<T> {
    obj: *mut c_void,
}

impl <T> Handler<T> {
    pub fn new() -> Handler<T> { Handler{obj: std::ptr::null_mut(),} }

    pub fn invoke_external_proc(&mut self, value: T) where T: MemoryArea {
        let (area, area_len) = value.get_memory_area();
        unsafe {
            some_external_proc(self.obj, area as *const c_void,
                               area_len as size_t)
        };
    }
}

// this is Rust wrapper user code
fn main() {
    let mut handler_u64 = Handler::new();
    let mut handler_str = Handler::new();

    handler_u64.invoke_external_proc(1u64); // OK
    handler_str.invoke_external_proc("Hello"); // also OK
    loop  {
        match std::io::stdin().read_line() {
            Ok(line) => {
                let key =
                    line.trim_right_matches(|&: c: char| c.is_whitespace());

                //// error: `line` does not live long enough
                // handler_str.invoke_external_proc(key)
            }
            Err(std::io::IoError { kind: std::io::EndOfFile, .. }) => break ,
            Err(error) => panic!("io error: {}" , error),
        }
    }
}

防锈围栏

如果我在循环中取消注释行，我会得到“行不够长”的错误。 事实上，我意识到Rust害怕我可以将短生命引用存储在Handler对象内部的某个切片中，但我确信我不会，而且我也知道，将指针传递给外部是安全的proc（实际上，内存在C库端被临时复制）。

我有什么方法可以绕过这张支票吗？

Answer 1

问题是，如果您真的想要为函数执行此操作，则会错误地对结构进行参数化。 在创建当前的Handler ，struct将专门使用包含生命周期的类型。 然而，寿命line是仅针对块，所以不可能有寿命为处理程序 ，持续多个循环迭代。

你想要的是生命与函数调用有关，而不是结构的生命。 如您所述，如果您将生命周期放在结构上，那么结构就能够存储该长度的引用。 你不需要它，所以把泛型类型放在函数上：

impl Handler {
    pub fn new() -> Handler { Handler{obj: std::ptr::null_mut(),} }

    pub fn invoke_external_proc<T>(&mut self, value: T) where T: MemoryArea {
        let (area, area_len) = value.get_memory_area();
        unsafe {
            some_external_proc(self.obj, area as *const c_void,
                               area_len as size_t)
        };
    }
}

修改后的答案

既然你想在类型上专门化结构，但是不要过多关注类型的生命周期，那么试试这个：

#[allow(missing_copy_implementations)]
pub struct Handler<T: ?Sized> {
    obj: *mut c_void,
}

impl<T: ?Sized> Handler<T> {
    pub fn new() -> Handler<T> { Handler{ obj: std::ptr::null_mut() } }

    pub fn invoke_external_proc(&mut self, value: &T) where T: MemoryArea {
        let (area, area_len) = value.get_memory_area();
        unsafe {
            some_external_proc(self.obj, area as *const c_void,
                               area_len as size_t)
        };
    }
}

在这里，我们允许类型不合格 。 由于您无法将未大小的值作为参数传递，因此我们现在必须使用引用。 我们还必须改变impl ：

impl MemoryArea for str {
    fn get_memory_area(&self) -> (*const u8, usize) {
        let bytes = self.as_bytes();
        (bytes.as_ptr(), bytes.len())
    }
}