Question

我正在编写一个Rust库，它是C ++库的包装器。

这是C ++方面：

#define Result(type,name) typedef struct { type value; const char* message; } name

extern "C" 
{
    Result(double, ResultDouble);

    ResultDouble myFunc() 
    {
        try
        {
            return ResultDouble{value: cv::someOpenCvMethod(), message: nullptr};
        }
        catch( cv::Exception& e )
        {
            const char* err_msg = e.what();
            return ResultDouble{value: 0, message: err_msg};
        }
    }
}

和相应的Rust方面：

#[repr(C)]
struct CResult<T> {
    value: T,
    message: *mut c_char,
}

extern "C" {
    fn myFunc() -> CResult<c_double>;
}

pub fn my_func() -> Result<f64, Cow<'static, str>> {
    let result = unsafe { myFunc() };
    if result.message.is_null() {
        Ok(result.value)
    } else {
        unsafe {
            let str = std::ffi::CString::from_raw(result.message);
            let err = match str.into_string() {
                Ok(message) => message.into(),
                _ => "Unknown error".into(),
            };
            Err(err)
        }
    }
}

我在这里有两个问题：

我可以在C ++端使用*const char但在Rust上使用*mut c_char吗？我需要它，因为CString::from_raw需要可变引用。
我应该使用CStr吗？如果是的话，我该如何管理它的生命周期？我应该释放这个记忆还是静态生命？

通常我只想映射在FFI调用Rust Result<T,E>

这样做的惯用方法是什么？

Answer 1

我可以在C ++端使用* const char但在Rust上使用* mut c_char吗？我需要它，因为CString :: from_raw需要可变引用。

CString::from_raw上的文档已经回答了问题的第一部分：

＆＃34;只能通过在CString＆＃34;上调用into_raw获得的指针来调用它。

尝试使用指向不是由CString创建的字符串的指针在这里是不合适的，并且会吃掉你的衣服。

我应该使用CStr吗？如果是的话，我该如何管理它的生命周期？我应该释放这个记忆还是静态生命？

如果保证返回的C样式字符串具有静态生命周期（如，它具有static duration），那么您可以从中创建&'static CStr并返回该字符串。但是，情况并非如此：cv::Exception包含多个成员，其中一些成员拥有字符串对象。一旦程序离开myFunc的范围，被捕获的异常对象e就会被销毁，因此来自what()的任何内容都将失效。

        const char* err_msg = e.what();
        return ResultDouble{0, err_msg}; // oops! a dangling pointer is returned

虽然可以跨FFI边界传输值，但所有权的责任应始终保持在该值的来源。换句话说，如果C ++代码正在创建异常并且我们想要将这些信息提供给Rust代码，那么它必须保留该值并最终释放它的C ++代码。我冒昧在下面选择了一种可能的方法。

通过关注this question on duplicating C strings，我们可以重新实现myFunc以将字符串存储在动态分配的数组中：

#include <cstring>

ResultDouble myFunc() 
{
    try
    {
        return ResultDouble{value: cv::someOpenCvMethod(), message: nullptr};
    }
    catch( cv::Exception& e )
    {
        const char* err_msg = e.what();
        auto len = std::strlen(err_msg);
        auto retained_err = new char[len + 1];
        std::strcpy(retained_err, err_msg);
        return ResultDouble{value: 0, message: retained_err};
    }
}

这使得我们返回一个指向有效内存的指针。然后，必须公开一个新的公共函数来释放结果：

// in extern "C"
void free_result(ResultDouble* res) {
    delete[] res->message;
}

在Rust-land中，我们将使用this question中描述的方法保留相同字符串的副本。完成后，我们不再需要result的内容，因此可以通过对free_result的FFI函数调用来释放它。处理to_str()没有unwrap的结果只会留给读者。

extern "C" {
    fn myFunc() -> CResult<c_double>;
    fn free_result(res: *mut CResult<c_double>);
}

pub fn my_func() -> Result<f64, String> {
    let result = unsafe {
        myFunc()
    };
    if result.message.is_null() {
        Ok(result.value)
    } else {
        unsafe {
            let s = std::ffi::CStr::from_ptr(result.message);
            let str_slice: &str = c_str.to_str().unwrap();
            free_result(&mut result);
            Err(str_slice.to_owned())
        }
    }
}

将C ++异常映射到Result

1 个答案: