将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};
}
}
}

和相应的锈侧：

#[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. 我可以在C++端使用*const char但在 Rust 方面使用*mut c_char吗？我需要它，因为CString::from_raw需要可变引用。
2. 我应该改用CStr吗？如果是，我应该如何管理其生命周期？我应该释放此内存还是具有静态生存期？

通常，我只想映射一个C++异常，该异常发生在 FFI 调用 RustResult<T,E>

惯用的方法是什么？

Answer 1

我可以在

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

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

"这只能使用之前通过CString上调用into_raw获得的指针来调用

"。

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

2. 我应该改用 CStr 吗？如果是，我应该如何管理其生命周期？我应该释放此内存还是具有静态生存期？

如果返回的 C 样式字符串保证具有静态生存期(如 in ，它具有静态持续时间)，则可以从中创建&'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++代码必须保留该值并最终释放它。我冒昧地在下面选择了一种可能的方法。

通过遵循有关复制 C 字符串的问题，我们可以重新实现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 中，我们将使用此问题中描述的方法保留相同字符串的副本。一旦完成，我们不再需要result的内容，因此可以通过 FFI 函数调用来释放它free_result。不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())
}
}
}