含位域结构体的序列化与反序列化​

原创 已于 2026-03-30 17:10:07 修改 · 395 阅读 · 15 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
于 2026-03-27 15:26:19 首次发布

需求背景

CPU 与智能网卡（DPU）交互时，需要把表项数据按协议序列化成字节流。由于 DPU 按 bit 粒度解析数据，协议对布局通常有明确约束。

  • 传输的数据必须是字节流
  • DPU 逐 bit 读取，字段需要紧密排列
  • 协议规定比特位按从高到低（MSB-first）排列

说明：CPU 主机序为小端序。但这里的协议是按 bit 流（MSB-first）定义的，不等价于“把结构体内存布局直接拷贝出去”。

带位域结构体的序列化

手动序列化：先推导出标准答案

先用一个最小例子把协议格式算清楚，后面所有实现都以这份“标准答案”做对照。

结构体定义如下。

struct Vrf {
    BYTE hitFlag : 1;
    BYTE pad1 : 7;
    WORD vrfId : 12;
    WORD pad2 : 4;
    DWORD rsv;
};

以 hitFlag = 1、vrfId = 100 为例。

  • hitFlag 只占 1 bit，写到第一个字节最高位，因此第一个字节开头是 1000 0000（0x80）
  • vrfId 占 12 bit，100 的二进制是 0000 0110 0100，紧接着写入 bit 流
  • 其余位域填 0，rsv 也填 0
#include <bits/stdc++.h>

using namespace std;
using BYTE = unsigned char;
using WORD = unsigned short int;
using DWORD = unsigned int;
using U64 = unsigned long long;

struct Vrf {
    BYTE hitFlag : 1;
    BYTE pad1 : 7;
    WORD vrfId : 12;
    WORD pad2 : 4;
    DWORD rsv;

    Vrf() = default;

    explicit Vrf(const std::vector<BYTE>& config) {
        hitFlag = config[0] >> 7;
        pad1 = 0;
        vrfId = (config[1] << 4) | (config[2] >> 4);
        pad2 = 0;
        rsv = 0;
    }

    explicit Vrf(WORD vrfId)
        : hitFlag(1), pad1(0), vrfId(vrfId), pad2(0), rsv(0) {};

    std::vector<BYTE> serialize() const {
        std::vector<BYTE> buf(sizeof(Vrf));
        buf[0] = (hitFlag << 7) | pad1;
        buf[1] = static_cast<BYTE>(vrfId >> 4);
        buf[2] = static_cast<BYTE>(((vrfId & 0x0F) << 4) | pad2);
        buf[3] = static_cast<BYTE>((rsv >> 24) & 0xFF);  // rsv 最高字节
        buf[4] = static_cast<BYTE>((rsv >> 16) & 0xFF);
        buf[5] = static_cast<BYTE>((rsv >> 8) & 0xFF);
        buf[6] = static_cast<BYTE>(rsv & 0xFF);
        return buf;
    }

    std::vector<BYTE> serializeByMemcpy() const {
        std::vector<BYTE> buf(sizeof(Vrf));
        memcpy(buf.data(), this, sizeof(Vrf));
        return buf;
    }

    std::string toString() const {
        return "hitFlag:" + std::to_string(hitFlag) +
               ", vrfId:" + std::to_string(vrfId);
    }
} __attribute__((packed));

void dumpVector(const std::vector<BYTE>& data, size_t dumpCount) {
    cout << hex << uppercase;

    for (size_t i = 0; i < data.size(); ++i) {
        cout << setw(2) << setfill('0') << static_cast<int>(data[i]) << " ";
    }
    cout << dec << endl;
}

int main() {
    Vrf vrf(100);
    cout << vrf.toString() << endl;

    auto config = vrf.serialize();
    cout << "Serialized: " << endl;
    dumpVector(config);
    auto config2 = vrf.serializeByMemcpy();
    cout << "SerializedByMemcpy: " << endl;
    dumpVector(config2);

    return 0;
}

serialize() 输出如下：80 06 40 00 00 00 00。

内存布局拷贝测试

这里用 memcpy 直接展示结构体在内存中的布局，作为对比。

std::vector<BYTE> serializeByMemcpy() const {
    std::vector<BYTE> buf(sizeof(Vrf));
    memcpy(buf.data(), this, sizeof(Vrf));
    return buf;
}

  • 测试结果如下：

  • 预期目标：80 06 40 00 00 00 00

  • serializeByMemcpy() 返回：01 64 00 00 00 00 00

  • 原因分析：

