极简风格快速处理序列化与反序列化 C++ 11 C++20

已于 2024-02-18 15:20:56 修改
阅读量498 收藏 10
点赞数 7
分类专栏： 实战项目C++ 文章标签： c++ c++20 开发语言
于 2024-02-18 15:03:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010872708/article/details/136130883
版权

市面开源库序列化二进制库太多、各种功能强大、使用也比较繁琐。实际项目中使用的功能很少。

内存与维护消耗比较重。

极简使用方式。

一、测试代码：

#include "Serialize.h"
#include <limits>
#include <iostream>

void main()
{
	unsigned char ucValue = (std::numeric_limits<unsigned char>::max)();
	short sValue = (std::numeric_limits<short>::max)();
	unsigned short usValue = (std::numeric_limits<unsigned short>::max)();
	int iValue = (std::numeric_limits<int>::max)();
	unsigned int uiValue = (std::numeric_limits<unsigned int>::max)();
	long long llValue = (std::numeric_limits<long long>::max)();
	unsigned long long ullValue = (std::numeric_limits<unsigned long long>::max)();
	float fValue = (std::numeric_limits<float>::max)();
	double dValue = (std::numeric_limits<double>::max)();
	bool bValue = (std::numeric_limits<bool>::max)();

	std::string stds = "test Serialize std::string";
	std::string stdsw = "test Serialize std::wstring";

	Serialize ar;
	ar << ucValue << sValue << usValue << iValue << uiValue << llValue 
	   << ullValue << fValue << dValue << bValue << stds << stdsw;

	std::cout << "src:" << ucValue << " " << sValue << " " << usValue << " " << iValue << " " << uiValue << " " << llValue << " "
		<< ullValue << " " << fValue << " " << dValue << "\n\t" << bValue << " " << stds << " " << stdsw << "\n";

	UnSerialize unAr(ar.str());

	unsigned char uc = 0;
	short s;
	unsigned short us;
	int i = 0;
	unsigned int ui = 0;
	long long ll = 0;
	unsigned long long ull = 0;
	float f = 0.0f;
	double d = 0.0f;
	bool b = false;
	std::string s1 = "";
	std::string s2 = "";
	unAr >> uc >> s >> us >> i >> ui >> ll >> ull >> f >> d >> b >> s1 >> s2;

	std::cout << "dst:" << uc << " " << s << " " << us << " " << i << " " << ui << " " << ll << " "
		<< ull << " " << f << " " << d << "\n\t" << b << " " << s1 << " " << s2 << "\n";
}

二、运行结果:

三、Serialize （序列化）

class Serialize final
{
public:
	void ClearBuffer();

	//Serialize& operator<<(char value); C++中大量使用std::string 删除此实现
	Serialize& operator<<(unsigned char value);
	Serialize& operator<<(short value);
	Serialize& operator<<(unsigned short value);
	Serialize& operator<<(int value);
	Serialize& operator<<(unsigned int value);
	Serialize& operator<<(long long value);
	Serialize& operator<<(unsigned long long value);
	Serialize& operator<<(float value);
	Serialize& operator<<(double value);
	Serialize& operator<<(const std::string& value);
	Serialize& operator<<(const std::wstring& value);
	Serialize& operator<<(bool value);

	template <typename T>
	Serialize& Make(T value)
	{
		m_sBuf.sputn((char*)&value, sizeof(T));
		return (*this);
	}

	std::string str();

	int len();

private:
	std::stringbuf m_sBuf;
};

四、UnSerialize (反序列化)

class UnSerialize final
{
public:
	UnSerialize(const std::string& sSrc);

	//UnSerialize& operator>>(char& value); C++中大量使用std::string 删除此实现
	UnSerialize& operator>>(unsigned char& value);
	UnSerialize& operator>>(short& value);
	UnSerialize& operator>>(unsigned short& value);
	UnSerialize& operator>>(int& value);
	UnSerialize& operator>>(unsigned int& value);
	UnSerialize& operator>>(long long& value);
	UnSerialize& operator>>(unsigned long long& value);
	UnSerialize& operator>>(float& value);
	UnSerialize& operator>>(double& value);
	UnSerialize& operator>>(std::string& value);
	UnSerialize& operator>>(std::wstring& value);
	UnSerialize& operator>>(bool& value);

