c++ - 将 C++ 异常映射到结果

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)
        }
    }
}

这里有两个问题:

1. 我可以使用 *const char 吗？在 C++ 方面但是 *mut c_char在 Rust 上？我需要它因为CString::from_raw需要可变引用。
2. 我应该使用 CStr 吗？反而？如果是，我应该如何管理它的生命周期？我应该释放此内存还是它具有静态生命周期？

通常我只想将 FFI 调用中发生的 C++ 异常映射到 Rust Result<T,E>

惯用的方法是什么？

Answer 1

1. Is it ok that I use *const char on C++ side but *mut c_char on Rust one? I need it because CString::from_raw requires mutable reference.

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

"This should only ever be called with a pointer that was earlier obtained by calling into_raw on a CString".

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

2. Should I use CStr instead? If yes, how should I manage its lifetime? Should I free this memory or maybe it has static lifetime?

如果保证返回的 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 边界转移值(value)，但所有权的责任应始终留在该值(value)的源头。换句话说，如果 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};
    }
}

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

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

在 Rust-land 中，我们将使用 this question 中描述的方法保留相同字符串的拷贝。 .完成后，我们不再需要 result 的内容，因此可以通过对 free_result 的 FFI 函数调用来释放它。在不使用 unwrap 的情况下处理 to_str() 的结果留给读者作为练习。

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())
        }
    }
}