BYTE hitFlag : 1：位域在内存中的具体落位由编译器/ABI 决定，常见实现会从低 bit 开始放，导致内存里看到 0000 0001（0x01）。

WORD vrfId : 12：GCC 常见实现会先分配一个 16-bit 容器；由于主机序为小端序，两个字节在内存里表现为 64 00。这与协议要求的 MSB-first bit 流顺序不是一回事。

优化一：定义工具类代替手动序列化

每次都手写“位拼装”容易出错，也不便维护。一个更可复用的做法是抽象出 BitWriter：只关心“写多少 bit、按 MSB-first 写到哪里”。

  • 接口定义：writeBits(value, n)，其中value表示要序列化的值，n表示这个值要占几位

  • 功能定义：先序列化的位，放在前面的字节，一个字节内，也是从高到低位的顺序来存储

  • 算法描述：自动根据已序列化的bit数量，计算待填充的字节，每个字节内部又从高到低存储比特位

class BitWriter {
public:
    BitWriter() : bitPos_(0) {}

    // 写入 value 的低 bitCount 位（bitCount 最大 64）。
    void writeBits(U64 value, BYTE bitCount) {
        if (bitCount == 0) {
            return;
        }
        if (bitCount > 64) {
            throw invalid_argument("bitCount must be <= 64");
        }

        value &= maskLowerBits(bitCount); //去掉高位脏数据
        //从高到低写入比特位
        for (int i = bitCount - 1; i >= 0; --i) {
            appendOneBit(static_cast<BYTE>((value >> i) & 1ULL));
        }
    }

    void writeZeroBits(DWORD bitCount) {
        for (DWORD i = 0; i < bitCount; ++i) {
            appendOneBit(0);
        }
    }

    const vector<BYTE>& bytes() const {
        return data_;
    }

    size_t bitSize() const {
        return bitPos_;
    }

private:
    static U64 maskLowerBits(BYTE bitCount) {
        if (bitCount == 64) {
            return ~0ULL;
        }
        return (1ULL << bitCount) - 1ULL;
    }

    void appendOneBit(BYTE bit) {
        //计算比特位所属的字节
        size_t byteIndex = bitPos_ / 8;
        BYTE bitInByte = static_cast<BYTE>(bitPos_ % 8);

        if (byteIndex >= data_.size()) {
            data_.push_back(0);
        }

        BYTE shift = static_cast<BYTE>(7 - bitInByte);
        data_[byteIndex] |= static_cast<BYTE>(bit << shift);
        ++bitPos_;
    }

private:
    vector<BYTE> data_;
    size_t bitPos_;
};

那么在序列化的时候就可以简单调用writeBits接口即可

std::vector<BYTE> serializeByBitWriter() const {
    BitWriter w;
    w.writeBits(static_cast<U64>(hitFlag), 1);
    w.writeBits(static_cast<U64>(pad1), 7);
    w.writeBits(static_cast<U64>(vrfId), 12);
    w.writeBits(static_cast<U64>(pad2), 4);
    w.writeBits(static_cast<U64>(rsv), 32);
    //或者w.writeZeroBits(32);
    return w.bytes();
}

结果与手动序列化结果一致

优化二：只维护一处结构体位域信息

  • 痛点：结构体里已经写过“字段 + 位宽”，序列化又写一遍；字段变更时容易漏改，维护成本高
  • 难点：C++ 缺少反射，运行期拿不到字段列表与位宽
  • 方案：使用 X Macro，把“字段列表”集中维护一处，然后派生出位域声明、序列化与反序列化代码
#define VRF_FIELD_LIST(X) \
    X(BYTE, hitFlag, 1) \
    X(BYTE, pad1, 7) \
    X(WORD, vrfId, 12) \
    X(WORD, pad2, 4) \
    X(DWORD, rsv, 32)

struct Vrf {
#define VRF_DECLARE_BITFIELD(type, name, bits) type name : bits;
    VRF_FIELD_LIST(VRF_DECLARE_BITFIELD)
#undef VRF_DECLARE_BITFIELD

    Vrf() = default;

    explicit Vrf(const std::vector<BYTE>& config) {
        hitFlag = config[0] >> 7;
        pad1 = 0;
        vrfId = (config[1] << 4) | (config[2] >> 4);
        pad2 = 0;
        rsv = 0;
    }

    explicit Vrf(WORD vrfId)
        : hitFlag(1), pad1(0), vrfId(vrfId), pad2(0), rsv(0) {};