	template <typename T>
	UnSerialize& Get(T& ret)
	{
		if (!bSuccess)
			return (*this);

		auto iRet = m_sBuf.sgetn((char*)&ret, sizeof(T));

		if (iRet != sizeof(T))
			bSuccess = false;

		return (*this);
	}

	bool bSuccess;	//解析数据是否成功
	int iLen;
private:
	std::stringbuf m_sBuf;
};

五、包装模板

template<class T>
class SerializeT
{
public:
	Serialize ar;
public:
	SerializeT() {}
	virtual ~SerializeT() {}

	std::string package()
	{
		serialize();
		return ar.str();
	}

	virtual void serialize() = 0;
};

template<class T>
class UnSerializeT
{
public:
	virtual ~UnSerializeT() {}

	virtual bool unPackage(UnSerialize& ar)
	{
		unSerialize(ar);
		return ar.bSuccess;
	}

protected:
	virtual void unSerialize(UnSerialize& ar) = 0;
};


class Test1 : public UnSerializeT<Test1>
{
private:
	int				iCmd=0x123456;
	int				iMagicNum=6;
public:
	virtual void unSerialize(UnSerialize& ar) override
	{
		ar >> iCmd >> iMagicNum;
	}
};


class Test2 : public SerializeT<Test2>
{
private:
	int				iCmd = 0x654321;
	int				iMagicNum = 6;
public:
	int				iClientHeartbeatId = 0;
	virtual void serialize() override
	{
		ar << iCmd << iMagicNum<< iClientHeartbeatId;
	}
};

六、具体实现


#include "Serialize.h"
#include <string.h>
#include <codecvt>

Serialize& Serialize::operator<<(unsigned char value)
{
	m_sBuf.sputn((char*)&value, sizeof(unsigned char));
	return (*this);
}

Serialize& Serialize::operator<<(short value)
{
	char tmp[2] = { 0 };
	tmp[0] = (char)(((value & 0xff00) >> 8) & 0xff);
	tmp[1] = (char)((value & 0x00ff) & 0xff);
	m_sBuf.sputn((char*)&tmp, 2);
	return (*this);
//	return Make<short>(value);
}

Serialize& Serialize::operator<<(unsigned short value)
{
	char tmp[2] = { 0 };
	tmp[0] = (char)(((value & 0xff00) >> 8) & 0xff);
	tmp[1] = (char)((value & 0x00ff) & 0xff);
	m_sBuf.sputn((char*)&tmp, 2);
	return (*this);
//	return Make<unsigned short>(value);
}

Serialize& Serialize::operator<<(int value)
{
	char tmp[4] = { 0 };
	tmp[0] = (char)(((value & 0xff000000) >> 24) & 0xff);
	tmp[1] = (char)(((value & 0x00ff0000) >> 16) & 0xff);
	tmp[2] = (char)(((value & 0x0000ff00) >> 8) & 0xff);
	tmp[3] = (char)((value & 0x000000ff) & 0xff);
	m_sBuf.sputn((char*)&tmp, 4);
	return (*this);
	//return Make<int>(value);
}

Serialize& Serialize::operator<<(unsigned int value)
{
	char tmp[4] = { 0 };
	tmp[0] = (char)(((value & 0xff000000) >> 24) & 0xff);
	tmp[1] = (char)(((value & 0x00ff0000) >> 16) & 0xff);
	tmp[2] = (char)(((value & 0x0000ff00) >> 8) & 0xff);
	tmp[3] = (char)((value & 0x000000ff) & 0xff);
	m_sBuf.sputn((char*)&tmp, 4);

	return (*this);
//	return Make<unsigned int>(value);
}

