C++序列化

最新推荐文章于 2024-10-02 08:00:00 发布
最新推荐文章于 2024-10-02 08:00:00 发布
阅读量518 收藏 2
点赞数
分类专栏： 造轮子系列 文章标签： c++ 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zdsji/article/details/130891402
版权

主体类实现序列化和反序列化功能，用的模版元编程。通过重载<<达到流式编码效果。

代码里没有用using namespace，不习惯这种用法，习惯了显式namespace。

编码结果参考YaZi, 将变量编码为: 1字节(类型) + n字节(数据)。

对容器类编码为: 1字节(类型) + 5字节(长度，其中1字节代表类型，4字节代表长度) + n字节(数据)。

类型

类型通过枚举类表示

enum my_enum
    {
        UNKNOW = -1,
        INT = 0,
        INT64,
        BOOL,
        CHAR,
        FLOAT,
        DOUBLE,
        CHARPTR,
        STRING,
        VECTOR,
        DEQUE,
        SET,
        MULTISET,
        MAP,
        MULTIMAP,
        LIST,
        CUSTOM
    };

 序列化实现

template<class T>
Serialize& operator << (T data)
{
    this->write(data);
    this->obj_num++;
    return *this;
}

可以看到调用的是write方法，在实现中对write方法做了一些重载，主要处理

1. 基本类型，int32,bool之类的，非指针类型。

// 基本数据类型
template<class T, class  = std::enable_if_t<std::is_pod_v<std::decay_t<T>>, void>>
void write(T data)
{
    this->writeType(data);
    this->write((char*)&data, sizeof(data));
}

对基本类型处理直接转为char*指针，本质是将数据转为字节流传输，调用memcpy_s方法写入字节流。

void Serialize::write(const char* data, int len)
{
    this->reserve(len);
    int size = this->m_buf.size();
    this->m_buf.resize(size + len);
    memcpy_s(&this->m_buf[size], size+len, data, len);
}

其中std::enable_if_t<std::is_pod_v<std::decay_t<T>>, void>匹配基本数据类型，个人感觉std::enable_if_t主要在模版中提供一种筛选功能，具体可以看官网介绍。std::decay_t用来进行类型擦除，主要擦除const以及引用这些。

2. stl标准容器类型

下边是write的另外两个重载，用来处理stl标准容器类型

// 类list类型
template<class T>
std::enable_if_t<is_array_v<T>, void> write(const T& data)
{
    this->writeType(data);
    int len = data.size();
    this->write(len);
    for(auto iter = data.begin(); iter != data.end(); iter++)
    {
        this->write(*iter);
    }
}
// k,v类型
template<class T>
std::enable_if_t<is_KV_v<T>, void> write(const T& data)
{
    this->writeType(data);
    int len = data.size();
    this->write(len);
    for(auto iter = data.begin(); iter != data.end(); iter++)
    {
        this->write(iter->first);
        this->write(iter->second);
    }
}

3.string类型

对string类型做单独处理，因为需要调用c_str将string转为char*

// std::string类型
template<class T>
std::enable_if_t<std::is_same_v<std::decay_t<T>, std::string>, void> write(T data)
{
    this->writeType(data);
    this->write(data.c_str());
}

4. char*类型

没有考虑对其他类型数组的处理，主要原因是除了char类型数组，其他数组没有明显的结束符，需要额外传递长度参数，建议直接使用stl标准库的list/vector。而char*类型一般表示字符串，有明显的'\0'结束符，因此直接对char*类型做了偏特化。这样所有类型只需要传递数据本身，在调用时没有差别。

void Serialize::write(const char* data)
{
    int len = strlen(data) + 1;
    this->write(len);
    this->write(data, len);
}

5. 自定义类型处理 

此处借鉴了YaZi大佬的思路，通过宏获取自定义类中需要序列化的属性，使用变长模版参数进行处理。唯一感觉难受的就是需要将该方法做成public，有点影响封装。

关于自定义类型，需要继承SerializeAble类并且调用宏SERIALIZEABLE将自定义类中需要序列化的字段写入。

void Serialize::write(SerializeAble& serialize_able)
{
    serialize_able.serialize(*this);
}

#define SERIALIZEABLE(...)                                  \
    void serialize(zdsj::Serialize& stream) const override  \
    {                                                       \
        auto type_name = zdsj::CUSTOM;                      \
        stream.write_args(type_name, __VA_ARGS__);          \
    }                                                       \
    bool unSerialize(zdsj::Serialize& stream) override      \
    {                                                       \
        return stream.read_args(__VA_ARGS__);               \
    }                                                       \

template<class T, class ...Args>
void write_args(T& data, Args& ...args)
{
    this->write(data);
    this->write_args(args...);
}

void write_args()
{
    
}

class A : public zdsj::SerializeAble
{
public:
    A()
    {
        
    }

    void show()
    {
        std::cout << "a=" << a << " b=" <<  b << std::endl;
    }

