1.由json解析的常用库nlohmann引入序列化反序列化的概念

序列化是指将对象转换为字节序列的过程，以便于存储或传输。在序列化过程中，对象的状态信息将被转换为字节流，可以保存到文件中或通过网络传输给其他计算机。反序列化则是将字节序列恢复为对象的过程

在代码种具体表示为这种

#include <iostream>
#include "nlohmann/json.hpp"
using json = nlohmann::json;
int main()
{
    json j;

    //反序列化方式1
    j["pi"] = 3.141;

    
    j["happy"] = true;

   
    j["name"] = "Niels";

   
    j["nothing"] = nullptr;

   
    j["answer"]["everything"] = 42;

   
    j["list"] = { 1, 0, 2 };

   
    j["object"] = { {"currency", "USD"}, {"value", 42.99} };
    std::cout << j << std::endl;


   
    //反序列化方式1
    auto j2 = R"(
  {
    "happy": true,
    "pi": 3.141
  }
)"_json;

    //反序列化方式1
    auto j3 = json::parse("{ "happy": true, "pi": 3.141 }");

    //序列化
    std::string a = j.dump();

   
}

当时笔者读到这里还是感觉有点抽象，单看代码和结合概念说明难以理解。

最终在c++直接进行序列化和反序列化的原生代码种完全明白了，在这里和读者进行分享

2.c++struct的序列化和反序列化

1.把struct结构体转换成字节流进行序列化

2.把字节流转换成struct进行反序列化

#include <iostream>


typedef unsigned char BYTE;
typedef struct tagStudents {
    std::string name;
    std::string No;
    int         age;
    int         grade;
    int         scores;
}STUDENTS, * LP_STUDENTS;

bool Serialize(BYTE** pMem, LP_STUDENTS pData)
{
    bool bok = false;
    

    bok = pData != NULL;
    if (bok)
    {
      //序列化过程，把内存种的结构体拷贝到领一个内存种，这个内存每个数据都是byte大小
      //就像int*指针空间自动认为是一个数据占四个字节，longlong*空间的一个数据自动占8个字节
       memcpy_s(*pMem, sizeof(STUDENTS), pData, sizeof(STUDENTS));
       
    }


    return bok;
}

bool DeSerialize(BYTE* pMem, LP_STUDENTS pData)
{
    bool bok = false;
    bok = pMem != NULL;
    if (bok)
    {
        //反序列化过程，把字节流转换成结构体类型，方便我们读取里面的数据
         memcpy_s(pData, sizeof(STUDENTS), pMem, sizeof(STUDENTS));
    }

    return bok;
}

int main()
{
    STUDENTS st;
    LP_STUDENTS pst = &st;

    STUDENTS st2;
    LP_STUDENTS pst2 = &st2;
    bool state;
    st.name = "jjk";
    st.No = "111";
    st.grade = 3;
    st.age = 23;
    st.scores = 95;
    BYTE* pbyte = (BYTE*)malloc(sizeof(STUDENTS));


    state = Serialize(&pbyte, pst);

    DeSerialize(pbyte, pst2);

    std::cout << pst2->name << std::endl;
    std::cout << pst2->age << std::endl;
    std::cout << pst2->No << std::endl;
    std::cout << pst2->grade << std::endl;
    std::cout << pst2->scores << std::endl;

    free(pbyte);
}

重点部分：memcpy_s(*pMem, sizeof(STUDENTS), pData, sizeof(STUDENTS));

序列化过程，把内存种的结构体拷贝到领一个内存种，这个内存每个数据都是byte大小
 就像int*指针空间自动认为是一个数据占四个字节，longlong*空间的一个数据自动占8个字节

memcpy_s(pData, sizeof(STUDENTS), pMem, sizeof(STUDENTS));

反序列化过程，把字节流转换成结构体类型，方便我们读取里面的数据

3.总结

序列化转换成字节流，能方便的进行保持和在网络进行传输。

反序列化能把字节流数据转换成结构化的数据，方便读取和识别。

首先要明白一个概念，如果用int*指针对，一块内存进行遍历这个指针每次加1

实际上是向前移动4个字节，类似的shor*每次移动2个字节，BYTE*每次移动一个字节。