    std::vector<BYTE> serialize() const {
        BitWriter w;
#define VRF_WRITE_FIELD(type, name, bits) w.writeBits(static_cast<U64>(name), bits);
        VRF_FIELD_LIST(VRF_WRITE_FIELD)
#undef VRF_WRITE_FIELD
        return w.bytes();
    }

    std::string toString() const {
        return "hitFlag:" + std::to_string(hitFlag) +
               ", vrfId:" + std::to_string(vrfId);
    }
} __attribute__((packed));

带位域结构体的反序列化

BitReader

延续序列化思路，实现一个 BitReader 按 MSB-first 从字节流读出 bit，并按位宽拼回字段值。

class BitReader {
public:
    explicit BitReader(const vector<BYTE>& data) : data_(data), bitPos_(0) {}

    U64 readBits(BYTE bitCount) {
        if (bitCount == 0) {
            return 0;
        }
        if (bitCount > 64) {
            throw invalid_argument("bitCount must be <= 64");
        }

        U64 value = 0;
        for (BYTE i = 0; i < bitCount; ++i) {
            value = (value << 1) | readOneBit();
        }
        return value;
    }

private:
    BYTE readOneBit() {
        size_t byteIndex = bitPos_ / 8;
        BYTE bitInByte = static_cast<BYTE>(bitPos_ % 8);
        ++bitPos_;

        if (byteIndex >= data_.size()) {
            return 0;
        }

        BYTE shift = static_cast<BYTE>(7 - bitInByte);
        return static_cast<BYTE>((data_[byteIndex] >> shift) & 1U);
    }

private:
    const vector<BYTE>& data_;
    size_t bitPos_;
};

宏驱动修改反序列化

explicit Vrf(const std::vector<BYTE>& config) {
    BitReader r(config);
#define VRF_READ_FIELD(type, name, bits) name = static_cast<type>(r.readBits(bits));
    VRF_FIELD_LIST(VRF_READ_FIELD)
#undef VRF_READ_FIELD
}

最终优化版本及测试代码

下面给出整合版代码与最小测试，目标是：序列化字节序列与“标准答案”一致，且反序列化能恢复关键字段。

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>

using namespace std;

// 自定义类型定义
using BYTE  = unsigned char;
using WORD  = unsigned short int;
using DWORD = unsigned int;
using U64   = unsigned long long;

// MSB-first 位流：先写入的位占据缓冲区中更早的字节、更高位（与常见网络报文一致）。
class BitWriter {
public:
    BitWriter() : bitPos_(0) {}

    // 写入 value 的低 bitCount 位（bitCount 最大 64）。
    void writeBits(U64 value, BYTE bitCount) {
        if (bitCount == 0) {
            return;
        }
        if (bitCount > 64) {
            throw invalid_argument("bitCount must be <= 64");
        }

        value &= maskLowerBits(bitCount); //去掉高位脏数据
        //从高到低写入比特位
        for (int i = bitCount - 1; i >= 0; --i) {
            appendOneBit(static_cast<BYTE>((value >> i) & 1ULL));
        }
    }

    void writeZeroBits(DWORD bitCount) {
        for (DWORD i = 0; i < bitCount; ++i) {
            appendOneBit(0);
        }
    }

    const vector<BYTE>& bytes() const {
        return data_;
    }

    size_t bitSize() const {
        return bitPos_;
    }

private:
    static U64 maskLowerBits(BYTE bitCount) {
        if (bitCount == 64) {
            return ~0ULL;
        }
        return (1ULL << bitCount) - 1ULL;
    }

    void appendOneBit(BYTE bit) {
        //计算比特位所属的字节
        size_t byteIndex = bitPos_ / 8;
        BYTE bitInByte = static_cast<BYTE>(bitPos_ % 8);

        if (byteIndex >= data_.size()) {
            data_.push_back(0);
        }

        BYTE shift = static_cast<BYTE>(7 - bitInByte);
        data_[byteIndex] |= static_cast<BYTE>(bit << shift);
        ++bitPos_;
    }

private:
    vector<BYTE> data_;
    size_t bitPos_;
};

class BitReader {
public:
    explicit BitReader(const vector<BYTE>& data) : data_(data), bitPos_(0) {}

