Python ctypes与C结构体数组的UDP通信及解析教程-Python教程-PHP中文网

python ctypes与c结构体数组的udp通信及解析教程

本教程旨在详细讲解如何在Python中使用`ctypes`库接收并解析通过UDP发送的C语言嵌套结构体数组数据。我们将探讨C语言侧的数据序列化方法，以及Python侧使用`ctypes`进行复杂结构体数据反序列化的正确姿势，并提供一种更简洁的纯Python `struct` 模块实现方案，以提高数据处理效率和代码可读性。

1. 引言：C/C++与Python的数据交互挑战

在跨语言通信，特别是C/C++与Python之间进行数据交换时，经常需要处理复杂的数据结构。当这些结构体包含嵌套结构体或动态数组（通过指针表示）时，通过网络（如UDP）传输原始内存数据会遇到挑战。C语言中的指针在序列化时，其值（内存地址）本身并无意义，我们需要发送的是指针所指向的实际数据内容。本教程将以一个包含嵌套结构体数组的C结构体为例，演示如何在Python中正确接收和解析此类数据。

2. C/C++端数据序列化

原始的C代码尝试通过memcpy(&testStruct, buffer, sizeof(MyStruct))直接复制结构体内存来发送数据。然而，当结构体中包含指针（如MyInnerStruct *InnerStruct）时，memcpy只会复制指针变量本身的值（即一个内存地址），而不会复制指针所指向的实际数组内容。这导致Python端接收到的指针值是无效的，无法正确访问数组数据。

正确的C端序列化方法是，将结构体的所有基本类型字段以及指针所指向的数组元素逐一写入一个字节缓冲区。

立即学习“Python免费学习笔记（深入）”；

C/C++结构体定义：

#include <iostream>
#include <vector>
#include <cstring> // For memcpy
#include <winsock2.h> // For network operations (optional for serialization logic)

// 禁用一些警告，实际项目中应谨慎处理
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#pragma comment(lib, "Ws2_32.lib")

struct MyInnerStruct {
    int intValue;
    float floatValue;
};

struct MyStruct {
    int intValue; // This field will also serve as the count of InnerStructs
    float floatValue;
    MyInnerStruct *InnerStruct; // Pointer to an array of MyInnerStruct
};

// 辅助函数：将MyStruct及其内部数组序列化为字节向量
std::vector<char> serializeMyStruct(const MyStruct& s, int innerStructCount) {
    std::vector<char> buffer;
    // 确保使用小端序（Little-endian）以匹配Python的'<if'格式
    // 实际项目中应考虑网络字节序或明确指定字节序

    // 序列化 MyStruct 的 intValue
    buffer.insert(buffer.end(), (char*)&s.intValue, (char*)&s.intValue + sizeof(s.intValue));
    // 序列化 MyStruct 的 floatValue
    buffer.insert(buffer.end(), (char*)&s.floatValue, (char*)&s.floatValue + sizeof(s.floatValue));

    // 序列化 MyInnerStruct 数组的每个元素
    for (int i = 0; i < innerStructCount; ++i) {
        buffer.insert(buffer.end(), (char*)&s.InnerStruct[i].intValue, (char*)&s.InnerStruct[i].intValue + sizeof(s.InnerStruct[i].intValue));
        buffer.insert(buffer.end(), (char*)&s.InnerStruct[i].floatValue, (char*)&s.InnerStruct[i].floatValue + sizeof(s.InnerStruct[i].floatValue));
    }
    return buffer;
}