Serialize& Serialize::operator<<(long long value)
{
	//return Make<long long>(value);
	char tmp[8] = { 0 };
	tmp[0] = (char)(((value & 0xff00000000000000) >> 56) & 0xff);
	tmp[1] = (char)(((value & 0x00ff000000000000) >> 48) & 0xff);
	tmp[2] = (char)(((value & 0x0000ff0000000000) >> 40) & 0xff);
	tmp[3] = (char)(((value & 0x000000ff00000000) >> 32) & 0xff);

	tmp[4] = (char)(((value & 0x00000000ff000000) >> 24) & 0xff);
	tmp[5] = (char)(((value & 0x0000000000ff0000) >> 16) & 0xff);
	tmp[6] = (char)(((value & 0x000000000000ff00) >> 8) & 0xff);
	tmp[7] = (char)((value & 0x00000000000000ff) & 0xff);
	m_sBuf.sputn((char*)&tmp, 8);

	return (*this);
}

Serialize& Serialize::operator<<(unsigned long long value)
{
//	return Make<unsigned long long>(value);
	char tmp[8] = { 0 };
	tmp[0] = (char)(((value & 0xff00000000000000) >> 56) & 0xff);
	tmp[1] = (char)(((value & 0x00ff000000000000) >> 48) & 0xff);
	tmp[2] = (char)(((value & 0x0000ff0000000000) >> 40) & 0xff);
	tmp[3] = (char)(((value & 0x000000ff00000000) >> 32) & 0xff);

	tmp[4] = (char)(((value & 0x00000000ff000000) >> 24) & 0xff);
	tmp[5] = (char)(((value & 0x0000000000ff0000) >> 16) & 0xff);
	tmp[6] = (char)(((value & 0x000000000000ff00) >> 8) & 0xff);
	tmp[7] = (char)((value & 0x00000000000000ff) & 0xff);
	m_sBuf.sputn((char*)&tmp, 8);

	return (*this);
}

Serialize& Serialize::operator<<(float value)
{
	return Make<float>(value);
}

Serialize& Serialize::operator<<(double value)
{
	return Make<double>(value);
}

Serialize& Serialize::operator<<(const std::string& value)
{
	int len = (int)value.length();
	(*this) << len;
	//int iCount = value.length();
	//m_sBuf.sputn((char*)&iCount, sizeof(int));
	m_sBuf.sputn(value.c_str(), len);

	return (*this);
}

Serialize& Serialize::operator<<(const std::wstring& value)
{
	std::wstring_convert<std::codecvt_utf8<wchar_t>> conv;
	auto sData = conv.to_bytes(value);

	int len = (int)sData.length();
	(*this) << len;

	m_sBuf.sputn(sData.c_str(), len);

	return (*this);
}

Serialize& Serialize::operator<<(bool value)
{
	unsigned short usShort = value ? 1 : 0;
	(*this) << usShort;

	return (*this);
	//	return Make<unsigned short>(usShort);
}

std::string Serialize::str()
{
	return m_sBuf.str();
}

int Serialize::len()
{
	return (int)m_sBuf.str().length();
}

void Serialize::ClearBuffer()
{
	m_sBuf.str("");
}

UnSerialize::UnSerialize(const std::string& sSrc)
	:m_sBuf(sSrc, std::ios_base::in)
	, iLen((int)sSrc.length())
{
	bSuccess = true;
}

UnSerialize& UnSerialize::operator >> (unsigned char& value)
{
	if (!bSuccess)
		return (*this);

	auto iRet = m_sBuf.sgetn((char*)&value, 1);
	if (iRet != 1) {
		bSuccess = false;
		return (*this);
	}
	return (*this);
//	return Get<unsigned char>(value);
}