    U64 readBits(BYTE bitCount) {
        if (bitCount == 0) {
            return 0;
        }
        if (bitCount > 64) {
            throw invalid_argument("bitCount must be <= 64");
        }

        U64 value = 0;
        for (BYTE i = 0; i < bitCount; ++i) {
            value = (value << 1) | readOneBit();
        }
        return value;
    }

private:
    BYTE readOneBit() {
        size_t byteIndex = bitPos_ / 8;
        BYTE bitInByte = static_cast<BYTE>(bitPos_ % 8);
        ++bitPos_;

        if (byteIndex >= data_.size()) {
            return 0;
        }

        BYTE shift = static_cast<BYTE>(7 - bitInByte);
        return static_cast<BYTE>((data_[byteIndex] >> shift) & 1U);
    }

private:
    const vector<BYTE>& data_;
    size_t bitPos_;
};

#define VRF_FIELD_LIST(X) \
    X(BYTE, hitFlag, 1) \
    X(BYTE, pad1, 7) \
    X(WORD, vrfId, 12) \
    X(WORD, pad2, 4) \
    X(DWORD, rsv, 32)

struct Vrf {
#define VRF_DECLARE_BITFIELD(type, name, bits) type name : bits;
    VRF_FIELD_LIST(VRF_DECLARE_BITFIELD)
#undef VRF_DECLARE_BITFIELD

    Vrf() = default;

    explicit Vrf(const std::vector<BYTE>& config) {
        BitReader r(config);
#define VRF_READ_FIELD(type, name, bits) name = static_cast<type>(r.readBits(bits));
        VRF_FIELD_LIST(VRF_READ_FIELD)
#undef VRF_READ_FIELD
    }

    explicit Vrf(WORD vrfId)
        : hitFlag(1), pad1(0), vrfId(vrfId), pad2(0), rsv(0) {};

    std::vector<BYTE> serialize() const {
        BitWriter w;
#define VRF_WRITE_FIELD(type, name, bits) w.writeBits(static_cast<U64>(name), bits);
        VRF_FIELD_LIST(VRF_WRITE_FIELD)
#undef VRF_WRITE_FIELD
        return w.bytes();
    }

    std::string toString() const {
        return "hitFlag:" + std::to_string(hitFlag) +
               ", vrfId:" + std::to_string(vrfId);
    }
} __attribute__((packed));

void dumpVector(const std::vector<BYTE>& data) {
    cout << hex << uppercase;

    for (size_t i = 0; i < data.size(); ++i) {
        cout << setw(2) << setfill('0') << static_cast<int>(data[i]) << " ";
    }
    cout << dec << endl;
}

int main() {
    Vrf vrf(100);
    cout << "Origin: " << vrf.toString() << endl;

    auto config = vrf.serialize();
    //cout << "Serialized: " << endl;
    //dumpVector(config);
    const vector<BYTE> expected = {0x80, 0x06, 0x40, 0x00, 0x00, 0x00, 0x00};
    const bool serializeOk = (config == expected);
    cout << "Serialize bytes test: " << (serializeOk ? "PASS" : "FAIL") << endl;
    cout << "  actual  : ";
    dumpVector(config);
    cout << "  expected: ";
    dumpVector(expected);

    Vrf decoded(config);
    cout << "Decoded: " << decoded.toString() << endl;

    const bool deserializeOk = (decoded.hitFlag == vrf.hitFlag) &&
                               (decoded.vrfId == vrf.vrfId);
    cout << "Deserialize test: " << (deserializeOk ? "PASS" : "FAIL") << endl;

    return 0;
}

可复用的工程经验

  1. 协议是协议，内存是内存：位域布局不受标准保证，memcpy 只能拿到内存表示，不能当作协议序列化
  2. 先手算一个标准答案：有了可对照的期望字节序列，后续任何实现（手写、工具类、宏驱动）都能用单测快速验证
  3. 把“bit 流写入/读取”抽成工具：BitWriter/BitReader 只做一件事：维护 bit 游标，按 MSB-first 写/读
  4. 把字段列表当作单一事实源：用 X Macro 集中维护 type/name/bits，再派生声明、序列化、反序列化，减少重复与漏改
