使用 CFFI 处理复杂 C 结构体与 void* 指针的内存管理指南

typedef enum State {
    state_1 = 0,
    state_2,
    state_3,
    state_4
} state_t;

typedef struct buffer {
    char* name;
    state_t state;
    void* next;
} buffer_t;

typedef struct buffer_next {
    char* name;
    state_t state;
    void* next;
} buffer_next_t;

typedef struct buffer_next_next {
    char* name;
    state_t state;
    void* next;
} buffer_next_next_t;

extern buffer_t createBuffer();
extern int accessBuffer(buffer_t buffer);

#include <stdio.h> // For printf

buffer_t createBuffer(){
    buffer_next_next_t bufferNN; // 栈上分配
    buffer_next_t bufferN;       // 栈上分配
    buffer_t buffer;             // 栈上分配

    bufferNN.name = "buffer_next_next";
    bufferNN.state = 3;
    bufferNN.next = NULL; // 确保最内层指针初始化

    bufferN.name = "buffer_next";
    bufferN.state = 2;
    bufferN.next = &bufferNN; // 指向栈上变量

    buffer.name = "buffer";
    buffer.state = 1;
    buffer.next = &bufferN; // 指向栈上变量

    // 在 C 内部调用，此时栈变量仍然有效
    // accessBuffer(buffer); 
    // 此行注释掉，模拟将buffer返回给Python再调用

    return buffer; // 返回的是栈上变量的副本，其内部指针仍指向栈内存
}

int accessBuffer(buffer_t buffer){
    // 类型转换并访问嵌套结构体
    buffer_next_t *buffer_next = (buffer_next_t*)buffer.next;

    // 检查指针是否有效，避免解引用空指针
    if (buffer_next == NULL) {
        fprintf(stderr, "Error: buffer_next is NULL\n");
        return -1;
    }
    buffer_next_next_t *buffer_next_next = (buffer_next_next_t*)buffer_next->next;

    if (buffer_next_next == NULL) {
        fprintf(stderr, "Error: buffer_next_next is NULL\n");
        return -1;
    }

    printf("%s, %s, %s\n", buffer.name, buffer_next->name, buffer_next_next->name);

    return 0;
}

import os
import subprocess
from cffi import FFI

ffi = FFI()

here = os.path.abspath(os.path.dirname(__file__))
header = os.path.join(here, 'test.h')

# 使用 cc -E 预处理头文件以获取完整的 C 定义
ffi.cdef(subprocess.Popen([
    'cc', '-E',
    header], stdout=subprocess.PIPE).communicate()[0].decode('UTF-8'))
lib = ffi.dlopen(os.path.join(here, 'test.so'))

# 在 C 中创建 buffer
value = lib.createBuffer()
print(value)

# 将从 C 返回的 buffer 传回 C 函数
# 此时，value 内部的 next 指针指向的 C 栈内存已失效
lib.accessBuffer(value) 

import os
import subprocess
from cffi import FFI

ffi = FFI()

here = os.path.abspath(os.path.dirname(__file__))
header = os.path.join(here, 'test.h')

ffi.cdef(subprocess.Popen([
    'cc', '-E',
    header], stdout=subprocess.PIPE).communicate()[0].decode('UTF-8'))
lib = ffi.dlopen(os.path.join(here, 'test.so'))

# 1. 为字符串分配内存，并用 bytes 初始化
# 这些 char 数组的生命周期由 Python 管理
char_buffer_nn = ffi.new("char[20]", b"buffer_next_next")
char_buffer_n = ffi.new("char[20]", b"buffer_next")
char_buffer = ffi.new("char[20]", b"buffer")

# 2. 从最内层开始，使用 ffi.new() 分配结构体及其指针
# 注意：分配的是指针类型 (e.g., "buffer_next_next_t *")
# 这样 CFFI 会在堆上分配实际的结构体，并返回其指针
bufferNN_py = ffi.new("buffer_next_next_t *")
bufferNN_py.name = char_buffer_nn # 赋值 char*
bufferNN_py.state = 3
bufferNN_py.next = ffi.NULL # 最内层结构体的 next 设为 NULL

bufferN_py = ffi.new("buffer_next_t *")
bufferN_py.name = char_buffer_n
bufferN_py.state = 2
bufferN_py.next = bufferNN_py # 链接到 bufferNN_py (类型匹配，CFFI自动处理 void*)

buffer_py = ffi.new("buffer_t *")
buffer_py.name = char_buffer
buffer_py.state = 1
buffer_py.next = bufferN_py # 链接到 bufferN_py

# 此时，我们已经完全在 Python 中构建了整个嵌套结构体链
# 并且这些结构体的内存由 CFFI 管理，生命周期与 Python 变量同步

# 可以选择调用 C 的 createBuffer，但它返回的结构体内部指针仍是无效的
# value_from_c = lib.createBuffer() 
# lib.accessBuffer(value_from_c) # 仍然可能导致段错误

# 将 Python 中创建的有效结构体传递给 C 函数
# 注意：lib.accessBuffer 接收的是 buffer_t 类型，而不是 buffer_t *
# 所以需要解引用 buffer_py[0]
lib.accessBuffer(buffer_py[0])

buffer, buffer_next, buffer_next_next