UnSerialize& UnSerialize::operator >> (short& value)
{
	if (!bSuccess)
		return (*this);

	char tmp[2] = { 0 };
	auto iRet = m_sBuf.sgetn((char*)&tmp, 2);
	if (iRet != 2) {
		bSuccess = false;
		return (*this);
	}
	int i1 = (((char)tmp[0]) << 8) & 0xFF00;
	int i2 = ((char)tmp[1]) & 0x00FF;
	int ret = i1 | i2 ;
	value = ret;
	return (*this);
//	return Get<short>(value);
}

UnSerialize& UnSerialize::operator >> (unsigned short& value)
{
	if (!bSuccess)
		return (*this);

	char tmp[2] = { 0 };
	auto iRet = m_sBuf.sgetn((char*)&tmp, 2);
	if (iRet != 2) {
		bSuccess = false;
		return (*this);
	}
	int i1 = (((char)tmp[0]) << 8) & 0xFF00;
	int i2 = ((char)tmp[1]) & 0x00FF;
	int ret = i1 | i2;
	value = ret;
	return (*this);
//	return Get<unsigned short>(value);
}

UnSerialize& UnSerialize::operator >> (int& value)
{
	if (!bSuccess)
		return (*this);

	char tmp[4] = { 0 };
	auto iRet = m_sBuf.sgetn((char*)&tmp, 4); 
	if (iRet != 4) 
	{
		bSuccess = false;
		return (*this);
	}

	int i1 = (((char)tmp[0]) << 24)&0xFF000000;
	int i2 = (((char)tmp[1]) << 16)&0x00FF0000;
	int i3 = (((char)tmp[2]) << 8)& 0x0000FF00;
	int i4 = ((char)tmp[3])& 0x000000FF;
	//int ret = (int)(((byte)tmp[0] << 24 )| ((char)tmp[1] << 16 )| ((char)tmp[2] << 8) | ((char)tmp[3]));
	int ret = i1 | i2 | i3 | i4;
	value = ret;
	return (*this);
	//return Get<int>(value);
}

UnSerialize& UnSerialize::operator >> (unsigned int& value)
{
	if (!bSuccess)
		return (*this);

	char tmp[4] = { 0 };
	auto iRet = m_sBuf.sgetn((char*)&tmp, 4);
	if (iRet != 4) {
		bSuccess = false;
		return (*this);
	}
	int i1 = (((char)tmp[0]) << 24) & 0xFF000000;
	int i2 = (((char)tmp[1]) << 16) & 0x00FF0000;
	int i3 = (((char)tmp[2]) << 8) & 0x0000FF00;
	int i4 = ((char)tmp[3]) & 0x000000FF;
	//int ret = (int)(((byte)tmp[0] << 24 )| ((char)tmp[1] << 16 )| ((char)tmp[2] << 8) | ((char)tmp[3]));
	int ret = i1 | i2 | i3 | i4;
	value = ret;
	return (*this);
//	return Get<unsigned int>(value);
}

UnSerialize& UnSerialize::operator>>(long long& value)
{
	if (!bSuccess)
		return (*this);

	char tmp[8] = { 0 };
	auto iRet = m_sBuf.sgetn((char*)&tmp, 8);
	if (iRet != 8) 
	{
		bSuccess = false;
		return (*this);
	}

	long long i1 = (((long long)tmp[0]) << 56) & 0xFF00000000000000;
	long long i2 = (((long long)tmp[1]) << 48) & 0x00FF000000000000;
	long long i3 = (((long long)tmp[2]) << 40) & 0x0000FF0000000000;
	long long i4 = (((long long)tmp[3]) << 32) & 0x000000FF00000000;

	long long i5 = (((long long)tmp[4]) << 24) & 0x00000000FF000000;
	long long i6 = (((long long)tmp[5]) << 16) & 0x0000000000FF0000;
	long long i7 = (((long long)tmp[6]) << 8) & 0x000000000000FF00;
	long long i8 = ((long long)tmp[7]) & 0x00000000000000FF;
	//int ret = (int)(((byte)tmp[0] << 24 )| ((char)tmp[1] << 16 )| ((char)tmp[2] << 8) | ((char)tmp[3]));
	long long ret = i1 | i2 | i3 | i4 | i5 | i6 | i7 | i8;
	value = ret;
	return (*this);
	//return Get<long long>(value);
}