    SERIALIZEABLE(a, b)
private:
    int a = 2;
    float b = 23.0;
};

序列化中对stl容器类型判断方法

这里借鉴了其他大佬的思路，通过模版匹配的方式判断

template<typename T,typename... Types>
struct IsContainerType
{
    static const bool value = false;
    static const my_enum type = zdsj::CUSTOM;
};

// Vector类型为true
template<typename T,typename... Types>
struct IsContainerType<std::vector<T, Types...>>
{
    static const bool value = true;
    static const my_enum type = zdsj::VECTOR;
};

// deque类型
template<typename T,typename... Types>
struct IsContainerType<std::deque<T, Types...>>
{
    static const bool value = true;
    static const my_enum type = zdsj::DEQUE;
};

// set类型
template<typename T,typename... Types>
struct IsContainerType<std::set<T, Types...>>
{
    static const bool value = true;
    static const my_enum type = zdsj::SET;
};

// multiset类型
template<typename T,typename... Types>
struct IsContainerType<std::multiset<T, Types...>>
{
    static const bool value = true;
    static const my_enum type = zdsj::MULTISET;
};

// map类型
template<typename K,typename V,typename... Types>
struct IsContainerType<std::map<K, V, Types...>>
{
    static const bool value = true;
    static const my_enum type = zdsj::MAP;
};

// multimap类型
template<typename K,typename V,typename... Types>
struct IsContainerType<std::multimap<K, V, Types...>>
{
    static const bool value = true;
    static const my_enum type = zdsj::MULTIMAP;
};

// list类型
template<typename T,typename... Types>
struct IsContainerType<std::list<T, Types...>>
{
    static const bool value = true;
    static const my_enum type = zdsj::LIST;
};

// 定义获取容器类型的模板
template<typename T,typename... Types>
constexpr bool is_container_v = IsContainerType<T, Types...>::value;

// 定义获取容器类型的模板
template<typename T,typename... Types>
constexpr my_enum is_container_t = IsContainerType<T, Types...>::type;

// 定义获取容器类型的模板
template<typename T,typename... Types>
constexpr bool is_array_v = IsContainerType<T, Types...>::type == zdsj::VECTOR ||
    IsContainerType<T, Types...>::type == zdsj::SET ||
    IsContainerType<T, Types...>::type == zdsj::MULTISET ||
        IsContainerType<T, Types...>::type == zdsj::DEQUE ||
            IsContainerType<T, Types...>::type == zdsj::LIST;

template<typename T,typename... Types>
constexpr bool is_KV_v = IsContainerType<T, Types...>::type == zdsj::MAP ||
    IsContainerType<T, Types...>::type == zdsj::MULTIMAP;

反序列化

反序列化与序列化操作相反，代码已上传gitee

找到数据起始地址所在索引，将其转换为指针后直接解引用，提前加了判断，判断类型是否匹配，防止解引用时数据出错，其他数据格式同理：

// 基本数据类型
template<class T, class = std::enable_if_t<std::is_pod_v<std::decay_t<T>>, void>>
bool read(T& data)
{
    auto read_type = my_enum(this->m_buf[this->m_pos]);
    this->m_pos++;
    if(this->checkType(data, read_type))
    {
        data = *(T*)(&this->m_buf[this->m_pos]);
        this->m_pos += sizeof(T);
        return true;
    }else
    {
        return false;
    }
}

由于反序列化实现的方式，在使用时需要反序列化顺序与序列化相同，否则容易出现类型不匹配导致反序列化失败的情况。

其实本质上不需要对类型进行编码，只要保证反序列化时与序列化顺序相同即可，但是那样因为缺少类型判断，如果顺序不同，容易出现数据读取错误的问题。

代码地址：Serialize: c++序列化

