C++笔记_序列化与反序列化

于 2025-06-16 13:52:43 发布
阅读量178 收藏 5
点赞数 11
CC 4.0 BY-SA版权
分类专栏： C++学习日记 文章标签： c++ 笔记 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mounmory/article/details/148689678

序列化与反序列化 StreamBuffer 类

1、概述作用

在网络数据传输与数据存储中，经常涉及到C++数据到二进制数据的转换。这里设计一个StreamBuffer 类，使用操作符<<及>>完成C++数据与二进制数据的转换。

2、使用示例

自定义一个结构体Mydata，包含int、string、float和枚举成员，定义接口marshal将成员数据序列化成二进制数据，定义unmarshal接口，将二进制数反序列化成成员数据。

#include "StreamBuffer.hpp"
#include <iostream>

enum class EM_TEST :int16_t
{
	TYPE_1,
	TYPE_2,
	TYPE_3
};

struct Mydata// :public mmrUtil::IDealByStream<std::string>
{
	Mydata() = default;
	Mydata(std::string str1, int n, float f, std::string str2, EM_TEST emTest)
		: strValue1(std::move(str1))
		, nValue(n)
		, fValue(f)
		, strValue2(std::move(str2))
		, emTest(emTest)
	{
	}

	std::string strValue1;
	int nValue;
	float fValue;
	std::string strValue2;
	EM_TEST emTest;//枚举值

	void marshal(mmrUtil::StreamBuffer& dataStream) const
	{
		dataStream << strValue1;
		dataStream << nValue;
		dataStream << fValue;
		dataStream << strValue2;
		dataStream << emTest;
	}

	void unmarshal(mmrUtil::StreamBuffer& dataStream)
	{
        //通常需要对数据做一些校验，并且保证反序列化数据与序列化书序严格一致
		dataStream >> strValue1;
		dataStream >> nValue;
		dataStream >> fValue;
		dataStream >> strValue2;
		dataStream >> emTest;
	}
};

int main()
{	//复制数据到byte
	char transData[1024] = { 0 };
	int byteLen = 0;
	//数据序列化二进制保存
	{
		mmrUtil::StreamBuffer dataMarshal;
		Mydata dataTest = { "你好",5,2.5,"hello" ,EM_TEST::TYPE_2 };
		std::cout << "origin data is " << dataTest.strValue1 << " " << dataTest.nValue << " " << dataTest.fValue << " " << dataTest.strValue2 << " " << static_cast<int>(static_cast<int16_t>(dataTest.emTest)) << std::endl;
		dataTest.marshal(dataMarshal);
		byteLen = dataMarshal.dataSize();
		memcpy(transData, dataMarshal.getStartPtr(), byteLen);
	}

	//反序列化
	{
		//使用vector<char类型>
		mmrUtil::StreamBuffer dataUnmarshal(transData, byteLen);

		Mydata dataTrans;
		dataTrans.unmarshal(dataUnmarshal);
		std::cout << "unmarshal data is "
			<< dataTrans.strValue1 << " "
			<< dataTrans.nValue << " "
			<< dataTrans.fValue << " "
			<< dataTrans.strValue2 << " "
			<< static_cast<int16_t>(dataTrans.emTest)
			<< std::endl;
	}

	std::cout << "输入任意字符继续..." << std::endl;
	std::cin.get();
	return 0;
}

3、StreamBuffer 类源码及说明

/**
 * @file SteramBuffer.h
 * @brief
 * @author Mounmory (237628106@qq.com) https://github.com/Mounmory
 * @date
 *
 *
 */

#ifndef MMR_UTIL_STREAM_BUGGER_H
#define MMR_UTIL_STREAM_BUGGER_H

#include <string>
#include <memory>
#include <cstring>
#include <type_traits>
#include <functional>
#include <cassert>

 /*
	 可以处理数据流的buffer
 */

enum class emEndian //计算机大小端
{
	LITTLE = 1,
	BIG = 0
};


namespace mmrUtil
{

	class StreamBuffer
	{
		using BYTE = uint8_t;
	public:
		StreamBuffer(emEndian streamEndian = emEndian::LITTLE)
			: m_endianStream(streamEndian)
		{
			initMachineEndian();
		}