UnSerialize& UnSerialize::operator>>(unsigned long long& value)
{
	if (!bSuccess)
		return (*this);

	char tmp[8] = { 0 };
	auto iRet = m_sBuf.sgetn((char*)&tmp, 8);
	if (iRet != 8) 
	{
		bSuccess = false;
		return (*this);
	}
	
	unsigned long long i1 = (((unsigned long long)tmp[0]) << 56) & 0xFF00000000000000;
	unsigned long long i2 = (((unsigned long long)tmp[1]) << 48) & 0x00FF000000000000;
	unsigned long long i3 = (((unsigned long long)tmp[2]) << 40) & 0x0000FF0000000000;
	unsigned long long i4 = (((unsigned long long)tmp[3]) << 32) & 0x000000FF00000000;

	unsigned long long i5 = (((unsigned long long)tmp[4]) << 24) & 0x00000000FF000000;
	unsigned long long i6 = (((unsigned long long)tmp[5]) << 16) & 0x0000000000FF0000;
	unsigned long long i7 = (((unsigned long long)tmp[6]) << 8) & 0x000000000000FF00;
	unsigned long long i8 = ((unsigned long long)tmp[7]) & 0x00000000000000FF;
	//int ret = (int)(((byte)tmp[0] << 24 )| ((char)tmp[1] << 16 )| ((char)tmp[2] << 8) | ((char)tmp[3]));
	unsigned long long ret = i1 | i2 | i3 | i4 | i5 | i6 | i7 | i8;
	value = ret;
	return (*this);
	//return Get<unsigned long long>(value);
}

UnSerialize& UnSerialize::operator>>(float& value)
{
	return Get<float>(value);
}

UnSerialize& UnSerialize::operator>>(double& value)
{
	return Get<double>(value);
}

UnSerialize& UnSerialize::operator>>(std::string& value)
{
	int iCount = 0;
	//auto iRet = m_sBuf.sgetn((char*)&iCount, sizeof(int));
	(*this) >> iCount;
	if (iCount > 0)
	{
		char* buff = new char[iCount + 1];
		memset(buff, 0, iCount + 1);
		auto iRet = m_sBuf.sgetn(buff, iCount);
		value.assign(std::move(buff), iCount);
		delete[] buff;

		if (iRet != iCount)
			bSuccess = false;
	}

	return (*this);
}

UnSerialize& UnSerialize::operator>>(std::wstring& value)
{
	int iCount = 0;
	//auto iRet = m_sBuf.sgetn((char*)&iCount, sizeof(int));
	(*this) >> iCount;
	if (iCount > 0)
	{
		std::string sData;
		char* buff = new char[iCount + 1];
		memset(buff, 0, iCount + 1);
		auto iRet = m_sBuf.sgetn(buff, iCount);
		sData.assign(std::move(buff), iCount);
		delete[] buff;

		if (sData.length() > 0)
		{
			std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t> con;
			value = std::move(con.from_bytes(sData.data()));
		}

		if (iRet != iCount)
			bSuccess = false;
	}

	return (*this);
}

UnSerialize& UnSerialize::operator>>(bool& value)
{
	unsigned short usValue = 0;
	(*this) >> usValue;
	value = usValue ? true : false;
	return (*this);
}

【免费】极简风格快速处理序列化与反序列化C++11C++20测试及代码实现工程文件资源-CSDN文库

