C++对象的JSON序列化与反序列化探索完结-列表的序列化与反序列化

最新推荐文章于 2024-08-10 15:17:40 发布
最新推荐文章于 2024-08-10 15:17:40 发布
阅读量6.5k 收藏 18
点赞数 2
分类专栏： C++ 文章标签： C++ JSON 对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TragicGuy/article/details/9174015
版权

在前两篇文章中，我们已经完成对普通对象以及复杂对象嵌套的序列化与反序列化，见如下地址：

C++对象的JSON序列化与反序列化探索

C++对象的JSON序列化与反序列化探索续-复杂对象的序列化与反序列化


经过一番折腾，总算把带有列表的对象的序列化完成了，目前支持 list 和 vector 的列表，以及自定义的其他类型的列表，我们可以先来看看实现的效果。

复杂对象及带列表对象的序列号主要有如下几种：

1. 普通的list列表，如:list<string>

	list<string> testList;
	testList.push_back("33333333");
	testList.push_back("55555555");
	tvalue = CJsonObjectBase::DoArraySerialize<list<string>>(&testList);
	out = CJsonObjectBase::JsonValueToString(tvalue);
	AfxMessageBox(out.c_str());
序列化结果为： 
["33333333","55555555"]

2. 复杂对象的列表，如list<CTestStru*>

Json::Value tvalue;
	std::string out;
	vector<CSubTestStruct*> testListSpecial;
	obj = new CSubTestStruct();
	obj->SubMsgID = 2;
	obj->SubMsgTitle = "333";
	testListSpecial.push_back(obj);
	obj = new CSubTestStruct();
	obj->SubMsgID = 3;
	obj->SubMsgTitle = "4444";
	testListSpecial.push_back(obj);	
	tvalue = CJsonObjectBase::DoArraySerialize<vector<CJsonObjectBase*>>((vector<CJsonObjectBase*>*)&testListSpecial);
	out = CJsonObjectBase::JsonValueToString(tvalue);
	AfxMessageBox(out.c_str());

[{"SubMsgID":2,"SubMsgTitle":"333"},{"SubMsgID":3,"SubMsgTitle":"4444"}]
此注需要注意的是，使用完毕后，一定要记得销毁列表中的对象： 

for (vector<CSubTestStruct*>::iterator it = testListSpecial.begin(); it != testListSpecial.end(); ++ it)
	{
		delete (*it);
	}
反序列化： 

void* GenerateTest(const string& name)
{
	return new CSubTestStruct(); 
}

CString strTest = "";
	string strTestEx = "[{\"SubMsgID\":2,\"SubMsgTitle\":\"2222\"},{\"SubMsgID\":4444,\"SubMsgTitle\":\"4444\"}]";
	Json::Reader reader;    
	Json::Value root;  
	if (reader.parse(strTestEx, root))  
	{
		vector<CSubTestStruct*> listObjTest;
		CJsonObjectBase::DoObjArrayDeSerialize<vector<CJsonObjectBase*>>("test", &listObjTest, root, GenerateTest);
		strTest.Format("count %d\r\nfirst subTitle:%s", listObjTest.size(), listObjTest.size() > 0 ? listObjTest[0]->SubMsgTitle.c_str() : "");
		AfxMessageBox(strTest);

		for (vector<CSubTestStruct*>::iterator it = listObjTest.begin(); it != listObjTest.end(); ++ it)
		{
			delete (*it);
		}
	}
打印结果： 

count 2
first subTitle:2222
3. 在对象中包含普通及复杂的列表，如下： 

struct CSubTestStruct : public CJsonObjectBase  
{  
	CSubTestStruct()  
	{  
		SubMsgID = 0;  
		SetPropertys();  
	}  
	
