C++序列化

最新推荐文章于 2023-12-26 09:25:18 发布
最新推荐文章于 2023-12-26 09:25:18 发布
阅读量473 收藏 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
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++与序列化
weixin_43728590的博客
06-15 3302
协议/protobuf
手撕代码: C++实现数据的序列化和反序列化
最新发布
红军不怕远征难，万水千山只等闲
04-24 1271
在C++应用程序中，经常会涉及到对一些数据进行序列化和反序列化的处理。序列化可以将一个对象转换为一串字节流，这样就可以将其存储在硬盘上或者通过网络传输到其他设备上。而反序列化则是将这些字节流解析成原始的对象。 在Qt中，数据的序列化和反序列化可以使用QDataStream类来完成。QDataStream是一个方便的Qt类，它可以将基本数据类型、Qt数据类型以及用户定义的数据类型都进行序列化和反序列化。在使用QDataStream进行序列化时，需要指定一个QIODevice类的子类（例如QF
C++ 实现序列化
热门推荐
leapmotion的博客
11-03 2万+
本文大概讲下用C++实现序列化 本文的序列化：简单的讲是将C++里的对象（此处是广义上的对象，内置类型或者用户自定义类型）数据变成char*，即单个字节的数据，这样方便传输等 本文要求有一点C/C++基础 涉及到的知识点有C++中的函数重载，操作符重写，allcotor，左值和右值，继承，模板等 序列化： 数据对象 =====&gt; 字节数组 反序列化： 字节数组 ==...
C++Boost序列化（Serialization）库教程（中文版）
weixin_38070782的博客
05-25 3211
一个非常简单的情形 非侵入的版本 可序列化的成员 派生类 指针 数组 STL容器 类的版本 把serialize拆分成save/load 档案 输出档案(archive)类似于输出数据流(stream)。数据能通过<< 或 & 操作符存储到档案(archive)中: ar << data; ar & data; 输入档案(archive)类似于输入数据流(stream)。数据能通过>> 或 & 操作符从档案(archi
c++对象序列化编程实例
网络编程与服务器编程
11-14 416
      在《使用 acl 库针对 C++ 对象进行序列化及反序列编程》中介绍了 acl 库中针对 C/C++ 的 struct 对象进行序列化和反序列化的功能，并且给出了一个简单的例子。本文将介绍一些较为复杂的例子。       一、示例一：支持多继承的例子       先定义 struct.stub 文件： #pragma once #include &lt;string&gt;...
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++序列化组件
10-17
这个"C++序列化组件"可能是一个专用于处理C++对象序列化的库或框架，帮助开发者更方便地进行序列化操作。描述中提到的链接（http://blog.csdn.net/chenyu2202863/article/details/6879013）可能是对该组件的详细讲解...
C++序列化类的详细说明
08-29
详细解释了C++对类的序列化的原理，通过这个，可以自己编译出可以序列化和反序列化的代码来，而不再用MFC的宏，本想0积分的，但确实是自己慢慢测试编译的，好歹也有辛苦分，高手勿喷，新手共勉。
amsg:C++ 序列化库
06-04
AMSG 是一个 C++ 序列化库。 功能概述 轻量、快速、高效的序列化实现 只有一个宏来注册C++结构体，一行代码就够了 仅头文件，无需构建库，只需三个 hpp 文件 支持 C++11 默认支持 C++ 内置类型和所有 std 容器 ...
对话框序列号例程serialize
11-29
对话框序列号例程serialize
YAZI序列化工具
qq_57283958的博客
12-31 370
序列化
C++ 序列化
08-15 1852
转自:http://blog.csdn.net/pandaxcl/archive/2006/04/03/649682.aspx #if 0     在用C++编写应用程序的过程中，经常涉及到序列化的问题，但是序列化的问题通常都 会有非常繁琐的过程代码需要书写，本文中就是
C++中序列化和反序列化
道亦无名
12-26 612
需要注意的是，这个示例中的序列化和反序列化方法很简单，只适用于基本类型和简单的结构体。对于更复杂的数据类型，如类或数组，你可能需要实现自定义的序列化和反序列化方法。此外，为了确保数据的完整性和安全性，你可能还需要添加错误处理和加密等额外的功能。在C++中，序列化和反序列化是指将数据转换为字节流或从字节流中恢复数据的过程。C++标准库中没有提供序列化和反序列化的直接支持，但你可以使用第三方库或自己编写代码来实现这个功能。函数中，我们演示了如何使用这两个函数进行序列化和反序列化整数。函数将一个对象写入到。
C++中struct序列化为xml的简易实现
superlee19的专栏
05-23 5167
刺瞎我的狗眼！！！听说C#有一个功能，能自动将一个struct的对象序列化成xml，也能将xml反序列化成对应的struct对象，C++木有，好吧，我承认，C++木有的东西还很多。。。。。。把struct序列化为xml有虾米好处呢？想了半天，想到的我都用不上，唯一的好处，打发最近无聊的时间。时间有限，不能整复杂了，免得收不了场，一切从简。比如有struct定义如下：struct Test{    int nItem;    bool bItem;}这样一个最基本的struct定义，序列化为xml，基本效果应
C++序列化方案
Jiewang的博客
03-29 1424
1、什么是序列化 程序员在编写应用程序的时候往往需要将程序的某些数据存储在内存中，然后将其写入某个文件或是将它传输到网络中的另一台计算机上以实现通讯。这个将程序数据转化成能被存储并传输的格式的过程被称为“序列化”（Serialization），而它的逆过程则可被称为“反序列化” （Deserialization）。 简单来说，序列化就是将对象实例的状态转换为可保持或传输的格式的过程。与序列化相对的...
使用C++进行对象序列化
Everything is possible--博客的内容只是作为一种备忘
03-09 1041
什么是序列化 程序员在编写应用程序的时候往往需要将程序的某些数据存储在内存中，然后将其写入某个文件或是将它传输到网络中的另一台计算机上以实现通讯。这个将程序数据转化成能被存储并传输的格式的过程被称为“序列化”（Serialization），而它的逆过程则可被称为“反序列化”（Deserialization）。 简单来说，序列化就是将对象实例的状态转换为可保持或传输的格式的过程。与序列化...
畅游C++ Boost Serialization 序列化
梦想博客
05-10 7746
畅游C++ Boost Serialization 序列化。使用案例详细了解Boost::Serialization存储C++对象。
c++序列化
05-24
C++ 序列化是将对象转换为字节流的过程，这样可以将对象存储到磁盘或网络中，并在需要时重新读取。以下是一个简单的示例： ```c++ #include <iostream> #include <fstream> #include <string> class Person { public: Person() = default; Person(std::string name, int age) : m_name(name), m_age(age) {} std::string getName() const { return m_name; } int getAge() const { return m_age; } friend std::ostream& operator<<(std::ostream& os, const Person& p) { os << "Name: " << p.m_name << ", Age: " << p.m_age << std::endl; return os; } friend std::istream& operator>>(std::istream& is, Person& p) { is >> p.m_name >> p.m_age; return is; } private: std::string m_name; int m_age; }; int main() { // 创建 Person 对象 Person p1("Tom", 30); // 将对象序列化写入文件 std::ofstream ofs("person.dat", std::ios::binary); ofs.write(reinterpret_cast<const char*>(&p1), sizeof(p1)); ofs.close(); // 从文件中读取序列化的对象 std::ifstream ifs("person.dat", std::ios::binary); Person p2; ifs.read(reinterpret_cast<char*>(&p2), sizeof(p2)); ifs.close(); std::cout << p2; return 0; } ``` 在这个示例中，我们定义了一个名为 `Person` 的类，它有两个成员变量：姓名和年龄。我们还重载了输入输出运算符，以便我们可以将对象输出到控制台或从控制台读取对象。 在 `main` 函数中，我们首先创建一个 `Person` 对象 `p1`，然后将其序列化写入名为 `person.dat` 的二进制文件中。接下来，我们从文件中读取序列化的对象并将其存储在 `p2` 中。最后，我们将 `p2` 输出到控制台。 请注意，在将对象写入文件时，我们使用了 `reinterpret_cast` 将指向 `Person` 对象的指针转换为 `char` 指针。同样，在从文件读取对象时，我们也使用了 `reinterpret_cast` 将 `char` 指针转换为 `Person` 对象指针。这是因为我们正在处理字节流，而不是对象本身。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值