优秀会上瘾
关注
  • 7
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++学习笔记序列之经典处理程序汇总（不断更新中）
z_shaowu的专栏
08-04 505
经典处理程序汇总： 1.         字符串处理     While(*str) {        Statements++; //这里添加一些自己定义的语句        Str++; } 如： int c_in_str(const
二叉树的序列化和反序列化——C++
净无邪博客
12-15 2573
总体解题思想为先用层次遍历存储包括空节点的每个节点，存储是每个节点都存储左右子节点，如果节点为空，则存储"#,"，否则存储节点的值val，同时用逗号','分割每个节点内容，存储完后进行序列化string。反序列化则先按逗号','分割每个字符串为数组字符串vector<string> valStrArr，该valStrArr存储每个节点的值，包括空节点；然后遍历valStrArr，反向构建原始二叉树。反向构建二叉树时由于存储是按层次遍历存入的，所以反向遍历时也需要按照层次遍历依次将非空节点压栈和弹出栈。由于层
C++ 常用序列操作
huatian5的博客
11-25 1424
copy 将 src 的序列 拷贝到 dest 的一个位置 move 将 src 的序列 移动到 dest 的一个位置 fill 用 某值 填充 dest 序列 transform 将 src 的序列 拷贝运算到 dest 的一个位置 all_of 判断序列所有元素是否 在某操作 全为true remove 移除所有等于 某值 的元素 #include &amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;gt; #incl...
手撕代码: C++实现数据的序列化和反序列化
最新发布
红军不怕远征难，万水千山只等闲
04-24 2044
在C++应用程序中，经常会涉及到对一些数据进行序列化和反序列化的处理。序列化可以将一个对象转换为一串字节流，这样就可以将其存储在硬盘上或者通过网络传输到其他设备上。而反序列化则是将这些字节流解析成原始的对象。 在Qt中，数据的序列化和反序列化可以使用QDataStream类来完成。QDataStream是一个方便的Qt类，它可以将基本数据类型、Qt数据类型以及用户定义的数据类型都进行序列化和反序列化。在使用QDataStream进行序列化时，需要指定一个QIODevice类的子类（例如QF
C++序列化
zdsji的博客
05-26 503
借用c++元编程实现的序列化与反序列化，感谢大佬YaZi, B站Id: 天天写乱码, 提供的思路。
C++文件的序列化
Billy Jue的博客
12-10 1958
转载于：https://blog.csdn.net/freehyan/article/details/51814336 用于记录下 序列化(serializtion)是指把对象信息转换成可以存储或者通过网络连接传输格式的过程，然后在本地或者在另一个计算机环境中可以重构出原有的对象信息是指反序列化。 前言 本文只介绍通过boost serialization存储的优势，先通过例子简单明白。假如现在你是一个学校学生系统管理员，你需要保存学生信息，比如学生学好，名字，年龄。当然最简单的方式是通过C++的文
极简风格快速处理序列化与反序列化 C++ 11 C++20 测试及代码实现工程文件
02-18
本项目“极简风格快速处理序列化与反序列化 C++ 11 C++20 测试及代码实现工程文件”主要关注如何使用C++ 11和C++ 20标准来高效地处理这些问题。 C++ 11引入了许多现代特性，如类型推断（auto）、右值引用（rvalue ...
C++ JSON 序列化与反序列化
06-22
本篇文章将深入探讨C++中JSON的序列化与反序列化。 **一、JSON序列化** 序列化是指将C++的对象转换为JSON字符串的过程，以便在网络上传输或保存到文件中。常见的C++ JSON序列化库有RapidJSON、nlohmann/json、...
C++序列化和反序列化
03-10
函数API接口感受到非常不适应，你一定非常怀念使用java和C#对一个实体类的那么轻松加简单的直接json序列化，本篇博客使用一个RapidJsonHelper类，将帮你实现对一个C++实体类的的序列化和反序列化。rapidjson的版本是...
Visual C++中对象的序列化与文件I-O研究.rar_c++对象序列化_对象序列化_序列化
09-19
在C++编程中，对象序列化是一个重要的概念，它涉及到将程序中的对象状态转换为可以存储或传输的数据格式，如二进制或文本文件。这一过程通常用于持久化数据、跨进程通信或在网络上传输对象。在Visual C++环境下，...
serializeTest.rar
08-23
MFC的单文档程序中，用CArchive类实现自定义类的序列化，本实例用一个绘图程序实现一个序列化的过程
基于Protobuf C++ serialize到char*的实现方法分析
09-05
本篇文章是对Protobuf C++ serialize到char*的实现方法进行了详细的分析介绍。需要的朋友参考下
C++与序列化
weixin_43728590的博客
06-15 3795
协议/protobuf
[C++]两种常用C++序列化方案protobuf和boost serialization
FL1768317420的博客
03-16 782
对象序列化的好处在哪里？Boost库是个很庞大的库，功能非常丰富，序列化只是其中的一个小分支，但为了使用Boost的序列化方案，你需要安装整个Boost库，所花费的磁盘空间和时间都很多，同样支持的序列化功能也很强大，既支持二维数组（指针），也支持STL容器，更不需要我们用某种特殊的格式重新定义我们的类结构，其非侵入的性质使得我们无须改动已有的类结构即可序列化，这时非常赞的一个性质。但是由于体积庞大，安装复杂，如果只是简单的序列化，没必要使用该方案，只有protobuf不能满足你的需求时，才应该考虑该方案。
C++学习 优雅的实现对象到文件的序列化/反序列化 关键字serialize
CHYabc123456hh的博客
09-30 795
需要使用到序列化场景的需求 在写代码的过程中，经常会需要把代码层面的对象数据保存到文件，而这些数据会以各种格式存储．例如：json，xml，二进制等等．二进制，相比json，xml格式，直接把字节copy到硬盘，所以这实现起来相对容易． 例子 下面是一个简单的三维向量结构体，如何把它序列化到文件呢？ struct Vec3 { float x; float y; float z; } Vec3 v; v.x = 1.0f; v.y = 2.0f; v.z =
C++Boost序列化（Serialization）库教程（中文版）
weixin_38070782的博客
05-25 3269
一个非常简单的情形 非侵入的版本 可序列化的成员 派生类 指针 数组 STL容器 类的版本 把serialize拆分成save/load 档案 输出档案(archive)类似于输出数据流(stream)。数据能通过<< 或 & 操作符存储到档案(archive)中: ar << data; ar & data; 输入档案(archive)类似于输入数据流(stream)。数据能通过>> 或 & 操作符从档案(archi
C++ 序列化和反序列化
热门推荐
JMW1407的博客
07-07 1万+
序列化序列化1、背景2、定义3、序列化评价指标4、序列化实例参考 序列化 1、背景 1、在TCP的连接上，它传输数据的基本形式就是二进制流，也就是一段一段的1和0。 2、在一般编程语言或者网络框架提供的API中，传输数据的基本形式是字节，也就是Byte。一个字节就是8个二进制位，8个Bit。 二进制流和字节流本质上是一样的。对于我们编写的程序来说，它需要通过网络传输的数据是结构化的数据，比如，一条命令、一段文本或者一条消息。对应代码中，这些结构化的数据都可以用一个类或者一个结构体来表示。 序
C++序列化处理是什么意思？简单案例讲解
xcksj888的博客
10-20 132
这个例子中，`serialize`函数将`Person`对象的状态转换为字节流，存储在`std::stringstream`中。`deserialize`函数则将字节流恢复为`Person`对象的状态。C++序列化处理是将对象的状态转换为字节流的过程，以便于存储和传输。反序列化则是将字节流恢复为对象的状态。Person person("张三", 30);Deserialized: 张三，30。Serialized: 张三 30。
C++序列化与反序列化的简单探索
Kiritow的学园
11-11 1万+
C++序列化与反序列化 初步的探索~
C++对象数组序列化与反序列化详解
总结起来，本篇文档涵盖了C++中基于MFC的序列化和反序列化技术，以及CObArray等数组集合类的使用，这些技术对于开发需要持久化数据的C++应用程序至关重要。通过理解并熟练运用这些概念和方法，开发者能够有效地管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

优秀会上瘾

缺少的是时间,从来不是金钱.

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值