标签
#开发语言 #c++
网络探秘
关注
Qt之数据序列化（结构体序列化，类序列化，含源码+注释）
lw的博客
08-18 8590
下图包含常用类型、复杂容器、结构体、类对象的序列化和反序列化值演示。 提示：不会使用Qt设计师设计界面的小伙伴点击这里其中序列化和反序列化简单的操作流程如下 基本上所有序列化、反序列化流程都是如此，记住这个顺序最好 反序列化（用源码中整形举例） SerializeType.h头文件讲解 该头文件中包含学生信息结构体和学生信息类，咋一看两者内容都一样，其实是真的一样；这样是为了表达说结构体和类中序列化、反序列化操作超级像，了解一个相当于了解第二个 CSerializeWindow.h CSerial
【网络】自定义协议——序列化和反序列化
AAlykk的博客
11-04 1753
前面我们已经学习了网络的基础知识，对网络的基本框架已有认识，算是初步认识到网络了，如果上期我们的学习网络是步入基础知识，那么这次学习的板块就是基础知识的实践，我们今天的板块是学习网络重要之一，学习完这个板块对虚幻的网络就不再迷茫！！！二网络协议：是通信计算机双方必须共同遵从的一组约定，为了使数据在网络上能够从源地址到目的地址，网络通信的参与方必须遵循相同的规则，因此我们将这套规则称为协议，协议最终需要通过计算机语言的方式表示出来。应用层：位于网络协议的最高层，直接为用户提供服务。
go结构体和json相互转换、序列化和反序列化
SunnyRivers
02-07 1830
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。RESTfull Api 接口中返回的数据都是 json 数据。"title": "笔记本电脑",},"title": "第二个轮播图",},"title": "第三个轮播图",},"title": "教程",
QT笔记——QDataStream 序列化 与 反序列化
lion_cxq的博客
08-18 3292
1. 序列化与反序列化目的 通常在程序运行过程中我们需要对一个对象当前的状态进行存储或者传输，在传递和保存对象时，保证对象的完整性和可传递性。对象转换为有序字节流，以便在网络上传输或者保存在本地文件中，之后根据字节流中保存的对象状态及描述信息，通过反序列化重建对象，反序列化之后的对象状态跟序列化之前的对象状态一致。 写QDataStream 遇到的问题： 在UDP 通信中发送一个结构体如下 struct Person { char name[20]; int age; int score; P.
C#结构体序列化与反序列化实战示例
weixin_30598047的博客
09-16 1094
在C#中，结构体（struct）是一种轻量级的值类型数据结构，通常用于封装一组相关的数据成员。与类（class）不同，结构体继承自，并默认在栈上分配内存，这使其在访问速度和内存效率上更具优势。定义结构体的基本语法如下：Age = age;上述代码定义了一个名为Person的结构体，包含两个字段：Name和Age，并提供了一个构造函数和一个方法Display()。结构体支持字段、属性、方法甚至构造函数，但不支持继承（不能继承自其他类或结构体）
Rust结构体的JSON序列化和反序列化
yeholmes的专栏
08-08 4257
一个JSON的序列化问题 与人聊天时偶然问到一个问题：“给定任意一个(C/C++)结构体，如何实现其JSON的序列化和反序列化，而不用专门编写相应的序列化、反序列化实现代码？”我摇摇头，表示不知如何实现这一功能；现在我也认为，这一功能对于C/C++，是不可能自动化实现的。不过对于其他的静态编译型编程语言，如Golang/Rust等，这一功能则相对容易实现。与Golang的反射机制(Reflection)不同，Rust使用到了trait机制。 Rust的JSON序列化库 serde提供了通用的序列化功能，诸多
C++使用protobuf实现序列化与反序列化
热门推荐
ArtAndLife的博客
05-15 2万+
考虑设计一个协议？ 高效、简单、扩展、兼容 解决拆包粘包： Protobuf的工作流程： 1. 首先设计一个 .proto 文件，其中是开发人员设计的协议内容； 2. 然后通过 protobuf 自带的 解析工具，将 .proto 文件进行解析，生成目标语言（c, cpp, java, py 等）的文件； 3. 最后将生成的目标语言的文件引入项目。 一个 .proto 文件编写示例： //addrbooks.proto syntax = "proto3"; //表示协议版本 //syntax: n.
[Linux#55][网络协议] 序列化与反序列化 | TcpCalculate为例
No Game No Life
09-20 3397
本文介绍了结构化数据在网络中的传输方法，通过定义Request和Response类实现序列化与反序列化，并以网络版计算器为例，详细阐述了TCP服务端、客户端的设计及其实现过程，强调了序列化技术在网络通信中的关键作用。
C#结构体Struct的序列化Serialize和反序列化unserialize为字符串
yangjun_cool的专栏
04-24 8303
C#结构体Struct的序列化Serialize和反序列化unserialize为字符串 201 关于对象如何序列化和反序列化为字符串的问题，已经解决了： 但是上次是遇到了，去序列化结构体，会出错，所以以为C#中，不支持结构体的序列化呢。  后来无意间得知，C#好像也是能实现结构体的序列化的，所以现在去搞清楚，如何实现。 【解决过程】  1.网上搜了一堆，找到很多谈
Unity-序列化和反序列化
chenshun123的博客
12-25 2197
序列化是指把对象转换为字节序列的过程，而反序列化是指把字节序列恢复为对象的过程。序列化最主要的用途就是传递对象和保存对象。 在Unity中保存和加载、prefab、scene、Inspector窗口、实例化预制体等都使用了序列化与反序列化。
序列化和反序列化
challenglistic的博客
07-22 1706
在网络中为了便于传输，采用序列化和反序列化
对象的序列化与反序列化详解
小小默：进无止境
09-30 6597
Java对象序列化时参与序列化的内容包含以下几个方面：1.属性，包括基本数据类型、数组以及其他对象的引用； 2.类名。不能被序列化的内容有以下几个方面：1.方法。 2.有static修饰的属性。 3.有transient修饰的属性。在序列化过程中不仅保留当前类对象的数据，而且递归保存对象引用的每个对象的数据。将整个对象层次写入字节流中，这也就是序列化对象的“深复制”，即复制对象本身及引用的对象
Unity中的序列化和反序列化
L的博客
08-31 7896
序列化是指把对象转换为字节序列的过程，而反序列化是指把字节序列恢复为对象的过程。序列化最主要的用途就是传递对象和保存对象在Unity中保存和加载、prefab、scene、Inspector窗口、实例化预制体等都使用了序列化与反序列化。...
【Golang】Go 语言 JSON 的序列化与反序列化实践
Fxtack的博客
07-03 5214
JSON 的序列化与反序列化 实践 导读 本文针对 Go 原生支持的，对 JSON 字符串以及 .json 文件进行序列化与反序列化的包进行实践，并进行简单的性能比对。 使用到的包是 encoding/json。详细文档可查看官方中文文档，链接为： https://studygolang.com/pkgdoc 本文中所有代码块的 Go 代码均经过运行测试，可以直接复制运行。 文章目录JSON 的序列化与反序列化 实践导读一. 简述序列化与反序列化二. JSON 的序列化1. 序列化简单示例2. 序列化完
结构体序列化和反序列化
weixin_43185874的博客
04-21 1508
内存对齐规则成员变量在内存中是否连续系统架构是否一致（不同系统架构下基本数据类型的字节数可能不同）因此，在设计序列化算法之前，请务必对结构体成员变量的内存布局有清晰的认识。
解构与重构：深入理解C语言中的数据序列化与反序列化
科技改变人类，技术成就未来
06-07 1万+
在底层系统开发、嵌入式设备通信或跨平台数据交换中，我们常常面临一个核心问题：如何将内存中的复杂数据结构安全、高效地转化为可传输或可持久化的字节流？这正是序列化与反序列化（Serialization&Deserialization）的关键所在。
C++武艺修炼--基于C++17实现遍历结构体及序列化和反序列化
m0_62100380的博客
06-13 1060
C++武艺修炼--基于C++17实现遍历结构体及序列化和反序列化
十一、结构体和 Json 相互转换（序列化反序列化）
阿澈不吃蒜的博客
08-03 2458
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。RESTfull Api 接口中返回的数据都是 json 数据。稍微复杂点的JSON注意一个点：结构体内的私有属性不能被json包访问，如果结构体内部的属性都要就行转换，需要全部为公有属性（开头字符大写）比如我们 Golang 要给 App 或者小程序提供 Api 接口数据，这个时候就需要涉及到结构体和Json 之间的相互转换。是指把结构体数据转化成。
网络基础『 序列化与反序列化』
北 海的博客
03-11 1821
本文将介绍如何使用C++实现简单的服务器和客户端通信，并重点讲解序列化与反序列化的概念和实现。这篇文章将深入探究数据在网络传输中的转换过程，以及如何在C++中应用这些技术
kettle扩大运行内存
最新发布
早睡早起
07-03 7408
机器内存大，kettle却还是报错内存溢出，这时候可以尝试调整kettle的运行内存 在windows中运行修改Spoon.bat文件中的参数PENTAHO_DI_JAVA_OPTIONS -Xms最小运行内存，-Xmx为最大运行内存，m为内存单位，也可以直接设置g为单位 在linux中修改spoon.sh的参数PENTAHO_DI_JAVA_OPTIONS -XX:MaxPermSize=256mJVM最大允许分配的非堆内存，java8以上中已经移除了该参数，如果使用的jdk8以上可以把.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值