CFFI ABI模式下复杂结构体与void*嵌套指针的内存管理

// test.h
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 int accessBuffer(buffer_t buffer);

// test.c (用于演示问题的C代码片段)
#include <stdio.h>
#include "test.h"

// 这是一个用于演示问题的函数，其返回的指针会失效
buffer_t createBuffer(){
    // 这些结构体在栈上分配
    buffer_next_next_t bufferNN;
    buffer_next_t bufferN;
    buffer_t buffer;

    bufferNN.name = "buffer_next_next";
    bufferNN.state = state_3;

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

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

    // 在C函数内部访问是安全的
    // accessBuffer(buffer); 

    return buffer; // 返回的buffer_t中的next指针已失效
}

// 实际用于访问数据的C函数
int accessBuffer(buffer_t buffer){
    buffer_next_t *buffer_next = (buffer_next_t*)buffer.next;

    // 增加空指针检查，提高健壮性
    if (!buffer_next) {
        fprintf(stderr, "Error: buffer.next is NULL or invalid.\n");
        return -1;
    }
    buffer_next_next_t *buffer_next_next = (buffer_next_next_t*)buffer_next->next;

    if (!buffer_next_next) {
        fprintf(stderr, "Error: buffer_next->next is NULL or invalid.\n");
        return -1;
    }

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

    return 0;
}

# test.py
import os
import subprocess
from cffi import FFI

# 1. 初始化CFFI
ffi = FFI()

# 获取当前脚本所在目录
here = os.path.abspath(os.path.dirname(__file__))
header = os.path.join(here, 'test.h')

# 2. 解析C头文件定义
# 使用cc -E预处理头文件，以处理宏定义等
ffi.cdef(subprocess.Popen([
    'cc', '-E',
    header], stdout=subprocess.PIPE).communicate()[0].decode('UTF-8'))

# 3. 加载C共享库
# 确保test.c已经被编译为test.so (例如: gcc -shared -o test.so test.c)
lib = ffi.dlopen(os.path.join(here, 'test.so'))

# --- 在Python中创建并管理嵌套结构体 ---

# 4. 分配字符串内存
# 使用ffi.new("char[SIZE]", b"string")分配固定大小的字符数组
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")

# 5. 分配并初始化最内层结构体 (buffer_next_next_t)
# 注意使用 "buffer_next_next_t *" 来分配指针，确保堆内存
bufferNN_py = ffi.new("buffer_next_next_t *")
bufferNN_py.name = char_buffer_nn
bufferNN_py.state = lib.state_3 # 使用CFFI定义的枚举值

# 6. 分配并初始化中间层结构体 (buffer_next_t)
bufferN_py = ffi.new("buffer_next_t *")
bufferN_py.name = char_buffer_n
bufferN_py.state = lib.state_2
bufferN_py.next = bufferNN_py # 将内层结构体指针赋值给next

# 7. 分配并初始化最外层结构体 (buffer_t)
buffer_py = ffi.new("buffer_t *")
buffer_py.name = char_buffer
buffer_py.state = lib.state_1
buffer_py.next = bufferN_py # 将中间层结构体指针赋值给next

# 8. 调用C函数 accessBuffer，并传递Python中创建的结构体
# 注意：C函数accessBuffer期望的是 buffer_t 类型，
# 而我们创建的是 buffer_t *。所以需要解引用 buffer_py[0]
print("Calling accessBuffer with Python-managed data:")
lib.accessBuffer(buffer_py[0])

# 9. (可选) 如果C代码中存在 createBuffer 函数，可以尝试调用，
# 但要明确其返回的结构体中的指针是无效的。
# value_from_c = lib.createBuffer()
# print(f"Received from C's createBuffer: {value_from_c}")
# print("Attempting to access data from C-created buffer (expected failure if pointers are stack-allocated):")
# try:
#     lib.accessBuffer(value_from_c)
# except Exception as e:
#     print(f"Caught expected error: {e}")

Calling accessBuffer with Python-managed data:
buffer, buffer_next, buffer_next_next