字符串转换的Rust，FFI和生存期

Question

I'm working in an FFI library and have encountered this pattern quite a few times that I don't know how to handle idiomatically.

impl CanVoidStar for str {
    fn as_cvoid_ptr(&self) -> *const c_void {
        let string = CString::new(self).unwrap(); 
        unsafe {
            return mem::transmute(string.as_ptr());
        }
    }
}

My intent was to create a const *void pointer to a piece of memory that I can hand off to a C function. The problem that here is that string goes out of scope and thus I get undefined behavior in the unsafe block.

Is there a way I can keep string allocated on the heap until whatever it is that is using the return value done with it? Further, is there a idiomatic way to handle this or do I need to redesign my algorithms?

Answer 1

It looks like you're using the wrong method on CString , and CString::into_raw() is what you want. Even better, it needs no unsafe code until you want to free the memory again.

While CString::as_ptr() returns a pointer into the string, CString::into_raw() passes the ownership of the memory into the raw pointer; this is intended for exactly your use case:

trait CanVoidStar {
    fn as_cvoid_ptr(&self) -> *const c_void;
}

impl CanVoidStar for str {
   fn as_cvoid_ptr(&self) -> *const c_void {
        let string = CString::new(self).unwrap();
        string.into_raw() as *const c_void
    }
}

As the documentation says, if you ever want to free it, you'll need to reconstruct the CString using CString::from_raw() and then have it dropped as usual.