CFFI处理嵌套结构与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; // 指向下一个结构体的void指针
} buffer_t;

typedef struct buffer_next {
    char* name;
    state_t state;
    void* next; // 指向下一个结构体的void指针
} buffer_next_t;

typedef struct buffer_next_next {
    char* name;
    state_t state;
    void* next; // 最终层，可指向NULL或特定数据
} buffer_next_next_t;

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

#include <stdio.h> // for printf

// ... (typedefs from test.h) ...

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; // 最后一层，此处示例设为NULL

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

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

    // 在C函数内部调用accessBuffer是安全的，因为bufferN和bufferNN仍在作用域内
    // accessBuffer(buffer); 
    // 此处注释掉，因为我们主要关注Python调用后的行为

    return buffer; // 返回buffer_t的副本
}

int accessBuffer(buffer_t buffer){
    // 将void*指针强制转换为具体类型并访问
    buffer_next_t *buffer_next = (buffer_next_t*)buffer.next;

    // 检查指针有效性以避免空指针解引用
    if (!buffer_next) {
        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) {
        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预处理头文件以获取cdef所需的完整定义
ffi.cdef(subprocess.Popen([
    'cc', '-E',
    header], stdout=subprocess.PIPE).communicate()[0].decode('UTF-8'))
lib = ffi.dlopen(os.path.join(here, 'test.so'))

value = lib.createBuffer() # 从C获取buffer_t
print(value)
lib.accessBuffer(value)    # 将其传回C

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预处理头文件以获取cdef所需的完整定义
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. 在Python中为字符串分配C内存
# ffi.new("char[SIZE]", b"string") 用于创建C字符串，确保其在C堆上
char_name_nn = ffi.new("char[20]", b"buffer_next_next")
char_name_n = ffi.new("char[20]", b"buffer_next")
char_name = ffi.new("char[20]", b"buffer")

# 2. 在Python中为嵌套结构体分配C内存
# ffi.new("TYPE *") 会在C堆上分配一个TYPE类型的实例，并返回一个指向它的cdata指针
bufferNN_py = ffi.new("buffer_next_next_t *")
bufferNN_py.name = char_name_nn
bufferNN_py.state = 3
bufferNN_py.next = ffi.NULL # 最后一层指针设为NULL

bufferN_py = ffi.new("buffer_next_t *")
bufferN_py.name = char_name_n
bufferN_py.state = 2
bufferN_py.next = bufferNN_py # 将上一层结构体的指针赋给当前层的next

buffer_py = ffi.new("buffer_t *")
buffer_py.name = char_name
buffer_py.state = 1
buffer_py.next = bufferN_py # 将上一层结构体的指针赋给当前层的next

# 3. 调用C函数
# 注意：如果C函数期望接收一个结构体实例（by value），
# 需要使用指针解引用 buffer_py[0] 将cdata指针转换为cdata结构体实例
# 如果C函数期望接收结构体指针，则直接传递 buffer_py
lib.accessBuffer(buffer_py[0]) 

# 原始问题中尝试从C创建并返回buffer_t，这里保留其调用以对比
# value_from_c = lib.createBuffer()
# print(value_from_c)
# lib.accessBuffer(value_from_c) # 再次调用此处仍会失败，因为value_from_c内部指针无效

gcc -shared -fPIC test.c -o test.so

buffer, buffer_next, buffer_next_next