		/*
			这个构造函数用于直接使用外部地址数据解析，仅限使用operator >> 将数据赋值给其他数据，指针生命周期由外部控制，确保在整个生命周期指针的有效性。
			即使调用其它接口也是内存安全的，若涉及导致重新分配内存，将拷贝地址上的数据然后丢弃这个地址
		*/
		StreamBuffer(void* buffer, uint32_t length, emEndian streamEndian = emEndian::LITTLE)
			: m_endianStream(streamEndian)
			, m_ptrStart((BYTE*)buffer)//只赋值指针和写位置
			, m_ulWritePos(length)
		{
			initMachineEndian();
		}

		StreamBuffer(const StreamBuffer&) = delete;

		StreamBuffer(StreamBuffer&& rhs)
			: m_endianStream(rhs.m_endianStream)
			, m_endianLocal(rhs.m_endianLocal)
			, m_ulReadPos(std::exchange(rhs.m_ulReadPos, 0))
			, m_ulWritePos(std::exchange(rhs.m_ulWritePos, 0))
			, m_ptrStart(std::exchange(rhs.m_ptrStart, nullptr))
			, m_ulCapacity(std::exchange(rhs.m_ulCapacity, 0))
			, m_ptrBuf(std::exchange(rhs.m_ptrBuf, nullptr)) { }

		//拷贝赋值函数
		StreamBuffer& operator = (const StreamBuffer&) = delete;

		//移动赋值函数
		StreamBuffer& operator = (StreamBuffer&& rhs)
		{
			if (this != &rhs)
			{
				m_ulReadPos = std::exchange(rhs.m_ulReadPos, 0);
				m_ulWritePos = std::exchange(rhs.m_ulWritePos, 0);
				m_ptrStart = std::exchange(rhs.m_ptrStart, nullptr);
				m_ulCapacity = std::exchange(rhs.m_ulCapacity, 0);
				m_ptrBuf = std::exchange(rhs.m_ptrBuf, nullptr);
			}
			return *this;
		}

		//模板函数，将基本数字数据类型序列化
		template<typename _Ty>
		typename std::enable_if<std::is_arithmetic<_Ty>::value && std::is_same<std::decay_t<_Ty>, _Ty>::value, StreamBuffer&>::type
			operator << (_Ty data)
		{
			static constexpr uint32_t dataSize = sizeof(_Ty);
			BYTE* ptrData = reinterpret_cast<BYTE*>(&data);
			doFlip(ptrData, dataSize);
			writeBuf(ptrData, dataSize);
			return *this;
		}

		//模板函数，自定义枚举数据类型序列化
		template<typename _Ty>
		typename std::enable_if<std::is_enum<_Ty>::value && std::is_same<std::decay_t<_Ty>, _Ty>::value, StreamBuffer&>::type
			operator << (_Ty data)
		{
			using Type = std::underlying_type_t<_Ty>;
			(*this) << static_cast<Type>(data);
			return *this;
		}

		//模板函数，对基本数字数据类型反序列化
		template<typename _Ty>
		typename std::enable_if<std::is_arithmetic<_Ty>::value && std::is_same<std::decay_t<_Ty>, _Ty>::value, StreamBuffer&>::type
			operator >> (_Ty& data)
		{
			static constexpr uint32_t dataSize = sizeof(_Ty);
			BYTE* ptrData = reinterpret_cast<BYTE*>(&data);
			readBuf(ptrData, dataSize);
			doFlip(ptrData, dataSize);
			return *this;
		}

		//模板函数，对枚举数据类型反序列化
		template<typename _Ty>
		typename std::enable_if<std::is_enum<_Ty>::value && std::is_same<std::decay_t<_Ty>, _Ty>::value, StreamBuffer&>::type
			operator >> (_Ty& data)
		{
			using Type = std::underlying_type_t<_Ty>;
			(*this) >> (*reinterpret_cast<Type*>(&data));
			return *this;
		}

		//对string类型序列化
		StreamBuffer& operator << (const std::string& strData)
		{
			uint32_t ulSize = strData.size();
			(*this) << ulSize;
			writeBuf(strData.data(), ulSize);
			return *this;
		}

