如何在Rust中为C绑定的链表分配内存？

你遇到的段错误核心原因是分配器不匹配：Rust的Box默认使用Rust全局分配器，而C链表节点由malloc分配，混用会导致内存释放时的非法操作。以下是几种符合Rust风格的解决方案：

方案1：自定义C兼容分配器，用Box自动管理 #

实现基于libc::malloc/libc::free的分配器，让Box使用这套分配器，确保内存分配和释放与C代码一致，同时享受Rust的RAII特性。

use std::alloc::{GlobalAlloc, Layout};
use libc::{malloc, free};

struct CAllocator;

unsafe impl GlobalAlloc for CAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        malloc(layout.size()) as *mut u8
    }

    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
        free(ptr as *mut libc::c_void);
    }
}

// 全局指定该分配器（适用于全项目需与C互操作的场景）
#[global_allocator]
static ALLOCATOR: CAllocator = CAllocator;

如果仅需局部使用，可借助Rust 1.56+的Allocator trait（需启用allocator_api不稳定特性，或使用第三方库如allocator-api2），通过Box::new_in指定分配器。

方案2：自定义RAII智能指针 #

若不想全局替换分配器，可封装一个专属智能指针，自动处理C内存的分配与释放，完全遵循Rust的RAII范式。

假设bindgen生成的C链表结构体如下：

#[repr(C)]
pub struct ListNode {
    pub data: i32,
    pub next: *mut ListNode,
}

自定义智能指针实现：

use libc::{malloc, free, c_void};
use std::ops::Deref;

struct CBox<T> {
    ptr: *mut T,
}

impl<T> CBox<T> {
    // 分配内存并初始化节点
    pub fn new(value: T) -> Self {
        unsafe {
            let ptr = malloc(std::mem::size_of::<T>()) as *mut T;
            if ptr.is_null() {
                panic!("malloc failed");
            }
            std::ptr::write(ptr, value);
            CBox { ptr }
        }
    }

    // 转换为原始指针供C代码调用
    pub fn into_raw(self) -> *mut T {
        let ptr = self.ptr;
        std::mem::forget(self);
        ptr
    }

    // 从C返回的原始指针恢复智能指针
    pub unsafe fn from_raw(ptr: *mut T) -> Self {
        CBox { ptr }
    }
}

impl<T> Deref for CBox<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        unsafe { &*self.ptr }
    }
}

impl<T> Drop for CBox<T> {
    fn drop(&mut self) {
        unsafe {
            std::ptr::drop_in_place(self.ptr);
            free(self.ptr as *mut c_void);
        }
    }
}

使用时，用CBox::new创建节点，into_raw将指针传给C链表操作函数；当CBox超出作用域时，会自动调用free释放内存，无需手动管理。

关键注意事项 #

• 确保Rust结构体标注#[repr(C)]，保证内存布局与C完全一致（bindgen生成的结构体已满足此要求）。
• 严格遵循“谁分配谁释放”原则：malloc分配的内存必须用free释放，Rust分配器分配的内存必须用Rust方式释放，禁止混用。

内容的提问来源于stack exchange，提问作者Cuci