在 Rust 与 C 语言进行外部函数接口 (FFI) 交互时，开发者常会遇到内存安全问题，例如段错误、内存泄漏或未定义行为。这些问题多源于对跨语言边界的资源管理理解不足。本文将深入探讨三个最易导致 FFI 代码崩溃的常见陷阱，并提供有效的规避方法。

1. 误解所有权转移

Rust 的所有权系统在 FFI 边界之外不再生效。直接将 Rust 的堆内存所有权（如 String 或 Vec）传递给 C 代码，可能导致 Rust 在 C 代码仍在使用时提前释放内存，从而产生悬垂指针。

错误示例：

// 错误示例：直接传递 String
#[no_mangle]
pub extern "C" fn process_name(name: String) -> i32 {
    // C 代码无法正确处理 Rust 的 String 类型
    println!("Received: {}", name);
    0
}

正确处理方式：应使用 C 兼容的指针类型（如 *const c_char）并由调用方管理其生命周期。

use std::ffi::CStr;
use std::os::raw::c_char;

#[no_mangle]
pub extern "C" fn process_name(name_ptr: *const c_char) -> i32 {
    if name_ptr.is_null() {
        eprintln!("Error: Received null pointer.");
        return -1;
    }
    let c_str = unsafe { CStr::from_ptr(name_ptr) };
    match c_str.to_str() {
        Ok(rust_str) => {
            println!("Name: {}", rust_str);
            0 // Success
        },
        Err(_) => {
            eprintln!("Error: Invalid UTF-8 sequence.");
            -1 // Error
        }
    }
}

2. 忽略调用约定与符号导出

Rust 默认使用 rust-call 调用约定，而 C 语言通常使用 cdecl 或 stdcall。若在 FFI 接口中未显式指定，可能导致栈不平衡，进而引发崩溃。

• 为所有 FFI 函数显式声明 extern "C"。
• 在 Windows 平台上，需特别注意 stdcall 的使用场景。
• 使用 #[no_mangle] 属性防止 Rust 编译器对函数名进行名称修饰（name mangling），确保 C 代码能通过原始函数名正确链接。

3. 跨语言内存管理混乱

当 Rust 和 C 使用不同的内存分配器时，在一个语言中分配的内存，若在另一个语言中被错误地释放（或未被释放），将导致内存损坏或泄漏。以下是内存管理的常见模式：

场景	推荐做法
Rust 分配，C 使用	C 只读，不释放。Rust 提供一个单独的释放函数（如 free_my_data(ptr)）供 C 调用。
C 分配，Rust 使用	Rust 复制数据到自己的内存空间，避免跨边界释放。或 Rust 明确接管所有权（使用 Box::from_raw 等）。
共享结构体	使用 #[repr(C)] 确保 Rust 结构体与 C 结构体在内存布局上兼容。

安全传递字符串与切片

Rust 的字符串（UTF-8, null-terminated）和 C 字符串（null-terminated byte sequences）在表示方式上存在差异。传递切片也需要注意其底层指针和长度信息。

• 字符串：使用 std::ffi::CString（Rust 到 C）和 std::ffi::CStr（C 到 Rust）进行安全转换。

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

#[no_mangle]
pub extern "C" fn greet(name_ptr: *const c_char) {
    if name_ptr.is_null() { return; }
    let c_str = unsafe { CStr::from_ptr(name_ptr) };
    if let Ok(rust_name) = c_str.to_str() {
        println!("Hello, {}!", rust_name);
    }
}

// 示例：Rust 调用 C 函数，传递 CString
fn call_c_greet() {
    let rust_string = "World";
    let c_string = CString::new(rust_string).expect("CString::new failed");
    // 假设 C 函数 `c_greet` 存在
    // unsafe { c_greet(c_string.as_ptr()); }
}

• 切片：通常通过指针和长度（*const T, usize）来传递。接收方必须严格按长度访问，避免越界。

使用裸指针的注意事项

裸指针（raw pointers）绕过了 Rust 的安全检查，要求开发者手动保证内存安全。

• 确保指针指向的内存生命周期足够长。
• 在解引用前，必须检查指针是否为 null。
• 内存的分配与释放必须成对进行。

正确使用模式：

use std::ptr;

let mut value = 100;
let raw_ptr: *const i32 = &value; // 引用转换为裸指针

if !raw_ptr.is_null() {
    unsafe {
        println!("Value via raw pointer: {}", *raw_ptr);
    }
}

// 内存分配示例 (需手动管理)
let boxed_data = Box::new(vec![1, 2, 3]);
let data_ptr = Box::into_raw(boxed_data); // 转移所有权，获取裸指针

// ... 传递 data_ptr 给 C ...

// 在 Rust 中释放（如果 C 未接管）
unsafe {
    // 必须先从裸指针重建 Box 来安全释放
    let _ = Box::from_raw(data_ptr);
}

避免 Rust 释放导致 C 端悬空指针

为了避免 Rust 析构函数提前释放内存，当 C 代码需要管理内存生命周期时，可使用 Box::into_raw 将所有权转移，并提供一个 Rust 导出的释放函数。

Rust 端：

use std::os::raw::c_void;
use std::alloc::{alloc, dealloc, Layout};

#[no_mangle]
pub extern "C" fn allocate_buffer(size: usize) -> *mut c_void {
    if size == 0 { return ptr::null_mut(); }
    let layout = Layout::array::<u8>(size).unwrap();
    unsafe { alloc(layout) as *mut c_void }
}

#[no_mangle]
pub extern "C" fn free_buffer(ptr: *mut c_void, size: usize) {
    if ptr.is_null() || size == 0 { return; }
    let layout = Layout::array::<u8>(size).unwrap();
    unsafe { dealloc(ptr as *mut u8, layout); }
}

C 端（示例）：

#include <stdlib.h> // For size_t
// 声明 Rust 导出的函数
extern void* allocate_buffer(size_t size);
extern void free_buffer(void* ptr, size_t size);

void use_buffer() {
    size_t buffer_size = 1024;
    void* buffer = allocate_buffer(buffer_size);
    if (buffer != NULL) {
        // ... 使用 buffer ...
        free_buffer(buffer, buffer_size); // 必须手动释放
    }
}

跨平台 ABI 兼容性

不同操作系统和 CPU 架构具有不同的应用二进制接口 (ABI)。在进行 FFI 编程时，需要考虑数据对齐、调用约定和符号命名规则的差异。

• 使用 #[repr(C)] 确保结构体布局一致。
• 显式指定 extern "C" 和可能的调用约定。
• 在多平台项目中使用条件编译（如 #[cfg(...)]）来处理平台特定的 FFI 定义。