将 C++ 字节结构转换/解析为 Go

最近发现不少小伙伴都对Golang很感兴趣，所以今天继续给大家介绍Golang相关的知识，本文《将 C++ 字节结构转换/解析为 Go》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

我正在用go读取一些数据包，其中的字段是c++数据类型。我尝试解析数据，但读取的是垃圾值。

这是一个小例子 - c++ 中特定数据类型的数据规格表如下，

struct cartelemetrydata
{
    uint16    m_speed;                      
    uint8     m_throttle;                   
    int8      m_steer;                      
    uint8     m_brake;                     
    uint8     m_clutch;                     
    int8      m_gear;                       
    uint16    m_enginerpm;                  
    uint8     m_drs;                        
    uint8     m_revlightspercent;           
    uint16    m_brakestemperature[4];       
    uint16    m_tyressurfacetemperature[4]; 
    uint16    m_tyresinnertemperature[4];   
    uint16    m_enginetemperature;          
    float     m_tyrespressure[4];           
};

下面是我在 go 中定义的内容

type cartelemetrydata struct {
    speed                   uint16
    throttle                uint8
    steer                   int8
    brake                   uint8
    clutch                  uint8
    gear                    int8
    enginerpm               uint16
    drs                     uint8
    revlightspercent        uint8
    brakestemperature       [4]uint16
    tyressurfacetemperature [4]uint16
    tyresinnertemperature   [4]uint16
    enginetemperature       uint16
    tyrespressure           [4]float32
}

对于实际的解组，我正在这样做 -

func decodePayload(dataStruct interface{}, payload []byte) {
    dataReader := bytes.NewReader(payload[:])
    binary.Read(dataReader, binary.LittleEndian, dataStruct)
}

payload := make([]byte, 2048)
s.conn.ReadFromUDP(payload[:])
telemetryData := &data.CarTelemetryData{}
s.PacketsRcvd += 1
decodePayload(telemetryData, payload)

我怀疑这是因为数据类型不相等，并且在将字节读入 go 数据类型时存在一些转换问题，而它们最初是作为 c++ 打包的。我该如何处理这个问题？

注意：我对发送的数据没有任何控制权，这是由第三方服务发送的。

正确答案

您面临的问题与结构成员的对齐有关。您可以阅读更多相关内容 here，但简而言之，c++ 编译器有时会添加填充字节，以保持架构所期望的自然对齐。如果不使用这种对齐方式，可能会导致性能下降甚至访问冲突。

例如，对于 x86/x64，大多数类型的对齐方式通常（但不一定保证）与大小相同。我们可以看到

#include 
#include 

std::size_t offsets[] = {
    std::alignment_of_v,
    std::alignment_of_v,
    std::alignment_of_v,
    std::alignment_of_v,
    std::alignment_of_v<__uint128_t>,
    std::alignment_of_v,
    std::alignment_of_v,
    std::alignment_of_v,
    std::alignment_of_v,
    std::alignment_of_v<__int128_t>,
    std::alignment_of_v,
    std::alignment_of_v,
    std::alignment_of_v,
    std::alignment_of_v,
};

编译为

offsets:
        .quad   1
        .quad   2
        .quad   4
        .quad   8
        .quad   16
        .quad   1
        .quad   2
        .quad   4
        .quad   8
        .quad   16
        .quad   4
        .quad   8
        .quad   16
        .quad   8

由于这些（和其他）实现细节，建议不要依赖内部表示。然而，在某些情况下，其他方法可能不够快（例如逐个字段序列化），或者您可能无法更改 c++ 代码，例如 op。

binary.Read 需要打包数据，但 c++ 将使用填充。我们需要使用依赖于编译器的指令，例如 #pragma pack(1) 或添加填充 go 结构。第一个选项不适用于 op，因此我们将使用第二个。

我们可以使用 offsetof 宏来确定结构体成员相对于结构体本身的偏移量。我们可以做类似的事情

#include 
#include 
#include 

using int8 = std::int8_t;
using uint8 = std::uint8_t;
using uint16 = std::uint16_t;

struct cartelemetrydata {
    uint16 m_speed;
    uint8 m_throttle;
    int8 m_steer;
    uint8 m_brake;
    uint8 m_clutch;
    int8 m_gear;
    uint16 m_enginerpm;
    uint8 m_drs;
    uint8 m_revlightspercent;
    uint16 m_brakestemperature[4];
    uint16 m_tyressurfacetemperature[4];
    uint16 m_tyresinnertemperature[4];
    uint16 m_enginetemperature;
    float m_tyrespressure[4];
};

// c++ has no reflection (yet) so we need to list every member
constexpr auto offsets = std::array{
    offsetof(cartelemetrydata, m_speed),
    offsetof(cartelemetrydata, m_throttle),
    offsetof(cartelemetrydata, m_steer),
    offsetof(cartelemetrydata, m_brake),
    offsetof(cartelemetrydata, m_clutch),
    offsetof(cartelemetrydata, m_gear),
    offsetof(cartelemetrydata, m_enginerpm),
    offsetof(cartelemetrydata, m_drs),
    offsetof(cartelemetrydata, m_revlightspercent),
    offsetof(cartelemetrydata, m_brakestemperature),
    offsetof(cartelemetrydata, m_tyressurfacetemperature),
    offsetof(cartelemetrydata, m_tyresinnertemperature),
    offsetof(cartelemetrydata, m_enginetemperature),
    offsetof(cartelemetrydata, m_tyrespressure),
};

