FFI交互实践 - 元素码农

发布时间: 2025-03-22 09:15

↑

# FFI交互实践

Rust提供了强大的外部函数接口（FFI）功能，允许Rust代码与其他编程语言（主要是C语言）进行交互。本文将详细介绍FFI的使用方法和最佳实践。

## FFI基础

### 1. 外部函数声明

```rust
#[link(name = "c_lib")]
extern "C" {
    fn abs(input: i32) -> i32;
    fn strlen(s: *const i8) -> usize;
}

fn main() {
    unsafe {
        let x = abs(-42);
        println!("绝对值: {}", x);
    }
}
```

### 2. 数据类型映射

常见的Rust与C类型对应关系：

```rust
// Rust类型 -> C类型
i32       -> int32_t
u32       -> uint32_t
i8        -> char
*const T  -> const T*
*mut T    -> T*
```

## 导出Rust函数

### 1. 基本导出

```rust
#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}
```

### 2. 回调函数

```rust
type Callback = extern "C" fn(i32) -> i32;

#[no_mangle]
pub extern "C" fn process_with_callback(x: i32, callback: Callback) -> i32 {
    callback(x)
}
```

## 内存管理

### 1. 字符串处理

```rust
use std::ffi::{CString, CStr};
use std::os::raw::c_char;

#[no_mangle]
pub extern "C" fn process_string(s: *const c_char) -> *mut c_char {
    let c_str = unsafe { CStr::from_ptr(s) };
    let r_str = c_str.to_str().unwrap();
    
    let modified = format!("处理后的字符串: {}", r_str);
    let c_string = CString::new(modified).unwrap();
    c_string.into_raw()
}

#[no_mangle]
pub extern "C" fn free_string(s: *mut c_char) {
    unsafe {
        if !s.is_null() {
            let _ = CString::from_raw(s);
        }
    }
}
```

### 2. 结构体对齐

```rust
#[repr(C)]
pub struct Point {
    x: f64,
    y: f64,
}

#[no_mangle]
pub extern "C" fn distance(p1: Point, p2: Point) -> f64 {
    let dx = p2.x - p1.x;
    let dy = p2.y - p1.y;
    (dx * dx + dy * dy).sqrt()
}
```

## 错误处理

### 1. 错误码

```rust
#[repr(C)]
pub enum Status {
    Success = 0,
    InvalidInput = 1,
    NullPointer = 2,
}

#[no_mangle]
pub extern "C" fn safe_division(a: f64, b: f64, result: *mut f64) -> Status {
    if result.is_null() {
        return Status::NullPointer;
    }
    
    if b == 0.0 {
        return Status::InvalidInput;
    }
    
    unsafe {
        *result = a / b;
    }
    Status::Success
}
```

### 2. 异常处理

```rust
use std::panic::catch_unwind;

#[no_mangle]
pub extern "C" fn safe_operation() -> i32 {
    match catch_unwind(|| {
        // 可能发生panic的操作
        42
    }) {
        Ok(result) => result,
        Err(_) => -1,
    }
}
```

## 性能优化

### 1. 零拷贝技术

```rust
use std::slice;

#[no_mangle]
pub extern "C" fn process_array(
    data: *const u8,
    len: usize,
    out: *mut u8,
    out_len: *mut usize
) -> Status {
    let input = unsafe {
        if data.is_null() { return Status::NullPointer; }
        slice::from_raw_parts(data, len)
    };
    
    // 处理数据，直接在原始内存上操作
    unsafe {
        if out.is_null() { return Status::NullPointer; }
        let output = slice::from_raw_parts_mut(out, len);
        output.copy_from_slice(input);
        *out_len = len;
    }
    
    Status::Success
}
```

### 2. 并行计算

```rust
use rayon::prelude::*;

#[no_mangle]
pub extern "C" fn parallel_sum(data: *const i32, len: usize) -> i64 {
    let slice = unsafe {
        if data.is_null() { return 0; }
        slice::from_raw_parts(data, len)
    };
    
    slice.par_iter()
         .map(|&x| x as i64)
         .sum()
}
```

## 调试与测试

### 1. 日志记录

```rust
use log::{info, error};

#[no_mangle]
pub extern "C" fn logged_operation(x: i32) -> i32 {
    info!("开始处理: {}", x);
    
    let result = match x {
        0 => {
            error!("无效输入: 0");
            return -1;
        }
        n => n * 2
    };
    
    info!("处理完成: {}", result);
    result
}
```

### 2. 单元测试

```rust
#[cfg(test)]
mod tests {
    use super::*;
    use std::ffi::CString;
    
    #[test]
    fn test_process_string() {
        let input = CString::new("hello").unwrap();
        let result = process_string(input.as_ptr());
        let output = unsafe { CStr::from_ptr(result).to_string_lossy().into_owned() };
        assert!(output.contains("hello"));
        unsafe { free_string(result); }
    }
}
```

## 最佳实践

1. **安全封装**：始终为不安全的FFI函数提供安全的Rust封装
2. **错误处理**：使用明确的错误码或结果类型
3. **内存管理**：谨慎处理内存分配和释放
4. **类型安全**：使用`repr(C)`确保结构体布局兼容
5. **文档化**：详细记录FFI接口的使用要求和限制

## 总结

Rust的FFI功能为与其他语言的互操作提供了强大而灵活的机制。通过合理使用FFI，我们可以充分利用现有的C语言生态系统，同时保持Rust的安全性和性能优势。在实际应用中，需要特别注意内存管理和错误处理，确保跨语言交互的可靠性和安全性。