Rust C语言FFI交互库c-types的使用：安全高效的C语言类型转换与兼容性支持

rust-c-types

该库重新导出了libc和winapi中定义的类型，以减少代码中需要的条件编译。不再需要这样写代码：

#[cfg(unix)]
use libc::some_type;

#[cfg(windows)]
use winapi::some_type;

现在可以这样写：

use c_types::some_type;

文档

API文档可在查看。

贡献

这个crate是非穷尽的 - 我根据需要为我的项目添加类型。

如果有应该包含但未包含的类型，添加它应该没有问题。请开一个问题，或者更好的是，发送一个pull请求。

完整示例

下面是一个完整的示例展示如何使用c-types进行跨平台FFI交互：

// 引入c-types库
use c_types::{c_int, c_char};

// 定义与C兼容的函数
#[no_mangle]
pub extern "C" fn rust_function(input: c_int) -> c_int {
    input * 2
}

// 定义与C兼容的结构体
#[repr(C)]
pub struct CStruct {
    pub number: c_int,
    pub name: [c_char; 32],
}

// 使用示例
fn main() {
    // 使用c_types中的类型
    let num: c_int = 42;
    let result = rust_function(num);
    println!("Result: {}", result);
    
    // 创建C兼容结构体
    let mut my_struct = CStruct {
        number: 10,
        name: [0; 32],
    };
    
    // 填充name字段(假设这是来自C的字符串)
    let name = b"Hello from Rust\0";
    for (i, &byte) in name.iter().enumerate() {
        my_struct.name[i] = byte as c_char;
    }
}

安装

在项目目录中运行以下Cargo命令：

cargo add c-types

或者将以下行添加到你的Cargo.toml中：

c-types = "5.0.0"

所有者

David Hotham (dimbleby)

完整示例代码

以下是一个更完整的FFI交互示例，展示了如何使用c-types库进行Rust与C语言的双向调用：

// 引入c-types库中的类型
use c_types::{c_int, c_char, c_void};

// 定义与C兼容的函数 - 将被C代码调用
#[no_mangle]
pub extern "C" fn rust_add(a: c_int, b: c_int) -> c_int {
    a + b
}

// 定义与C兼容的回调函数类型
type Callback = extern "C" fn(c_int, *const c_char);

// 定义与C兼容的结构体
#[repr(C)]
pub struct UserData {
    pub id: c_int,
    pub name: [c_char; 32],
    pub callback: Option<Callback>,
}

// 暴露给C调用的函数，处理UserData
#[no_mangle]
pub extern "C" fn process_user_data(data: *mut UserData) -> c_int {
    unsafe {
        if let Some(user) = data.as_mut() {
            if let Some(cb) = user.callback {
                let msg = b"Processing complete\0";
                let mut buff = [0 as c_char; 32];
                for (i, &byte) in msg.iter().enumerate() {
                    buff[i] = byte as c_char;
                }
                cb(user.id, buff.as_ptr());
            }
            return 0; // 成功
        }
    }
    -1 // 失败
}

// 模拟C库函数
extern "C" {
    fn c_library_function(input: c_int, output: *mut c_int) -> c_int;
}

// 使用示例
fn main() {
    // 调用Rust实现的C兼容函数
    let sum = rust_add(10, 20);
    println!("10 + 20 = {}", sum);
    
    // 准备调用C库函数
    let input: c_int = 42;
    let mut output: c_int = 0;
    
    // 安全包装外部C函数调用
    let result = unsafe { c_library_function(input, &mut output) };
    
    if result == 0 {
        println!("C function returned: {}", output);
    }
    
    // 创建并处理UserData结构体
    let mut user = UserData {
        id: 1,
        name: [0; 32],
        callback: Some(callback_example),
    };
    
    // 填充name字段
    let name = b"Rust User\0";
    for (i, &byte) in name.iter().enumerate() {
        user.name[i] = byte as c_char;
    }
    
    // 处理user数据
    let status = unsafe { process_user_data(&mut user) };
    println!("User data processing status: {}", status);
}

// 回调函数示例
extern "C" fn callback_example(id: c_int, msg: *const c_char) {
    unsafe {
        println!("Callback for user {}: {:?}", id, std::ffi::CStr::from_ptr(msg));
    }
}

这个示例展示了：

1. Rust函数暴露给C代码调用
2. 定义C兼容的结构体和回调函数
3. 调用外部C函数
4. 处理指针和内存安全
5. 字符串在FFI边界的传递

所有类型都来自c-types库，确保跨平台兼容性。