constexpr auto sizes = std::array{
    sizeof(cartelemetrydata::m_speed),
    sizeof(cartelemetrydata::m_throttle),
    sizeof(cartelemetrydata::m_steer),
    sizeof(cartelemetrydata::m_brake),
    sizeof(cartelemetrydata::m_clutch),
    sizeof(cartelemetrydata::m_gear),
    sizeof(cartelemetrydata::m_enginerpm),
    sizeof(cartelemetrydata::m_drs),
    sizeof(cartelemetrydata::m_revlightspercent),
    sizeof(cartelemetrydata::m_brakestemperature),
    sizeof(cartelemetrydata::m_tyressurfacetemperature),
    sizeof(cartelemetrydata::m_tyresinnertemperature),
    sizeof(cartelemetrydata::m_enginetemperature),
    sizeof(cartelemetrydata::m_tyrespressure),
};

constexpr auto computepadding() {
    std::array result;

    std::size_t expectedoffset = 0;

    for (std::size_t i = 0; i < offsets.size(); i++) {
        result.at(i) = offsets.at(i) - expectedoffset;
        expectedoffset = offsets.at(i) + sizes.at(i);
    }

    return result;
}

auto padding = computepadding();

编译为 (constexpr ftw)

padding:
        .quad   0
        .quad   0
        .quad   0
        .quad   0
        .quad   0
        .quad   0
        .quad   1
        .quad   0
        .quad   0
        .quad   0
        .quad   0
        .quad   0
        .quad   0
        .quad   2

因此，在 x86 上，我们需要在 enginerpm 之前有一个字节，在 tyrespressure 之前需要两个字节。

所以，let's check if that works。

c++：

#include 
#include 
#include 
#include 
#include 

using int8 = std::int8_t;
using uint8 = std::uint8_t;
using uint16 = std::uint16_t;

struct cartelemetrydata {
    uint16 m_speed;
    uint8 m_throttle;
    int8 m_steer;
    uint8 m_brake;
    uint8 m_clutch;
    int8 m_gear;
    uint16 m_enginerpm;
    uint8 m_drs;
    uint8 m_revlightspercent;
    uint16 m_brakestemperature[4];
    uint16 m_tyressurfacetemperature[4];
    uint16 m_tyresinnertemperature[4];
    uint16 m_enginetemperature;
    float m_tyrespressure[4];
};

int main() {
    cartelemetrydata data = {
        .m_speed = 1,
        .m_throttle = 2,
        .m_steer = 3,
        .m_brake = 4,
        .m_clutch = 5,
        .m_gear = 6,
        .m_enginerpm = 7,
        .m_drs = 8,
        .m_revlightspercent = 9,
        .m_brakestemperature = {10, 11, 12, 13},
        .m_tyressurfacetemperature = {14, 15, 16, 17},
        .m_tyresinnertemperature = {18, 19, 20, 21},
        .m_enginetemperature = 22,
        .m_tyrespressure = {23, 24, 25, 26},
    };

    std::cout << "b := []byte{" << std::hex << std::setfill('0');

    for (auto byte : std::as_bytes(std::span(&data, 1))) {
        std::cout << "0x" << std::setw(2) << static_cast(byte)
                  << ", ";
    }

    std::cout << "}";
}

结果

b := []byte{0x01, 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x07, 0x00, 0x08, 0x09, 0x0a, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x0d, 0x00, 0x0e, 0x00, 0x0f, 0x00, 0x10, 0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x41, 0x00, 0x00, 0xc0, 0x41, 0x00, 0x00, 0xc8, 0x41, 0x00, 0x00, 0xd0, 0x41, }

让我们在 go 中使用它：

// type your code here, or load an example.
// your function name should start with a capital letter.
package main

import (
    "bytes"
    "encoding/binary"
    "fmt"
)

type cartelemetrydata struct {
    speed                   uint16
    throttle                uint8
    steer                   int8
    brake                   uint8
    clutch                  uint8
    gear                    int8
    _                       uint8
    enginerpm               uint16
    drs                     uint8
    revlightspercent        uint8
    brakestemperature       [4]uint16
    tyressurfacetemperature [4]uint16
    tyresinnertemperature   [4]uint16
    enginetemperature       uint16
    _                       uint16
    tyrespressure           [4]float32
}

func main() {
    b := []byte{0x01, 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x07, 0x00, 0x08, 0x09, 0x0a, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x0d, 0x00, 0x0e, 0x00, 0x0f, 0x00, 0x10, 0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x41, 0x00, 0x00, 0xc0, 0x41, 0x00, 0x00, 0xc8, 0x41, 0x00, 0x00, 0xd0, 0x41}

    var datastruct cartelemetrydata

    datareader := bytes.newreader(b[:])
    binary.read(datareader, binary.littleendian, &datastruct)

    fmt.printf("%+v", datastruct)
}

打印内容

{Speed:1 Throttle:2 Steer:3 Brake:4 Clutch:5 Gear:6 _:0 EngineRPM:7 DRS:8 RevLightsPercent:9 BrakesTemperature:[10 11 12 13] TyresSurfaceTemperature:[14 15 16 17] TyresInnerTemperature:[18 19 20 21] EngineTemperature:22 _:0 TyresPressure:[23 24 25 26]}

取出填充字节，结果失败。

好了，本文到此结束，带大家了解了《将 C++ 字节结构转换/解析为 Go》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！