zdsji
关注
专栏目录
amsg:C++ 序列化库
06-04
AMSG v2.0 AMSG 是一个 C++ 序列化库。 功能概述 轻量、快速、高效的序列化实现 只有一个宏来注册C++结构体，一行代码就够了 仅头文件，无需构建库，只需三个 hpp 文件 支持 C++11 默认支持 C++ 内置类型和所有 std 容器 什么是AMSG？ struct person { std::string name; int age; bool operator ==(person const & rhs) const { return name == rhs. name && age == rhs. age ; } }; AMSG (person, (name)(age)); # define ENOUGH_SIZE 4096 unsigned char buf[ENOUGH_SIZE]; // seriali
c++简单序列化库
11-05
c++ 的简单序列化库，特点： 小巧 非侵入式 支持 pod 支持 stl 容器 二进制存储 可扩展
C++牛客网编程（十三）
weixin_45588765的博客
03-31 1219
序列化二叉树 描述：请实现两个函数，分别用来序列化和反序列化二叉树，不对序列化之后的字符串进行约束，但要求能够根据序列化之后的字符串重新构造出一棵与原二叉树相同的树。 二叉树的序列化(Serialize)是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树等遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#） 二叉树的反序列化(Deserialize)是指：根据某种遍历
[C++]两种常用C++序列化方案protobuf和boost serialization
FL1768317420的博客
03-16 802
对象序列化的好处在哪里？Boost库是个很庞大的库，功能非常丰富，序列化只是其中的一个小分支，但为了使用Boost的序列化方案，你需要安装整个Boost库，所花费的磁盘空间和时间都很多，同样支持的序列化功能也很强大，既支持二维数组（指针），也支持STL容器，更不需要我们用某种特殊的格式重新定义我们的类结构，其非侵入的性质使得我们无须改动已有的类结构即可序列化，这时非常赞的一个性质。但是由于体积庞大，安装复杂，如果只是简单的序列化，没必要使用该方案，只有protobuf不能满足你的需求时，才应该考虑该方案。
C++ 实现序列化
11-03
C++实现序列化，简单的讲是将C++里的对象（此处是广义上的对象，内置类型或者用户自定义类型）数据变成char*，即单个字节的数据，这样方便传输等，涉及到的知识点有C++中的函数重载，操作符重写，allcotor，左值和右值，继承，模板等
C++与序列化
weixin_43728590的博客
06-15 3882
协议/protobuf
c++序列化方法
weixin_33816611的博客
10-01 159
暂时使用boost 序列化， 目前我的测试基本都ok 只是对于c++11 shared ptr 没有测试成功，只能手工写下shared ptr 部分的序列化，也就是目前我对指针都不直接序列化，自己管理，例如下面样子 Load_(modelFile); //model直接序列化 string normalizerName = read_file(OBJ_NAME_PATH(_normalize...
C++ 序列化
08-15 1886
转自:http://blog.csdn.net/pandaxcl/archive/2006/04/03/649682.aspx #if 0     在用C++编写应用程序的过程中，经常涉及到序列化的问题，但是序列化的问题通常都 会有非常繁琐的过程代码需要书写，本文中就是
C++之序列化
qq_41980769的博客
07-10 3588
文章目录序列化和反序列化JSONMessagePackProtoBuffer 小结： JSON 是纯文本，容易阅读，方便编辑，适用性最广； MessagePack 是二进制，小巧高效，在开源界接受程度比较高； ProtoBuffer 是工业级的数据格式，注重安全和性能，多用在大公司的商业产品里。 序列化和反序列化 序列化，就是把内存里“活的对象”转换成静止的字节序列，便于存储和网络传输； 而反序列化则是反向操作，从静止的字节序列重新构建出内存里可用的对象。 接下来，我就和你介绍三种既简单又高效的数据
C++序列化和反序列化
03-10
函数API接口感受到非常不适应，你一定非常怀念使用java和C#对一个实体类的那么轻松加简单的直接json序列化，本篇博客使用一个RapidJsonHelper类，将帮你实现对一个C++实体类的的序列化和反序列化。rapidjson的版本是...
一个更好的C++序列化/反序列化库Kapok
12-15
　对对象进行自动化的序列化和反序列化，用起来非常简单，先来看个序列化/反序列化一个tuple的例子吧。 　//序列化 　Serializer sr; 　auto tp = std::make_tuple(10， 12， string("test")); 　sr.Serialize...
C++序列化类的详细说明
08-29
详细解释了C++对类的序列化的原理，通过这个，可以自己编译出可以序列化和反序列化的代码来，而不再用MFC的宏，本想0积分的，但确实是自己慢慢测试编译的，好歹也有辛苦分，高手勿喷，新手共勉。
C++ JSON 序列化与反序列化
06-22
本篇文章将深入探讨C++中JSON的序列化与反序列化。 **一、JSON序列化** 序列化是指将C++的对象转换为JSON字符串的过程，以便在网络上传输或保存到文件中。常见的C++ JSON序列化库有RapidJSON、nlohmann/json、...
C++文件的序列化
Billy Jue的博客
12-10 1971
转载于：https://blog.csdn.net/freehyan/article/details/51814336 用于记录下 序列化(serializtion)是指把对象信息转换成可以存储或者通过网络连接传输格式的过程，然后在本地或者在另一个计算机环境中可以重构出原有的对象信息是指反序列化。 前言 本文只介绍通过boost serialization存储的优势，先通过例子简单明白。假如现在你是一个学校学生系统管理员，你需要保存学生信息，比如学生学好，名字，年龄。当然最简单的方式是通过C++的文
c++序列化
hongge_smile的博客
11-23 299
链接: https://blog.csdn.net/leapmotion/article/details/83687517 https://www.cnblogs.com/feixiao5566/p/5189246.html
C/C++对象的序列化
热门推荐
IT1995的博客
08-28 1万+
C/C++对象的序列化
使用socket编程来实现一个简单的C/S模型（TCP协议）
最新发布
caiji0169的博客
10-02 1704
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值