	ULONGLONG SubMsgID;  
	string SubMsgTitle;  
protected:  
	//子类需要实现此函数，并且将相应的映射关系进行设置   
	virtual void SetPropertys()  
	{  
		SetProperty("SubMsgID", asUInt64, &SubMsgID);  
		SetProperty("SubMsgTitle", asString, &SubMsgTitle);  
	}  
};  
struct CTestStruct : public CJsonObjectBase  
{  
	CTestStruct()  
	{  
		SetPropertys();  
	}  
	~CTestStruct()
	{
		for (vector<CSubTestStruct*>::iterator it = testListSpecial.begin(); it != testListSpecial.end(); ++ it)
		{
			delete (*it);
		}
	}
	ULONGLONG MsgID;  
	string MsgTitle;  
	string MsgContent;  
	CSubTestStruct subObj;  
	vector<INT> intList;
	list<string> testList;
	vector<CSubTestStruct*> testListSpecial;
protected:  
	CJsonObjectBase* GenerateJsonObjForDeSerialize(const string& propertyName)
	{
		if("testListSpecial" == propertyName)
		{
			return new CSubTestStruct();
		}
		return NULL;
	}
	//子类需要实现此函数，并且将相应的映射关系进行设置   
	virtual void SetPropertys()  
	{
		SetProperty("MsgID", asUInt64, &MsgID);  
		SetProperty("MsgTitle", asString, &MsgTitle);  
		SetProperty("MsgContent", asString, &MsgContent);  
		SetProperty("subObj", asJsonObj, &subObj);
		SetProperty("intList", asVectorArray, &intList);
	        SetProperty("testList", asListArray, &testList, asString);
	        SetProperty("testListSpecial", asVectorArray, &testListSpecial, asJsonObj);		
	} 	
};
序列化代码： 

CTestStruct stru;
	stru.MsgID = 11223344;
	stru.MsgTitle = "黑黑";
	stru.MsgContent = "哈哈";
	stru.testList.push_back("aaaa");
	stru.testList.push_back("bbbb");
	stru.intList.push_back(3333);
	CSubTestStruct* obj = new CSubTestStruct();
	obj->SubMsgID = 2;
	obj->SubMsgTitle = "333";
	stru.testListSpecial.push_back(obj);
	obj = new CSubTestStruct();
	obj->SubMsgID = 3;
	obj->SubMsgTitle = "4444";
	stru.testListSpecial.push_back(obj);
	CString strTest = stru.Serialize().c_str();
	AfxMessageBox(strTest);
打印结果： 

{"MsgContent":"哈哈","MsgID":11223344,"MsgTitle":"黑黑","intList":[3333],"subObj":{"SubMsgID":0,"SubMsgTitle":""},"testList":["aaaa","bbbb"],"testListSpecial":[{"SubMsgID":2,"SubMsgTitle":"333"},{"SubMsgID":3,"SubMsgTitle":"4444"}]}
反序列化代码： 

const char* pstr = "{\"MsgContent\":\"哈哈\",\"MsgID\":11223344,\"MsgTitle\":\"黑黑\",\"intList\":[3333],\"subObj\":{\"SubMsgID\":0,\"SubMsgTitle\":\"dddd\"},\"testList\":[\"aaaa\",\"bbbb\"],\"testListSpecial\":[{\"SubMsgID\":2,\"SubMsgTitle\":\"333\"},{\"SubMsgID\":3,\"SubMsgTitle\":\"4444\"}]}";  
	CTestStruct stru;  
	stru.DeSerialize(pstr);  
	CString strShow = "";  
	strShow.Format("objlist Size:%d\r\nlistIntCount:%d\r\nMsgID:%I64u\r\nMsgTile:%s\r\nMsgContent:%s\r\nSubMsgTitle:%s\r\nfirst value:%d",
		stru.testListSpecial.size(), stru.intList.size(), stru.MsgID, stru.MsgTitle.c_str(), stru.MsgContent.c_str(), stru.subObj.SubMsgTitle.c_str(),
		stru.intList.size() > 0 ? stru.intList[0] : 0);  
	AfxMessageBox(strShow);
打印结果： 

objlist Size:2
listIntCount:1
MsgID:11223344
MsgTile:黑黑
MsgContent:哈哈
SubMsgTitle:dddd
first value:3333
目前仅支持vector与list类型的列表，对于其他特殊的列表类型，需要在子类中重载如下函数： 

virtual Json::Value DoSpecialArraySerialize(const string& propertyName){ return "";}

至此，对于C++对象以及相关列表的序列化与反序列化均已支持，在此将源码贴出：

#ifndef CJSONOBJECTBASE_H
#define CJSONOBJECTBASE_H
#include <string>  
#include <vector>  
#include <list>
#include "json/json.h"  
using std::string;  
using std::vector;  
using std::list;