		//对string类型反序列化
		StreamBuffer& operator >> (std::string& strData)
		{
			uint32_t ulSize;
			(*this) >> ulSize;
			assert(m_ulWritePos >= m_ulReadPos + ulSize);
			strData.resize(ulSize);
			readBuf(const_cast<char*>(strData.data()), ulSize);
			return *this;
		}

		//设置内存空间大小
		void setCapacity(uint32_t length)
		{
			if (length > m_ulCapacity)
			{
				m_ulCapacity = length;
				auto ptrNe = std::unique_ptr<BYTE, std::function<void(BYTE*)>>(new BYTE[m_ulCapacity], [](BYTE* ptr) {delete[] ptr; });
				memcpy(ptrNe.get(), m_ptrStart, m_ulWritePos);
				m_ptrBuf = std::move(ptrNe);
				m_ptrStart = m_ptrBuf.get();
			}
		}

		//获取当前写位置，并在外部进行内存写入
		BYTE* getWritePosAndWrite(uint32_t length)
		{
			checkBufCapacity(m_ulWritePos + length);
			m_ulWritePos += length;
			return (m_ptrStart + m_ulWritePos - length);
		}

		//获取当前读位置，并在外部读取数据
		BYTE* getReadPosAndRead(uint32_t length)
		{
			m_ulReadPos += length;
			assert(m_ulWritePos >= m_ulReadPos);
			return (m_ptrStart + m_ulReadPos - length);
		}

		//如果数据流大小端与本地大小端不一致，进行字节序翻转
		void doFlip(BYTE* buffer, uint32_t dataSize)
		{
			if (m_endianStream != m_endianLocal && dataSize >= 2)
			{
				BYTE* start = buffer;
				BYTE* end = buffer + (dataSize - 1);
				while (start < end)
				{
					std::swap(*start, *end);
					++start;
					--end;
				}
			}
		}

		//清空数据（读写位置）
		void clear()
		{
			m_ulReadPos = 0;
			m_ulWritePos = 0;
		}

		//内部数据大小
		uint32_t dataSize() { return (m_ulWritePos - m_ulReadPos); }

		//获取内存空间大小
		uint32_t getCapacity()const { return m_ulCapacity; }

		//内存数据起始位置
		BYTE* getStartPtr()const { return m_ptrStart; }

		//从StreamBuffer读取数据位置
		uint32_t getReadPos()const { return m_ulReadPos; }

		//向StreamBffer写数据位置
		uint32_t getWritePos()const { return m_ulWritePos; }
	private:
		//将数据写到StreamBuffer
		void writeBuf(const void* buffer, uint32_t length)
		{
			checkBufCapacity(m_ulWritePos + length);
			memcpy(m_ptrStart + m_ulWritePos, buffer, length);
			m_ulWritePos += length;
		}

		//从StreamBuffer读数据
		void readBuf(void* buffer, uint32_t length)
		{
			memcpy(buffer, m_ptrStart + m_ulReadPos, length);
			m_ulReadPos += length;
			assert(m_ulWritePos >= m_ulReadPos);
		}

		//检查内存空间是否够用
		void checkBufCapacity(uint32_t length)
		{
			if (length > m_ulCapacity)
			{
				setCapacity(2 * length);
			}
		}

		//初始化本地大小端
		void initMachineEndian()//初始化本地大小端Endian
		{
			long one(1);
			char e = (reinterpret_cast<char*>(&one))[0];
			(e == (char)1) ? m_endianLocal = emEndian::LITTLE : m_endianLocal = emEndian::BIG;
		}
	private:
		const emEndian m_endianStream;//数据流的的大小端
		emEndian m_endianLocal;//本地计算机大小端

		//内部数据处理相关
		uint32_t m_ulReadPos = 0;//buf读位置
		uint32_t m_ulWritePos = 0;//buf写位置
		BYTE* m_ptrStart = nullptr;//内部数据起始地址
		uint32_t m_ulCapacity = 0;//buf总空间大小
		std::unique_ptr<BYTE, std::function<void(BYTE*)>> m_ptrBuf = nullptr;//内部数据分配的内存地址指针
	};

}
#endif

