如何将 C 字符串转换为 Rust 字符串并通过 FFI 转换回来？

Question

我正在尝试获取 C 库返回的 C 字符串，并通过 FFI 将其转换为 Rust 字符串。

mylib.c

const char* hello(){
    return "Hello World!";
}

ma​​in.rs

#![feature(link_args)]

extern crate libc;
use libc::c_char;

#[link_args = "-L . -I . -lmylib"]
extern {
    fn hello() -> *c_char;
}

fn main() {
    //how do I get a str representation of hello() here?
}

Answer 1

在 Rust 中处理 C 字符串的最佳方式是使用来自 std::ffi 模块的结构，即 CStr 和 CString。

CStr 是动态大小的类型，因此只能通过指针使用。这使它与常规的str 类型非常相似。您可以使用不安全的CStr::from_ptr 静态方法从*const c_char 构造&CStr。这个方法是不安全的，因为不能保证你传递给它的原始指针是有效的，它确实指向一个有效的 C 字符串并且字符串的生命周期是正确的。

您可以使用&CStr 的to_str() 方法从&str 获取&str。

这是一个例子：

extern crate libc;

use libc::c_char;
use std::ffi::CStr;
use std::str;

extern {
    fn hello() -> *const c_char;
}

fn main() {
    let c_buf: *const c_char = unsafe { hello() };
    let c_str: &CStr = unsafe { CStr::from_ptr(c_buf) };
    let str_slice: &str = c_str.to_str().unwrap();
    let str_buf: String = str_slice.to_owned();  // if necessary
}

您需要考虑*const c_char 指针的生命周期以及谁拥有它们。根据 C API，您可能需要对字符串调用特殊的释放函数。您需要仔细安排转换，以便切片不会超过指针。 CStr::from_ptr 返回具有任意生命周期的 &CStr 的事实在这里有所帮助（尽管它本身很危险）；例如，您可以将 C 字符串封装到一个结构中并提供 Deref 转换，这样您就可以像使用字符串切片一样使用您的结构：

extern crate libc;

use libc::c_char;
use std::ops::Deref;
use std::ffi::CStr;

extern "C" {
    fn hello() -> *const c_char;
    fn goodbye(s: *const c_char);
}

struct Greeting {
    message: *const c_char,
}

impl Drop for Greeting {
    fn drop(&mut self) {
        unsafe {
            goodbye(self.message);
        }
    }
}

impl Greeting {
    fn new() -> Greeting {
        Greeting { message: unsafe { hello() } }
    }
}

impl Deref for Greeting {
    type Target = str;

    fn deref<'a>(&'a self) -> &'a str {
        let c_str = unsafe { CStr::from_ptr(self.message) };
        c_str.to_str().unwrap()
    }
}

此模块中还有另一种类型，称为CString。它与 CStr 的关系与 String 与 str 的关系相同 - CString 是 CStr 的拥有版本。这意味着它“持有”字节数据分配的句柄，删除CString 将释放它提供的内存（本质上，CString 包装了Vec<u8>，后者将被删除）。因此，当您想将 Rust 中分配的数据公开为 C 字符串时，它很有用。

不幸的是，C 字符串总是以零字节结尾，并且其中不能包含一个，而 Rust &[u8]/Vec<u8> 正好相反——它们不以零字节结尾，并且可以包含任意数量的他们在里面。这意味着从 Vec<u8> 到 CString 既不是无错误也不是无分配 - CString 构造函数都会检查您提供的数据中的零，如果找到则返回错误，并附加一个零字节到可能需要重新分配的字节向量的末尾。

像String，它实现了Deref<Target = str>，CString实现了Deref<Target = CStr>，所以你可以直接在CString上调用定义在CStr上的方法。这很重要，因为返回 C 互操作所需的 *const c_char 的 as_ptr() 方法是在 CStr 上定义的。可以直接在CString的值上调用这个方法，很方便。

CString 可以从可以转换为Vec<u8> 的所有内容创建。 String、&str、Vec<u8> 和 &[u8] 是构造函数 CString::new() 的有效参数。当然，如果你传递一个字节切片或字符串切片，则会创建一个新的分配，而Vec<u8> 或String 将被消耗。

extern crate libc;

use libc::c_char;
use std::ffi::CString;

fn main() {
    let c_str_1 = CString::new("hello").unwrap(); // from a &str, creates a new allocation
    let c_str_2 = CString::new(b"world" as &[u8]).unwrap(); // from a &[u8], creates a new allocation
    let data: Vec<u8> = b"12345678".to_vec(); // from a Vec<u8>, consumes it
    let c_str_3 = CString::new(data).unwrap();

    // and now you can obtain a pointer to a valid zero-terminated string
    // make sure you don't use it after c_str_2 is dropped
    let c_ptr: *const c_char = c_str_2.as_ptr();

    // the following will print an error message because the source data
    // contains zero bytes
    let data: Vec<u8> = vec![1, 2, 3, 0, 4, 5, 0, 6];
    match CString::new(data) {
        Ok(c_str_4) => println!("Got a C string: {:p}", c_str_4.as_ptr()),
        Err(e) => println!("Error getting a C string: {}", e),
    }  
}

如果您需要将CString 的所有权转移到C 代码，您可以调用CString::into_raw。然后你需要取回指针并在 Rust 中释放它； Rust 分配器不太可能与 malloc 和 free 使用的分配器相同。您需要做的就是调用CString::from_raw，然后让字符串正常删除。

Answer 2

除了@vladimir-matveev 所说的，你还可以在没有CStr 或CString 的帮助下在它们之间进行转换：

#![feature(link_args)]

extern crate libc;
use libc::{c_char, puts, strlen};
use std::{slice, str};

#[link_args = "-L . -I . -lmylib"]
extern "C" {
    fn hello() -> *const c_char;
}

fn main() {
    //converting a C string into a Rust string:
    let s = unsafe {
        let c_s = hello();
        str::from_utf8_unchecked(slice::from_raw_parts(c_s as *const u8, strlen(c_s)+1))
    };
    println!("s == {:?}", s);
    //and back:
    unsafe {
        puts(s.as_ptr() as *const c_char);
    }
}

只需确保在从 &str 转换为 C 字符串时，您的 &str 以 '\0' 结尾。 请注意，在上面的代码中，我使用strlen(c_s)+1 而不是strlen(c_s)，所以s 是"Hello World!\0"，而不仅仅是"Hello World!"。
（当然，在这种特殊情况下，它甚至可以仅使用 strlen(c_s)。但是使用新的 &str 不能保证生成的 C 字符串会在预期的位置终止。）
下面是运行代码的结果：

s == "Hello World!\u{0}"
Hello World!