#pragma warning(disable:4267)

#define DoArrayDeSerialize_Wrapper(listType, type)\
	DoArrayDeSerialize<##listType<##type>, ##type>

#define Type_Wrapper(listType, type)\
	(##listType<##type>*)

#define DoArraySerialize_Wrapper(listType, type)\
	DoArraySerialize(Type_Wrapper(listType, type)addr);

#define DoObjArrayDeSerialize_Wrapper(listType, type)\
	DoObjArrayDeSerialize<##listType<type>>

typedef void* (*GenerateJsonObjForDeSerializeFromOutSide)(const string& propertyName);

struct CJsonObjectBase  
{  
protected:  
	enum CEnumJsonTypeMap  
	{
		asBool = 1,  
		asInt,  
		asUInt,  
		asString,  
		asInt64,  
		asUInt64,  
		asJsonObj,
		asSpecialArray,
		asVectorArray,
		asListArray,
	};  
public:  
	CJsonObjectBase(void){}  
public:  
	virtual ~CJsonObjectBase(void){		
	}  
	string Serialize()  
	{  
		Json::Value new_item = DoSerialize();         
		Json::FastWriter writer;    
		std::string out2 = writer.write(new_item);   
		return out2;  
	}  
	
	bool DeSerialize(const char* str)  
	{  
		Json::Reader reader;    
		Json::Value root;  
		if (reader.parse(str, root))  
		{    
			return DoDeSerialize(root);  
		}  
		return false;  
	}  

	Json::Value DoSerialize()  
	{  
		Json::Value new_item;  
		int nSize = m_vectorName.size();  
		for (int i=0; i < nSize; ++i )  
		{  
			void* pAddr = m_vectorPropertyAddr[i];  
			switch(m_vectorType[i])  
			{  
			case asVectorArray:
			case asListArray:
				new_item[m_vectorName[i]] = DoArraySerialize(pAddr, m_vectorType[i], m_vectorListParamType[i]);
				break;
			case asSpecialArray:  
				new_item[m_vectorName[i]] = DoSpecialArraySerialize(m_vectorName[i]); 
				break;  
			case asJsonObj:  
				new_item[m_vectorName[i]] = ((CJsonObjectBase*)pAddr)->DoSerialize();  
				break;  
			case asBool:  
				new_item[m_vectorName[i]] = Serialize<bool>(pAddr); 
			case asInt:  
				new_item[m_vectorName[i]] = Serialize<INT>(pAddr); 
				break;  
			case asUInt:  
				new_item[m_vectorName[i]] = Serialize<UINT>(pAddr);  
				break;  
			case asInt64:  
				new_item[m_vectorName[i]] = Serialize<LONGLONG>(pAddr);  
				break;  
			case asUInt64:  
				new_item[m_vectorName[i]] = Serialize<ULONGLONG>(pAddr);  
				break;  
			case asString:  
				new_item[m_vectorName[i]] = Serialize<string>(pAddr);  
			default:  
				//我暂时只支持这几种类型，需要的可以自行添加
				break;  
			}         
		}  
		return new_item;  
	} 
protected:
	bool DoDeSerialize(Json::Value& root)  
	{  
		int nSize = m_vectorName.size();  
		for (int i=0; i < nSize; ++i )  
		{  
			void* pAddr = m_vectorPropertyAddr[i];  

			switch(m_vectorType[i])  
			{  
			case asListArray:
			case asVectorArray:
				{
					if (root.isNull() || root[m_vectorName[i]].isNull())
					{
						break;
					}
					DoArrayDeSerialize(m_vectorName[i], pAddr, root[m_vectorName[i]], m_vectorType[i], m_vectorListParamType[i]);
				}
				break;
			case asJsonObj:  
				{  
					if (!root[ m_vectorName[i] ].isNull())   
						((CJsonObjectBase*)pAddr)->DoDeSerialize(root[m_vectorName[i]]);  
				}                 
				break;  
			case asBool:  
				(*(bool*)pAddr) = root.get(m_vectorName[i], 0).asBool();  
				break;  
			case asInt:  
				(*(INT*)pAddr) = root.get(m_vectorName[i], 0).asInt();  
				break;  
			case asUInt:  
				(*(UINT*)pAddr) = root.get(m_vectorName[i], 0).asUInt();  
				break;  
			case asInt64:  
				(*(LONGLONG*)pAddr) = root.get(m_vectorName[i], 0).asInt64();  
				break;  
			case asUInt64:  
				(*(ULONGLONG*)pAddr) = root.get(m_vectorName[i], 0).asUInt64();  
				break;  
			case asString:  
				(*(string*)pAddr) = root.get(m_vectorName[i], "").asString();  
			default:  
				//我暂时只支持这几种类型，需要的可以自行添加   
				break;  
			}             
		}  
		return true;  
	}  
	 
	void SetProperty(string name, CEnumJsonTypeMap type, void* addr,  CEnumJsonTypeMap listParamType = asInt)  
	{  
		m_vectorName.push_back(name);  
		m_vectorPropertyAddr.push_back(addr);  
		m_vectorType.push_back(type);  
		m_vectorListParamType.push_back(listParamType);
	}  
	virtual void SetPropertys() = 0;  
	//有特殊对象需要序列化时，请重载此函数 
	virtual Json::Value DoSpecialArraySerialize(const string& propertyName){ return "";}

	//在反序列化时，如果对象中嵌套了列表，并且列表中容纳的内容是其他特殊对象时，需要重载此函数，new出真正的对象
	virtual CJsonObjectBase* GenerateJsonObjForDeSerialize(const string& propertyName){ return NULL;}

	bool DoArrayDeSerialize(const string& propertyName, void* addr, Json::Value& root, CEnumJsonTypeMap listType, CEnumJsonTypeMap paramType)
	{
		if (listType == asVectorArray)
		{
			switch(paramType)
			{ 
			case asJsonObj:  
				{  
					return DoObjArrayDeSerialize_Wrapper(vector, CJsonObjectBase*)(propertyName, addr, root);
				}                 
				break;  
			case asBool:  
				//无 
				break; 
			case asInt:  
				return DoArrayDeSerialize_Wrapper(vector, INT)(addr, root); 
			case asUInt:  
				return DoArrayDeSerialize_Wrapper(vector, UINT)(addr, root);   
			case asInt64:  
				return DoArrayDeSerialize_Wrapper(vector, LONGLONG)(addr, root);     
			case asUInt64:  
				return DoArrayDeSerialize_Wrapper(vector, ULONGLONG)(addr, root);     
			case asString:  
				return DoArrayDeSerialize_Wrapper(vector, string)(addr, root);       
			default:
				break;  
			}
		}
		else if(listType == asListArray)
		{
			switch(paramType)
			{ 
			case asJsonObj:  
				{
					return DoObjArrayDeSerialize_Wrapper(list, CJsonObjectBase*)(propertyName, addr, root);
				}                 
				break;  
			case asBool:  
				return DoArrayDeSerialize_Wrapper(list, bool)(addr, root);
			case asInt:  
				return DoArrayDeSerialize_Wrapper(list, INT)(addr, root); 
 			case asUInt:  
				return DoArrayDeSerialize_Wrapper(list, UINT)(addr, root);   
 			case asInt64:  
 				return DoArrayDeSerialize_Wrapper(list, LONGLONG)(addr, root);     
			case asUInt64:  
 				return DoArrayDeSerialize_Wrapper(list, ULONGLONG)(addr, root);     
			case asString:  
				return DoArrayDeSerialize_Wrapper(list, string)(addr, root);     
			default:
				break;  
			}
		}
		
		return true;
	}

	//特殊对象列表的反序列化
	template<typename T1>
	bool DoObjArrayDeSerialize(const string& propertyName, void* addr, Json::Value& node)
	{
		if (!node.isArray())
		{
			return false;
		}
		T1* pList = (T1*)addr;
		int size = node.size();
		for(int i = 0; i < size; ++i)
		{
			CJsonObjectBase* pNode = GenerateJsonObjForDeSerialize(propertyName);
			pNode->DoDeSerialize(node[i]);
			pList->push_back(pNode);
		}
		return true;
	}
public:
	//常见类型列表的反序列化 
	template <typename T1, typename T2>
	static bool DoArrayDeSerialize(void* addr, Json::Value& node)
	{
		if (!node.isArray())
		{
			return false;
		}
		T1* pList = (T1*)addr;
		int size = node.size();
		for(int i = 0; i < size; ++i)
			pList->push_back( DeSerialize<T2>(node[i]) );
		return true;
	}

	//特殊对象列表的反序列化
	template<typename T1>
	static bool DoObjArrayDeSerialize(const string& propertyName, void* addr, Json::Value& node, GenerateJsonObjForDeSerializeFromOutSide funGenerate)
	{
		if (!node.isArray())
		{
			return false;
		}
		T1* pList = (T1*)addr;
		int size = node.size();
		for(int i = 0; i < size; ++i)
		{
			CJsonObjectBase* pNode = (CJsonObjectBase*)funGenerate(propertyName);
			pNode->DoDeSerialize(node[i]);
			pList->push_back(pNode);
		}
		return true;
	}
protected:
	Json::Value DoArraySerialize(void* addr, CEnumJsonTypeMap listType, CEnumJsonTypeMap paramType)
	{
		if (listType == asVectorArray)
		{
			switch(paramType)
			{ 
			case asBool:  
				return "";
			case asJsonObj:
				return DoArraySerialize_Wrapper(vector, CJsonObjectBase*);
			case asInt:  
				return DoArraySerialize_Wrapper(vector, INT);
			case asUInt:  
				return DoArraySerialize_Wrapper(vector, UINT); 
			case asInt64:  
				return DoArraySerialize_Wrapper(vector, LONGLONG);   
			case asUInt64:  
				return DoArraySerialize_Wrapper(vector, ULONGLONG);  
			case asString:  
				return DoArraySerialize_Wrapper(vector, string);
			}
		}
		else 
		{
			switch(paramType)
			{ 
			case asBool:  
				return DoArraySerialize_Wrapper(list, bool);
			case asJsonObj:
				return DoArraySerialize_Wrapper(list, CJsonObjectBase*);
			case asInt:  
				return DoArraySerialize_Wrapper(list, INT);
			case asUInt:  
				return DoArraySerialize_Wrapper(list, UINT); 
			case asInt64:  
				return DoArraySerialize_Wrapper(list, LONGLONG);   
			case asUInt64:  
				return DoArraySerialize_Wrapper(list, ULONGLONG);  
			case asString:  
				return DoArraySerialize_Wrapper(list, string);
			}
		}
		return "";
	}
public:
	template <typename T1>
	static Json::Value DoArraySerialize(T1* pList)
	{
		Json::Value arrayValue;
		for (T1::iterator it = pList->begin(); it != pList->end(); ++ it)
		{
			arrayValue.append(*it);			
		}
		return arrayValue;
	}	
	
	template <>
	static Json::Value DoArraySerialize(vector<CJsonObjectBase*>* pList)
	{
		Json::Value arrayValue;
		for (vector<CJsonObjectBase*>::iterator it = pList->begin(); it != pList->end(); ++ it)
		{
			arrayValue.append((*it)->DoSerialize());			
		}
		return arrayValue;
	}

	template <>
	static Json::Value DoArraySerialize(list<CJsonObjectBase*>* pList)
	{
		Json::Value arrayValue;
		for (list<CJsonObjectBase*>::iterator it = pList->begin(); it != pList->end(); ++ it)
		{
			arrayValue.append((*it)->DoSerialize());			
		}
		return arrayValue;
	}
	static string JsonValueToString(Json::Value& tvalue)
	{
		Json::FastWriter writer;    
		return writer.write(tvalue);
	}
private:
	template <typename T>
	Json::Value Serialize(void* addr)
	{
		return (*(T*)addr);
	}

	template <typename T>
	static T DeSerialize(Json::Value& root)
	{
		return GetData<T>(root);
	}

	template <typename T>
	static T GetData(Json::Value& root)
	{
		T temp;
		return temp;
	}

	template <>
	static bool GetData(Json::Value& root)
	{
		return root.asBool();
	}

	template <>
	static INT GetData(Json::Value& root)
	{
		return root.asInt();
	}

	template <>
	static UINT GetData(Json::Value& root)
	{
		return root.asUInt();
	}
	template <>
	static LONGLONG GetData(Json::Value& root)
	{
		return root.asInt64();
	}
	template <>
	static ULONGLONG GetData(Json::Value& root)
	{
		return root.asUInt64();
	}
	template <>
	static string GetData(Json::Value& root)
	{
		return root.asString();
	}

private:  
	vector<string> m_vectorName;  
	vector<void*>  m_vectorPropertyAddr;  
	vector<CEnumJsonTypeMap>     m_vectorType;
	vector<CEnumJsonTypeMap>     m_vectorListParamType;
}; 
#endif

如果哪位有任何意见建议，敬请回复！
完整的测试程序及DEMO请见： http://download.csdn.net/detail/tragicguy/5649527



大蓝头
关注
  • 2
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
C++ JSON 序列化与反序列化
06-22
C++ JSON 序列化与反序列化 相关的博客文章见：http://blog.csdn.net/TragicGuy
C++对象的JSON序列化与反序列化探索续-复杂对象的序列化与反序列化
TragicGuy的专栏
06-22 3635
本文是基本上一篇博文进行改进而成，上一篇请见： C++对象的JSON序列化与反序列化探索 此处就不多说了，直接上代码。 1. 序列化基类 #pragma once #include #include #include "json/json.h" using std::string; using std::vector; struct CJsonObejectBase { pro
C++ JSON 序列化和反序列化 原创
qq_44377498的博客
07-22 608
有一些库依赖于更大的库，安装和使用较为麻烦。JSON转字符串，我们将刚刚创建的json转为字符串，直接使用JSON.stringfy()函数就行。使用C++进行后端开发的时候，我们会发现，有很多网上的第三方库进行JSON解析，但有的并不是特别好用。所以博主写了一个简单的JSON解析库，用于JSON操作，并重载了C++中的一些运算符，目标是为了让在C++中使用JSON，就像在JavaScript中使用Object一样简单。在C++代码中直接书写JSON代码如下，直接使用JSON.create来创建JSON。
C++对象的JSON序列化与反序列化探索
热门推荐
TragicGuy的专栏
06-22 1万+
一：背景 作为一名C++开发人员，我一直很期待能够像C#与JAVA那样，可以轻松的进行对象的序列化与反序列化，但到目前为止，尚未找到相对完美的解决方案。 本文旨在抛砖引玉，期待有更好的解决方案；同时向大家寻求帮助，解决本文中未解决的问题。  二：相关技术介绍 本方案采用JsonCpp来做具体的JSON的读入与输出，再结合类成员变量的映射，最终实现对象的JSON序列化与反序列化。 本文不再
C++ JSON对象序列化与反序列化
zccmid的博客
01-15 1343
C++ 反射 JSON 对象 序列化 反序列化 封装
在C#中，Json的序列化和反序列化的几种方式总结
weixin_30466953的博客
02-16 268
在这篇文章中，我们将会学到如何使用C#，来序列化对象成为Json格式的数据，以及如何反序列化Json数据到对象。 首先，解释一下json Json【javascript对象表示方法】，它是一个轻量级的数据交换格式，我们可以很简单的来读取和写它，并且它很容易被计算机转化和生成，它是完全独立于语言的。 Json支持下面两种数据结构： 键值对的集合--各种不同的编程语言，都支持这种数据结构...
Visual C++中对象的序列化与文件I-O研究.rar_c++对象序列化_对象序列化_序列化
09-19
在C++编程中，对象序列化是一个重要的概念，它涉及到将程序中的对象状态转换为可以存储或传输的数据格式，如二进制或文本文件。这一过程通常用于持久化数据、跨进程通信或在网络上传输对象。在Visual C++环境下，...
c++json序列化代码生成工具
04-26
c++json对象序列化反序列化代码生成工具。提供对象定义工具，定义项目、对象、字段。然后通过代码生成工具，生成json序列化、反序列化代码。c++json对象序列化反序列化代码生成工具。提供对象定义工具，定义项目、...
Json序列化和反序列化
05-06
JSON序列化是将数据对象转化为JSON字符串的过程，而反序列化则是将JSON字符串还原为数据对象。在C#中，处理JSON序列化和反序列化有多种方法，本篇文章将深入探讨这一主题。 1. .NET框架内置支持 .NET Framework ...
Visual C++中对象的序列化与文件I/O研究
07-26
在Visual C++中，对象的序列化与文件I/O是程序持久性和数据记录的重要技术。对象序列化的目的是保存和加载对象的状态数据，使得程序能够在终止后再恢复到之前的状态。这一过程在MFC（Microsoft Foundation Classes）...
Json的序列化和反序列化
zhruifei的专栏
11-01 544
原文链接：http://www.cnblogs.com/fengxuehuanlin/p/5700282.html一.什么是Json： 中午肚子饿了，到餐厅点餐。向服务员点了几个菜，厨师根据用户的需求，开始烹饪食物，食物烹饪好后，怎么将食物呈现给用户呢？这时就需要用到盛放食物的碗了。用户拿到盛放食物的碗，就可以获得点的餐了。这个碗就充当了数据交换的容器了(＾－＾)客户端向服务器端发送请求后，服务器
一个更好的C++序列化/反序列化库Kapok
12-15
Kapok FAQ 　　1.Kapok的特点 　　简单，易用，header-only，只需要引用Kapok.hpp即可；高效，初步测试性和messagepack相当。 　　它是纯c++11实现，因此需要支持C++11的编译器。 　　2.主要功能 　　对对象进行自动化的序列化和反序列化，用起来非常简单，先来看个序列化/反序列化一个tuple的例子吧。 　　//序列化 　　Serializer sr; 　　auto tp = std::make_tuple(10， 12， string("test")); 　　sr.Serialize(tp， "tuple"); 　　//反序列
c++实现Json配置数据序列化和反序列化
千人斩的博客
08-28 1275
配置参数的读写，从技术选型上有ini，xml，json。由于ini原生不支持树结构，需要根据需要将父节点的option作为子节点的section，配置文件可读性变差。xml由于属性和元素分开的形式，不适合直接转为c++定义的树状结构。所有最终选择了json。 要想用c++实现一个通用的json文件序列化和反序列化工具，反射是绕不开的。c++语言原生不支持反射，因此要通过一些编程技巧实现。......
c++ 序列化和反序列化
dat1842的博客
05-06 493
1.什么是序列化？ 程序猿在编写应用程序的时候往往须要将程序的某些数据存储在内存中，然后将其写入某个文件或是将它传输到网络中的还有一台计算机上以实现通讯。这个将程序数据转化成能被存储并传输的格式的过程被称为“序列化”（Serialization），而它的逆过程则可被称为“反序列化”（Deserialization）。 简单来说，序列化就是将对象实例的状态转换为可保持或传输的格式的过...
C++使用JSON的序列化与反序列化
hanhan的博客
10-06 5700
这里使用的json解析工具为JSON for Modern C++,使用的话仅需要包含头文件。 获取方式：wget https://github.com/nlohmann/json/releases/download/v3.7.3/json.hpp JSON json的序列化功能和map一样，用关联数组的"[]"来任意添加数据，不需要指定数据类型，它会自动推导。添加完之后用dump完成序列化，得到json形式的文本。 #include <iostream> #include <vector
C# c++ Json序列化与反序列
qq6304403348的博客
03-06 322
C# 序列化与反序列化， 读文件和写到文件
C++对象序列化与反序列化
qq_35886593的博客
12-09 382
https://my.oschina.net/u/727148/blog/706233 https://www.2cto.com/kf/201306/222076.html
【C++】一文搞懂JSON序列化和反序列（让你有一种相见恨晚的感觉！！）
最新发布
weixin_45031801的博客
08-10 1287
在现代软件开发中，JSON（JavaScript Object Notation）已经成为数据交换的标准格式之一。无论是在前后端通信、API 数据传输，还是在配置文件管理中，JSON 的简洁性和可读性使其广泛应用。然而，处理 JSON 数据的关键在于序列化和反序列化——将数据结构转换为 JSON 格式，以及将 JSON 格式解析回数据结构。这篇博客将深入探讨 JSON 序列化和反序列化的概念，并通过实例展示如何在 C++ 中高效地处理 JSON 数据。
C++对象数组序列化与反序列化详解
CArchive对象起到了一个中间媒介的作用，它使用类似于I/O流的操作符（>>和）来实现对象的序列化和反序列化，使得可以安全地将数据写入到CFile对象，或者从CFile对象中读取数据。CFile对象通常代表磁盘上的文件，但也...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值