4、特点分析

相比JSON/XML等通用格式，具有以下特点：

  • 转换速度更快
  • 支持类型更丰富
  • 内存占用更小
  • 非标准化方式，将二进制数据转换为C++数据时，要做好校验（类似ProtoBuf）

5、扩展

可以通过修改代码实现对一些C++标准容器的支持，如std::vector<int32_t>等

C++ 内存数据结构与二进制文件之间的序列化和反序列化
carbon06的博客
11-28 4918
许多后端检索server启动时候需要从文件加载到内存中构建索引，这个过程往往会消耗比较多的时间，通过提前将数据结构序列化为二进制文件，server 反序列化二进制文件的方式可以有效提升启动速度。
C++ 序列化和反序列化学习
CHYabc123456hh的博客
10-28 3359
定义 程序员在编写应用程序的时候往往需要将程序的某些数据存储在内存中，然后将其写入某个文件或是将它传输到网络中的另一台计算机上以实现通讯。这些过程将会涉及到程序数据转化成能被存储并传输的格式，因此被称为“序列化”（Serialization），而它的逆过程则可被称为“反序列化” （Deserialization） 简单来说，序列化就是将对象实例的状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它根据流重构对象。这两个过程结合起来，可以轻松地存储和传输数据。例如，可以序列化一个对象，然后使用
C++ 序列化和反序列化
热门推荐
JMW1407的博客
07-07 1万+
序列化序列化1、背景2、定义3、序列化评价指标4、序列化实例参考 序列化 1、背景 1、在TCP的连接上，它传输数据的基本形式就是二进制流，也就是一段一段的1和0。 2、在一般编程语言或者网络框架提供的API中，传输数据的基本形式是字节，也就是Byte。一个字节就是8个二进制位，8个Bit。 二进制流和字节流本质上是一样的。对于我们编写的程序来说，它需要通过网络传输的数据是结构化的数据，比如，一条命令、一段文本或者一条消息。对应代码中，这些结构化的数据都可以用一个类或者一个结构体来表示。 序
c++序列化以及反序列化实现
麦田里的守望者
06-10 2077
序列化就是将内存中运行的程序中的数据存储到中，使其能够持久化存在电脑中，就算程序停止，这些数据也能一直存在。、顾名思义，也就是序列化的反操作，就是将已经存在磁盘文件中的数据读取到程序中继续使用的这么一个操作。 写在最后 欢迎大家关注鄙人的公众号【麦田里的守望者zhg】，让我们一起成长，谢谢。我的博客...
c++ 序列化和反序列化
小麦大大博客
11-20 2415
1. 什么是序列化？ 程序猿在编写应用程序的时候往往须要将程序的某些数据存储在内存中，然后将其写入某个文件或是将它传输到网络中的还有一台计算机上以实现通讯。这个将程序数据转化成能被存储并传输的格式的过程被称为“序列化”（Serialization），而它的逆过程则可被称为“反序列化”（Deserialization）。 简单来说，序列化就是将对象实例的状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它依据流重构对象。这两个过程结合起来，能够轻松地存储和数据传输。比如，能够序列化一个对象，然
Json序列化和反序列化 笔记
呵呵哒!的博客
02-01 430
跟着施磊老师学C++
【OpenCV C++20 学习笔记】序列化——XML和YAML文件处理
TeamLee的博客
07-26 716
本文介绍了在OpenCV中对数据对象进行序列化和反序列化的常用方法，包括基本类型、map、数组和自定义数据类型的序列化和反序列化
学习笔记01-序列化与反序列化
wangyz_008的博客
10-26 228
序列化与反序列化 C/C++中实现手工序列化 调用MFC框架实现序列化和反序列化
搜狗workflow——C++并行计算与异步网络引擎 序列化与反序列化 代码分析（四）
wadaxinoli的博客
10-28 294
二.代码分析 namespace protocol { class TutorialMessage : public ProtocolMessage { private: virtual int encode(struct iovec vectors[], int max); virtual int append(const void *buf, size_t size); public: int set_message_body(const void *body, size_t
搜狗workflow——C++并行计算与异步网络引擎 序列化与反序列化 代码分析（一）
wadaxinoli的博客
10-05 858
一. 简单介绍序列化与反序列化 对象的序列化（Serialization），即把一个对象以流的方式，写入到文件中保存，叫写对象，也叫对象序列化，对象中包含的不仅仅是字符，使用字节流。 对象的反序列化（deserailization），即把文件中保存的对象，以流的方式读取出来，叫做读取对象，也叫对象的反序列。读取的文件保存的都是字节，使用字节流。 对象序列化的作用：在传递,和保存对象(object)的时候,保证对象的完整性和可传递性。 在翻看其它...
C++ JSON 序列化与反序列化
06-22
C++ JSON 序列化与反序列化 相关的博客文章见：http://blog.csdn.net/TragicGuy
C++ 中的序列化和反序列化
最新发布
2302_81041084的博客
12-17 780
在 C++ 中，序列化是将对象转换为字节流的过程，反序列化则是从字节流重新构建对象的过程。std::cerr << "无法打开文件进行Boost反序列化。栈对象：在函数内部定义的对象，当程序执行到对象定义处时，会调用对象的构造函数进行创建。栈对象：当栈对象所在的代码块结束时，对象的析构函数会被自动调用，用于清理对象占用的资源。是一个栈对象，它的生命周期从定义处开始，到所在的代码块结束（如函数返回）。使用：在对象的生命周期内，可以通过对象的成员函数访问和修改对象的状态，就像。
C++：序列化和反序列化知识和代码
qq_38409301的博客
04-02 970
它在此过程中，先将对象的公共字段和私有字段以及类的名称（包含类所在的程序集）转换为字节流，然后再把字节流写入数据流。basic_binary、basic_text、basic_xml、binary_oarchive、polymorphic_iarchive、text_iarchive、xml_iarchive这几种。可用于数据序列化与反序列化。（2）Boost.Serialization能够创建或重建程序中的等效结构，并保存为二进制数据、文本数据、XML或者实用户自己定义的其它文件。
手撕代码: C++实现数据的序列化和反序列化
红军不怕远征难，万水千山只等闲
04-24 3523
在C++应用程序中，经常会涉及到对一些数据进行序列化和反序列化的处理。序列化可以将一个对象转换为一串字节流，这样就可以将其存储在硬盘上或者通过网络传输到其他设备上。而反序列化则是将这些字节流解析成原始的对象。 在Qt中，数据的序列化和反序列化可以使用QDataStream类来完成。QDataStream是一个方便的Qt类，它可以将基本数据类型、Qt数据类型以及用户定义的数据类型都进行序列化和反序列化。在使用QDataStream进行序列化时，需要指定一个QIODevice类的子类（例如QF
C++的序列化和反序列化
路过的熊的博客
09-24 502
C++的序列化和反序列化
C++中序列化和反序列化
道亦无名
12-26 818
需要注意的是，这个示例中的序列化和反序列化方法很简单，只适用于基本类型和简单的结构体。对于更复杂的数据类型，如类或数组，你可能需要实现自定义的序列化和反序列化方法。此外，为了确保数据的完整性和安全性，你可能还需要添加错误处理和加密等额外的功能。在C++中，序列化和反序列化是指将数据转换为字节流或从字节流中恢复数据的过程。C++标准库中没有提供序列化和反序列化的直接支持，但你可以使用第三方库或自己编写代码来实现这个功能。函数中，我们演示了如何使用这两个函数进行序列化和反序列化整数。函数将一个对象写入到。
C++实现结构体序列化和反序列化
qq_55967171的博客
10-30 3661
序列化：就是将对象转化成字节序列的过程。反序列化：就是讲字节序列转化成对象的过程。对象序列化成的字节序列会包含对象的类型信息、对象的数据等，说白了就是包含了描述这个对象的所有信息，能根据这些信息“复刻”出一个和原来一模一样的对象。简单的来说结构体序列化就是将这个结构体里的数据转成一段通用的数据，另一个同类型结构体拿到这段数据后可以反序列化拿到每个结构体成员的值。上述代码中将a的数据拷贝到b，当然像A这样简单的结构体直接=就能进行拷贝了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值