int main() {
    // 1. 初始化数据
    MyStruct testStruct;
    testStruct.intValue = 4; // 设定内部数组的元素数量
    testStruct.floatValue = 3.5f;

    // 分配内部结构体数组
    int innerArrayCount = testStruct.intValue;
    testStruct.InnerStruct = new MyStruct::MyInnerStruct[innerArrayCount];

    for (int i = 0; i < innerArrayCount; ++i) {
        testStruct.InnerStruct[i].intValue = i + 1;
        testStruct.InnerStruct[i].floatValue = 1.25f + i * 1.25f / 2;
    }

    // 2. 序列化数据
    std::vector<char> serialized_data = serializeMyStruct(testStruct, innerArrayCount);

    // 3. UDP发送部分 (此处仅作示例，实际需完善错误处理)
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        std::cerr << "Failed to initialize winsock." << std::endl;
        return 1;
    }

    int udpSocket = socket(AF_INET, SOCK_DGRAM, 0);
    if (udpSocket == -1) {
        perror("Error creating socket");
        WSACleanup();
        return 1;
    }

    sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(5000); // 目标端口
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // 目标IP

    if (sendto(udpSocket, serialized_data.data(), serialized_data.size(), 0,
               reinterpret_cast<sockaddr*>(&serverAddr), sizeof(serverAddr)) == -1) {
        perror("Error sending data");
        closesocket(udpSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "Struct sent successfully. Data size: " << serialized_data.size() << " bytes." << std::endl;

    // 清理
    delete[] testStruct.InnerStruct;
    closesocket(udpSocket);
    WSACleanup();
    return 0;
}

登录后复制

关键点：

serializeMyStruct函数负责将MyStruct的字段和MyInnerStruct数组的每个元素逐个复制到std::vector<char>缓冲区中。
testStruct.intValue被用作MyInnerStruct数组的元素数量，这是一种常见的将数组长度与结构体一同传输的方式。
字节序（Endianness）非常重要。C++端需要与Python端（struct.pack或struct.unpack的格式字符串）保持一致。本例中，Python使用<表示小端序，C++代码隐式地以系统默认字节序复制，因此在小端序系统上可以匹配。跨平台或不同系统间通信时，推荐使用htons/htonl等函数进行网络字节序转换。

3. Python端接收与解析（ctypes方法）

Python的ctypes库允许我们定义与C语言结构体对应的Python类，并直接操作内存。然而，对于从网络接收到的原始字节流，我们不能直接将其强制转换为包含指针的ctypes结构体。因为字节流中的“指针”不再是有效的内存地址，而是序列化时混入的数据。

ChatBA

AI幻灯片生成工具

查看详情

正确的做法是：

首先使用struct模块解析出顶层结构体的基本字段（特别是数组长度）。
根据数组长度，动态创建ctypes数组。
迭代地从字节流中解析出数组的每个元素，并填充到ctypes数组中。
将填充好的ctypes数组的引用赋值给顶层ctypes结构体中的指针字段。

Python ctypes接收端代码：

import socket
import struct
import ctypes as ct

# 定义与C语言对应的内部结构体
class MyInnerStruct(ct.Structure):
    _fields_ = (('field4', ct.c_int),
                ('field5', ct.c_float))

    def __repr__(self):  # 用于方便打印显示
        return f'({self.field4}, {self.field5})'

# 定义与C语言对应的外部结构体
class MyStruct(ct.Structure):
    _fields_ = (('field1', ct.c_int),
                ('field2', ct.c_float),
                ('field3', ct.POINTER(MyInnerStruct))) # 指向内部结构体数组的指针

    def __repr__(self):  # 用于方便打印显示
        # 访问field3时，需要确保它已被正确赋值为一个数组
        if self.field3:
            # 使用切片[:self.field1]来获取实际的数组元素，self.field1是数组长度
            return f'[{self.field1}, {self.field2}, {list(self.field3[:self.field1])}]'
        else:
            return f'[{self.field1}, {self.field2}, (null_pointer)]'

# UDP socket设置
HOST = '' # 监听所有可用接口
PORT = 5000

sock = socket.socket(type=socket.SOCK_DGRAM)
sock.bind((HOST, PORT))
print(f"Listening on UDP port {PORT}...")

try:
    while True:
        # 接收数据，假设最大数据包大小为40960字节
        data, addr = sock.recvfrom(40960)
        print(f"Received {len(data)} bytes from {addr}")

        # 1. 解包MyStruct的field1和field2
        # '<if' 表示小端序，一个int，一个float
        field1, field2 = struct.unpack_from('<if', data)

        # 创建MyStruct实例，此时field3（指针）仍为空
        received_struct = MyStruct(field1, field2)

        # 2. 根据field1（内部数组的元素数量）动态分配MyInnerStruct数组
        # MyInnerStruct * field1 创建一个包含 field1 个 MyInnerStruct 元素的数组类型
        inner_array_type = MyInnerStruct * field1
        inner_array = inner_array_type() # 实例化这个数组

        # 3. 计算内部结构体数据在缓冲区中的起始位置和每个元素的大小
        # MyStruct的前两个字段的大小
        start_of_inner = struct.calcsize('<if') 
        # MyInnerStruct 的大小
        size_of_inner_element = struct.calcsize('<if') 

        # 4. 迭代解包并填充内部数组
        current_index = start_of_inner
        for i in range(field1):
            # 从当前位置开始解包一个MyInnerStruct元素
            field4, field5 = struct.unpack_from('<if', data, current_index)
            inner_array[i] = MyInnerStruct(field4, field5) # 赋值给数组元素
            current_index += size_of_inner_element # 移动到下一个元素的位置

        # 5. 将填充好的内部数组赋值给MyStruct的field3指针
        received_struct.field3 = inner_array

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

except KeyboardInterrupt:
    print("Shutting down...")
finally:
    sock.close()

登录后复制

关键点：

struct.unpack_from('<if', data)：用于从字节流中解析出MyStruct的前两个字段（field1和field2）。'<if'指定了小端序的整数和浮点数格式。
MyInnerStruct * field1：动态创建一个包含field1个MyInnerStruct元素的ctypes数组类型。
inner_array_type()：实例化这个数组类型，得到一个实际的ctypes数组对象。
struct.calcsize('<if')：计算特定格式的字节大小，用于确定数据偏移量。
received_struct.field3 = inner_array：这是最关键的一步，将动态创建并填充好的ctypes数组赋值给MyStruct实例中的field3指针。ctypes会自动处理这种赋值，使得field3指向inner_array的内存。

4. Python端接收与解析（纯Python struct方法）

对于从网络接收的序列化数据，如果不需要将数据回传给C库或者进行内存层面的直接操作，使用纯Python类结合struct模块进行解析通常更简单、更高效，且避免了ctypes指针的复杂性。

这种方法的核心思想是：定义普通的Python类来表示C结构体，并为这些类添加from_data或from_data_array等工厂方法，负责从原始字节流中解析数据并创建Python对象。

Python struct接收端代码：

import socket
import struct

# 定义内部结构体的纯Python类
class MyInnerStruct:
    _format = '<if'  # 对应C语言中的 int 和 float，小端序
    _size = struct.calcsize(_format) # 计算每个MyInnerStruct元素的大小

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

    @classmethod
    def from_data(cls, data_buffer, offset=0):
        """从字节缓冲区中解析单个MyInnerStruct"""
        f4, f5 = struct.unpack_from(cls._format, data_buffer, offset)
        return cls(f4, f5)

    @classmethod
    def from_data_array(cls, data_buffer, count, offset=0):
        """从字节缓冲区中解析MyInnerStruct数组"""
        inner_structs = []
        current_offset = offset
        for _ in range(count):
            inner_structs.append(cls.from_data(data_buffer, current_offset))
            current_offset += cls._size
        return inner_structs

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

# 定义外部结构体的纯Python类
class MyStruct:
    _format = '<if'  # 对应C语言中的 int 和 float，小端序
    _size = struct.calcsize(_format) # 计算MyStruct前两个字段的大小

    def __init__(self, f1, f2, f3_array):
        self.field1 = f1
        self.field2 = f2
        self.field3 = f3_array # 此时field3直接是MyInnerStruct对象的列表

    @classmethod
    def from_data(cls, data_buffer):
        """从字节缓冲区中解析整个MyStruct，包括其内部数组"""
        # 首先解析MyStruct的field1和field2
        f1, f2 = struct.unpack_from(cls._format, data_buffer, 0)

        # 接着解析内部数组，从MyStruct字段之后开始
        inner_array_offset = cls._size
        f3_array = MyInnerStruct.from_data_array(data_buffer, f1, inner_array_offset)

        return cls(f1, f2, f3_array)

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

# UDP socket设置
HOST = '' # 监听所有可用接口
PORT = 5000

sock = socket.socket(type=socket.SOCK_DGRAM)
sock.bind((HOST, PORT))
print(f"Listening on UDP port {PORT}...")

try:
    while True:
        data, addr = sock.recvfrom(40960)
        print(f"Received {len(data)} bytes from {addr}")

        # 直接使用MyStruct的工厂方法从数据中

登录后复制

以上就是Python ctypes与C结构体数组的UDP通信及解析教程的详细内容，更多请关注php中文网其它相关文章！