Python解析C/C++嵌套结构体数组方法

“纵有疾风来，人生不言弃”，这句话送给正在学习文章的朋友们，也希望在阅读本文《Python解析C/C++嵌套结构体数组技巧》后，能够真的帮助到大家。我也会在后续的文章中，陆续更新文章相关的技术文章，有好的建议欢迎大家在评论留言，非常感谢！

本教程详细介绍了Python解析从C/C++通过网络传输的嵌套结构体数据的方法，尤其针对包含数组指针的复杂场景。文章提供了两种策略：利用ctypes模块精确映射C结构体并手动处理指针和数组；或采用纯Python的struct模块进行高效数据解包并构建Python对象。通过示例，读者将掌握C数据序列化与Python反序列化的关键技术，应对跨语言数据通信挑战。

在跨语言通信（如C/C++与Python之间）中，通过网络传输复杂数据结构是一个常见需求。当C/C++结构体包含指向数组的指针时，直接传输内存中的结构体数据并不能正确地将数组内容一并发送。本文将深入探讨如何正确地序列化C/C++中包含嵌套结构体数组的数据，并在Python端使用ctypes或struct模块进行有效的反序列化。

C/C++数据结构与网络传输的挑战

C/C++中的结构体在内存中是连续存储的，但当结构体成员是指针时，它存储的仅仅是另一个内存地址，而不是实际的数据内容。例如，一个struct MyStruct中包含MyInnerStruct *InnerStruct;，如果InnerStruct指向一个数组，那么sizeof(MyStruct)只包含指针本身的大小，而不包括InnerStruct所指向的数组数据。

原始的C++发送代码中：

// 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) { ... }

这种做法的问题在于，它只复制了testStruct自身（包括InnerStruct指针的值，即一个内存地址），而没有复制InnerStruct指向的MyInnerStruct数组的实际内容。在接收端，这个指针地址在Python进程中是无效的，因此无法直接通过ctypes解引用获取数组数据。

正确的序列化策略是，在发送端，需要将主结构体的固定大小字段和其指向的数组元素数据分别或按序组合成一个连续的字节流进行发送。例如，先发送MyStruct的intValue和floatValue，然后紧接着发送MyInnerStruct数组中的每一个元素。

为了演示正确的发送方式，我们可以使用Python的struct模块模拟一个符合这种序列化规则的数据包：

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))

上述代码构造了一个字节流，其中包含了主结构体的两个字段，以及其后紧跟着的四个内部结构体实例的数据。

方法一：利用 ctypes 精确映射与解析

ctypes模块允许Python代码与C库进行交互，并能够精确地映射C语言的数据结构。然而，处理C结构体中的指针（特别是指向数组的指针）需要更细致的操作。

Python ctypes 结构体定义

首先，在Python中定义与C结构体对应的ctypes.Structure：

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])})]'

这里MyStruct的field3被定义为ct.POINTER(MyInnerStruct)，表示它是一个指向MyInnerStruct的指针。

接收与解包策略

由于网络传输的字节流是扁平的，Python端需要手动解析这个字节流，将数据填充到ctypes结构体中。核心步骤包括：

1. 接收数据：通过UDP套接字接收完整的字节流。
2. 解包主结构体字段：使用struct.unpack_from解包字节流开头的field1和field2。
3. 初始化主结构体：使用解包出的field1和field2初始化MyStruct实例。此时field3（指针）仍为空或无效。
4. 动态分配内部结构体数组：根据field1的值（表示数组长度），动态创建一个MyInnerStruct类型的ctypes数组。
5. 循环解包并填充数组：从字节流中field1和field2之后的位置开始，循环解包每个MyInnerStruct的字段，并将其赋值给动态创建的ctypes数组的对应元素。
6. 关联指针：将动态创建的ctypes数组赋值给MyStruct实例的field3指针。

示例代码 (Python 接收端)

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)])]

注意事项

• 内存管理：ctypes在Python中创建的C类型对象由Python垃圾回收机制管理，但在某些复杂场景下仍需注意生命周期。
• 数据对齐与字节序：确保C/C++发送端和Python接收端的结构体定义、数据对齐方式（_pack_属性）和字节序（如<表示小端序）一致。
• 指针有效性：在网络传输中，指针地址本身是无意义的。必须传输指针所指向的实际数据，并在接收端重新构建数据结构。

方法二：纯 Python struct 模块解析（推荐）

对于许多跨语言数据交换场景，特别是当不需要直接调用C库函数时，放弃ctypes而直接使用Python的struct模块来解析字节流，并构建纯Python对象，会更加简洁、高效且易于维护。这种方法避免了ctypes在Python对象和C类型之间进行映射的开销和复杂性。

优势与适用场景

• 简洁性：无需定义ctypes.Structure，直接使用struct进行解包。
• 效率：避免了ctypes的类型转换开销。
• 灵活性：更容易将解析后的数据转换为标准的Python数据类型（如列表、字典），方便后续处理。
• 适用场景：主要用于数据序列化和反序列化，不涉及直接调用C库函数。

Python类设计与数据解析逻辑

我们可以定义纯Python类来表示C结构体，并在这些类中实现从字节流解析数据的方法。

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}]'

示例代码 (Python 接收端)

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()

运行上述接收代码，然后运行之前模拟的发送代码，将得到与ctypes方案相同的输出：

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

比较与选择

• ctypes：
  • 优点：能够精确映射C

终于介绍完啦！小伙伴们，这篇关于《Python解析C/C++嵌套结构体数组方法》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识，快来关注吧！