Python中解析C/C++嵌套结构体数组：ctypes与struct模块实践

// Serialize the struct into a byte stream
char buffer[sizeof(MyStruct)];
memcpy(buffer, &testStruct, sizeof(MyStruct));
// Send the serialized struct over the UDP socket
if (sendto(udpSocket, buffer, sizeof(MyStruct), ...) == -1) { ... }

import struct
import socket

# 模拟发送数据：
# field1=4 (int), field2=3.5 (float)
# 接着是4个MyInnerStruct元素，每个包含一个int和一个float
data = struct.pack('<ififififif', 4, 3.5, 1, 1.25, 2, 2.5, 3, 2.75, 4, 3.00)

with socket.socket(type=socket.SOCK_DGRAM) as s:
    s.sendto(data, ('localhost', 5000))

import ctypes as ct

class MyInnerStruct(ct.Structure):
    _fields_ = (('field4', ct.c_int),
                ('field5', ct.c_float))
    def __repr__(self):  # 用于方便显示
        return f'({self.field4}, {self.field5})'

class MyStruct(ct.Structure):
    _fields_ = (('field1', ct.c_int),
                ('field2', ct.c_float),
                ('field3', ct.POINTER(MyInnerStruct))) # 注意这里是POINTER
    def __repr__(self):  # 用于方便显示
        # field3 是一个指针，需要切片才能作为数组访问
        return f'[{self.field1}, {self.field2}, {list(self.field3[:self.field1])})]'

import socket
import struct
import ctypes as ct

class MyInnerStruct(ct.Structure):
    _fields_ = (('field4', ct.c_int),
                ('field5', ct.c_float))
    def __repr__(self):
        return f'({self.field4}, {self.field5})'

class MyStruct(ct.Structure):
    _fields_ = (('field1', ct.c_int),
                ('field2', ct.c_float),
                ('field3', ct.POINTER(MyInnerStruct)))
    def __repr__(self):
        return f'[{self.field1}, {self.field2}, {list(self.field3[:self.field1])})]'

sock = socket.socket(type=socket.SOCK_DGRAM)
sock.bind(('', 5000)) # 绑定到本地所有接口的5000端口

print("等待接收数据...")
data, addr = sock.recvfrom(40960) # 接收数据，缓冲区大小足够大

# 1. 解包主结构体的前两个字段
field1, field2 = struct.unpack_from('<if', data)

# 2. 初始化MyStruct实例，此时field3指针为空
received_struct = MyStruct(field1, field2)

# 3. 动态分配内部结构体数组
inner_array = (MyInnerStruct * field1)() # 创建一个MyInnerStruct类型的数组，长度为field1

# 4. 计算内部结构体数据在字节流中的起始位置和大小
start_of_inner = struct.calcsize('if') # 主结构体前两个字段的大小
size_of_inner_element = struct.calcsize('if') # 单个MyInnerStruct元素的大小

# 5. 循环解包并填充数组
index = start_of_inner
for i in range(field1):
    # 从当前索引位置解包一个MyInnerStruct的字段
    field4, field5 = struct.unpack_from('<if', data[index:])
    inner_array[i] = MyInnerStruct(field4, field5) # 赋值给数组元素
    index += size_of_inner_element # 移动到下一个元素的起始位置

# 6. 关联指针：将填充好的数组赋值给MyStruct的field3指针
received_struct.field3 = inner_array

print("接收到的结构体:", received_struct)
sock.close()

等待接收数据...
接收到的结构体: [4, 3.5, [(1, 1.25), (2, 2.5), (3, 2.75), (4, 3.0)])]

import socket
import struct

class MyInnerStruct:
    _format = '<if'  # 内部结构体的格式字符串：int, float
    _size = struct.calcsize(_format) # 计算内部结构体序列化后的大小

    def __init__(self, f4, f5):
        self.field4 = f4
        self.field5 = f5

    @classmethod
    def from_data(cls, data):
        """从字节数据中解析单个MyInnerStruct实例"""
        return cls(*struct.unpack_from(cls._format, data))

    @classmethod
    def from_data_array(cls, data, count, offset=0):
        """从字节数据中解析MyInnerStruct数组"""
        inner_structs = []
        current_offset = offset
        for _ in range(count):
            # 每次从当前偏移量开始解包一个MyInnerStruct
            inner_structs.append(cls(*struct.unpack_from(cls._format, data, current_offset)))
            current_offset += cls._size
        return inner_structs

    def __repr__(self):
        return f'[{self.field4}, {self.field5}]'

class MyStruct:
    _format = '<if'  # 主结构体的格式字符串：int, float
    _size = struct.calcsize(_format) # 计算主结构体序列化后的大小

    def __init__(self, f1, f2, inner_struct_array):
        self.field1 = f1
        self.field2 = f2
        self.field3 = inner_struct_array # field3直接存储Python对象数组

    @classmethod
    def from_data(cls, data):
        """从完整的字节数据中解析MyStruct实例及其内部数组"""
        # 先解包主结构体的字段
        field1, field2 = struct.unpack_from(cls._format, data)
        # 然后从主结构体数据之后的位置开始解析内部结构体数组
        inner_struct_array = MyInnerStruct.from_data_array(data, field1, offset=cls._size)
        return cls(field1, field2, inner_struct_array)

    def __repr__(self):
        return f'[{self.field1}, {self.field2}, {self.field3}]'

import socket
import struct

# MyInnerStruct 和 MyStruct 的类定义同上

sock = socket.socket(type=socket.SOCK_DGRAM)
sock.bind(('', 5000))

print("等待接收数据...")
data, addr = sock.recvfrom(40960)

# 直接调用MyStruct的from_data类方法来解析整个数据包
received_struct = MyStruct.from_data(data)
print("接收到的结构体:", received_struct)

sock.close()

等待接收数据...
接收到的结构体: [4, 3.5, [[1, 1.25], [2, 2.5], [3, 2.75], [4, 3.0]]]