如何使用Python解析UDP传输的C语言嵌套结构体数组

import struct
import socket

# 模拟C端发送的数据：
# field1=4 (int), field2=3.5 (float)
# 接着是4个MyInnerStruct元素：
# (1, 1.25), (2, 2.5), (3, 2.75), (4, 3.00)
# '<if' 表示小端序，int和float
data = struct.pack('<ififififif', 4, 3.5, 1, 1.25, 2, 2.5, 3, 2.75, 4, 3.00)

# 模拟发送到UDP端口
with socket.socket(type=socket.SOCK_DGRAM) as s:
    s.sendto(data, ('localhost', 5000))
    print("模拟数据已发送。")

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))) # 注意这里是POINTER

    def __repr__(self):
        # 访问field3时，需要确保它已被正确赋值为一个ctypes数组
        # 否则尝试list(self.field3[:self.field1])可能会失败
        inner_data = []
        if self.field3: # 检查指针是否有效
            for i in range(self.field1):
                inner_data.append(self.field3[i])
        return f'MyStruct(field1={self.field1}, field2={self.field2}, field3={inner_data})'

# UDP接收设置
sock = socket.socket(type=socket.SOCK_DGRAM)
sock.bind(('', 5000))
print("等待接收UDP数据...")

# 接收数据
data, addr = sock.recvfrom(40960) # 接收足够大的缓冲区

# 1. 解析主结构体的标量字段
# '<if' 表示小端序，一个int和一个float
field1, field2 = struct.unpack_from('<if', data)

# 2. 初始化MyStruct，此时field3（指针）尚未指向有效数据
received_struct = MyStruct(field1=field1, field2=field2)

# 3. 根据field1的值（数组长度），动态分配一个MyInnerStruct的ctypes数组
inner_array_type = MyInnerStruct * field1
inner_array = inner_array_type()

# 4. 计算内部数组数据在接收缓冲区中的起始位置和每个元素的大小
start_of_inner_data = struct.calcsize('<if') # 主结构体标量字段的大小
size_of_inner_element = struct.calcsize('<if') # MyInnerStruct元素的大小

# 5. 循环解析字节流中的内部结构体元素，并填充到动态数组中
current_index = start_of_inner_data
for i in range(field1):
    # 从当前位置开始解析一个MyInnerStruct元素
    field4, field5 = struct.unpack_from('<if', data[current_index:])
    inner_array[i] = MyInnerStruct(field4=field4, field5=field5)
    current_index += size_of_inner_element

# 6. 将动态分配并填充好的ctypes数组赋值给主结构体的指针字段
received_struct.field3 = inner_array

# 打印完整的接收结果
print("接收到的结构体:", received_struct)

sock.close()

import socket
import struct

# 定义纯Python的内部结构体类
class MyInnerStruct:
    _format = '<if'  # 定义其序列化格式 (int, float)
    _size = struct.calcsize(_format) # 计算序列化后的大小

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

    @classmethod
    def from_data(cls, data_buffer):
        """从字节缓冲区解析单个MyInnerStruct实例。"""
        # 使用unpack_from从缓冲区的开头解析
        return cls(*struct.unpack_from(cls._format, data_buffer))

    @classmethod
    def from_data_array(cls, data_buffer, count):
        """从字节缓冲区解析MyInnerStruct实例数组。"""
        inner_structs = []
        for n in range(count):
            # 每次从缓冲区中提取一个MyInnerStruct大小的切片进行解析
            start = n * cls._size
            end = (n + 1) * cls._size
            inner_structs.append(cls(*struct.unpack_from(cls._format, data_buffer[start:end])))
        return inner_structs

    def __repr__(self):
        return f'MyInnerStruct(field4={self.field4}, field5={self.field5})'

# 定义纯Python的主结构体类
class MyStruct:
    _format = '<if'  # 定义其序列化格式 (int, float)
    _size = struct.calcsize(_format) # 计算序列化后的大小

    def __init__(self, field1, field2, field3_array=None):
        self.field1 = field1
        self.field2 = field2
        self.field3 = field3_array if field3_array is not None else []

    @classmethod
    def from_data(cls, data_buffer):
        """从字节缓冲区解析MyStruct实例及其内部数组。"""
        # 1. 解析主结构体的标量字段
        field1, field2 = struct.unpack_from(cls._format, data_buffer)

        # 2. 解析内部数组（从主结构体字段之后开始）
        # data_buffer[cls._size:] 表示跳过主结构体字段，直接处理内部数组数据
        field3_array = MyInnerStruct.from_data_array(data_buffer[cls._size:], field1)

        # 3. 构建并返回MyStruct实例
        return cls(field1, field2, field3_array)

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

# UDP接收设置 (与ctypes示例相同)
sock = socket.socket(type=socket.SOCK_DGRAM)
sock.bind(('', 5000))
print("等待接收UDP数据...")

# 接收数据
data, addr = sock.recvfrom(40960)

# 使用MyStruct的类方法直接从接收到的数据中构建对象
received_struct = MyStruct.from_data(data)
print("接收到的结构体:", received_struct)

sock.close()