c++对象序列化编程实例

最新推荐文章于 2024-04-24 21:42:54 发布
最新推荐文章于 2024-04-24 21:42:54 发布
阅读量287 收藏
点赞数
分类专栏： acl_cpp开发--序列化 文章标签： c++ 对象序列化 acl 库 对象序列化

      在《使用 acl 库针对 C++ 对象进行序列化及反序列编程》中介绍了 acl 库中针对 C/C++ 的 struct 对象进行序列化和反序列化的功能，并且给出了一个简单的例子。本文将介绍一些较为复杂的例子。

      一、示例一：支持多继承的例子

      先定义 struct.stub 文件：

#pragma once
#include <string>

struct student
{
	std::string shcool;
	std::string class_name;
};

struct province
{
	std::string province_name;
	std::string position;
};

struct user : student, province
{
	std::string name;
	int  age;
	bool male;
};

      上面的定义中，user 继承于 student 和 province。

      然后使用 gson 工具（运行：./gson -d ）根据此 struct.stub 生成目标源文件和头文件：gson.cpp, gson.h, struct.h。

      下面就可以编写业务逻辑代码：

#include "stdafx.h"
#include <list>
#include <vector>
#include <map>
#include <stdio.h>
#include <iostream>
#include <time.h>
#include "struct.h"  // 由 gson 工具根据 struct.stub 转换而成
#include "gson.h"    // 由 gson 工具根据 struct.stub 生成

// 序列化过程
static void serialize(void)
{
	user u;

	u.name = "zsx";
	u.age = 11;
	u.male = true;

	u.province_name = "省";
	u.position = "位置";

	u.shcool = "大学";
	u.class_name = "班级";

	acl::json json;

	// 将 user 对象转换为 json 对象
	acl::json_node& node = acl::gson(json, u);

	printf("serialize:\r\n");
	printf("json: %s\r\n", node.to_string().c_str());
	printf("\r\n");
}

// 反序列化过程
static void deserialize(void)
{
	const char *s = "{\"shcool\": \"大学\", \"class_name\": \"班级\", \"province_name\": \"省\", \"position\": \"位置\", \"name\": \"zsx\", \"age\": 11, \"male\": true}";
	printf("deserialize:\r\n");

	acl::json json;
	json.update(s);
	user u;

	// 将 json 对象转换为 user 对象
	std::pair<bool, std::string> ret = acl::gson(json.get_root(), u);

	// 如果转换失败，则打印转换失败原因
	if (ret.first == false)
		printf("error: %s\r\n", ret.second.c_str());
	else
	{
		printf("name: %s, age: %d, male: %s\r\n",
			u.name.c_str(), u.age, u.male ? "yes" : "no");
		printf("province_name: %s, position: %s\r\n",
			u.province_name.c_str(), u.position.c_str());
		printf("shcool: %s, class_name: %s\r\n",
			u.shcool.c_str(), u.class_name.c_str());
	}
}

int main(void)
{
	serialize();
	deserialize();
	return 0;
}

       编译并运行该例子，结果如下：

serialize:
json: {"shcool": "大学", "class_name": "班级", "province_name": "省", "position": "位置", "name": "zsx", "age": 11, "male": true}

deserialize:
name: zsx, age: 11, male: yes
province_name: 省, position: 位置
shcool: 大学, class_name: 班级

 

      二、示例二：支持 C++11 的例子

      定义 struct.stub 文件如下：

#pragma once

struct user
{
	// 带参数的构造函数
	user(const char* user_name, const char* user_domain,
		int user_age, bool user_male)
	: username(user_name)
	, domain(user_domain)
	, age(user_age)
	, male(user_male)
	{}

	user() {}
	~user() {}

	acl::string username;
	acl::string domain;
	int age = 100;
	bool male = true;
};

struct message
{
	int type;
	acl::string cmd;
	std::list<user> user_list;
	std::list<user> user_vector;
	std::map<acl::string, user> user_map;

	std::list<user*> *user_list_ptr = nullptr;
	std::vector<user*> *user_vector_ptr = nullptr;
	std::map<acl::string, user*> *user_map_ptr = nullptr;

	int n = 100;				// c++11 允许初始化成员变量
	long n1 = 1000;
	long long int n2 = 1000;
	short n3 = 100;
	//Gson@optional
	user* u = nullptr;

	message() {}

	~message()
	{
		if (user_list_ptr)
		{
			for (auto it : *user_list_ptr)
				delete it;
			delete user_list_ptr;
		}
		if (user_vector_ptr)
		{
			for (auto it : *user_vector_ptr)
				delete it;
			delete user_vector_ptr;
		}
		if (user_map_ptr)
		{
			for (auto it : *user_map_ptr)
				delete it.second;
			delete user_map_ptr;
		}
	}
};

       用 gson 工具将上述 stub 文件生成同样的三个文件：gson.cpp, gson.h, struct.h，然后编写业务处理代码如下：

#include "stdafx.h"
#include <list>
#include <vector>
#include <map>
#include <stdio.h>
#include <iostream>
#include <time.h>
#include "struct.h"
#include "gson.h"

static void print_msg(message& msg)
{
	printf("=======================================================\r\n");
	printf("type: %d\r\n", msg.type);
	printf("cmd: %s\r\n", msg.cmd.c_str());

	printf("-------------------- user list ------------------------\r\n");
	size_t i = 0;
	for (auto cit : msg.user_list)
	{
		printf(">>username: %s, domain: %s, age: %d, male: %s\r\n",
			cit.username.c_str(), cit.domain.c_str(),
			cit.age, cit.male ? "true" : "false");
		if (++i >= 10)
			break;
	}

	printf("-------------------- user vector ----------------------\r\n");
	i = 0;
	for (auto cit : msg.user_vector)
	{
		printf(">>username: %s, domain: %s, age: %d, male: %s\r\n",
			cit.username.c_str(), cit.domain.c_str(),
			cit.age, cit.male ? "true" : "false");
		if (++i >= 10)
			break;
	}

	printf("------------------- user map --------------------------\r\n");
	i = 0;
	for (auto cit : msg.user_map)
	{
		printf(">>key: %s, username: %s, domain: %s, age: %d, male: %s\r\n",
			cit.first.c_str(),
			cit.second.username.c_str(),
			cit.second.domain.c_str(),
			cit.second.age,
			cit.second.male ? "true" : "false");
		if (++i >= 10)
			break;
	}
	printf("-------------------- user list ptr --------------------\r\n");
	i = 0;
	for (auto cit : *msg.user_list_ptr)
	{
		printf(">>username: %s, domain: %s, age: %d, male: %s\r\n",
			cit->username.c_str(), cit->domain.c_str(),
			cit->age, cit->male ? "true" : "false");
		if (++i >= 10)
			break;
	}

	printf("-------------------- user vector ptr ------------------\r\n");
	i = 0;
	for (auto cit : *msg.user_vector_ptr)
	{
		printf(">>username: %s, domain: %s, age: %d, male: %s\r\n",
			cit->username.c_str(), cit->domain.c_str(),
			cit->age, cit->male ? "true" : "false");
		if (++i >= 10)
			break;
	}

	printf("------------------- user map ptr ----------------------\r\n");
	i = 0;
	for (auto cit : *msg.user_map_ptr)
	{
		printf(">>key: %s, username: %s, domain: %s, age: %d, male: %s\r\n",
			cit.first.c_str(),
			cit.second->username.c_str(),
			cit.second->domain.c_str(),
			cit.second->age,
			cit.second->male ? "true" : "false");
		if (++i >= 10)
			break;
	}

	printf("-------------------------------------------------------\r\n");
}

static void test(void)
{
	//
	// 序列化过程

	message msg;
	msg.user_list_ptr   = new std::list<user*>;
	msg.user_vector_ptr = new std::vector<user*>;
	msg.user_map_ptr    = new std::map<acl::string, user*>;

	msg.type = 1;
	msg.cmd  = "add";

	user u = {"zsx1", "263.net", 11, true};
	msg.user_list.push_back(u);
	msg.user_list.emplace_back(u);
	msg.user_list.emplace_back("zsx1", "263.net", 13, false);

	u = {"zsx2", "263.net", 11, true};
	msg.user_vector.push_back(u);
	msg.user_vector.emplace_back(u);
	msg.user_vector.emplace_back("zsx2", "263.net4", 14, true);

	u = {"zsx31", "263.net", 11, true};
	msg.user_map[u.username] = u;
	msg.user_map["zsx32"] = {"zsx32", "263.net", 11, true };

	msg.user_list_ptr->push_back(new user("zsx4", "263.net1", 11, true));
	msg.user_list_ptr->push_back(new user("zsx4", "263.net2", 12, true));

	msg.user_vector_ptr->push_back(new user("zsx5", "263.net1", 11, true));
	msg.user_vector_ptr->push_back(new user("zsx5", "263.net2", 12, true));

	(*msg.user_map_ptr)["zsx61"] = new user("zsx61:", "263.net1", 11, true);
	(*msg.user_map_ptr)["zsx62"] = new user("zsx62", "263.net2", 12, true);

	acl::json json;

	// 序列化
	acl::json_node& node = acl::gson(json, msg);
	printf("serialize: %s\r\n", node.to_string().c_str());

	/
	// 反序列化过程

	message msg1;
	acl::json json1;
	json1.update(node.to_string());

	printf("json1 to_string: %s\r\n", json1.to_string().c_str());

	// 反序列化
	std::pair<bool, std::string> ret = acl::gson(json1.get_root(), msg1);
	if (ret.first == false)
		printf("error: %s\r\n", ret.second.c_str());
	else
		print_msg(msg);
}

int main(void)
{
	test();
	return 0;
}

       上述例子主要体现了 gson 的两个特点：1、允许有构造函数，2、支持 C++11 中的结构成员初始化。

 

      三、参考

      文章参考：《使用 acl 库针对 C++ 对象进行序列化及反序列编程》

      更多示例：https://github.com/acl-dev/acl/tree/master/app/gson/test

      acl github：https://github.com/acl-dev/acl

      acl download: https://sourceforge.net/projects/acl/

      QQ 群：242722074

 

zsxxsz
关注
专栏目录
C++序列化和反序列化
03-10
​ 很多人都知道rapidjson这个json库，大家也都知道他的高效，可是你一定也对他的使用方法，函数API接口感受到非常不适应，你一定非常怀念使用java和C#对一个实体类的那么轻松加简单的直接json序列化，本篇博客使用一个RapidJsonHelper类，将帮你实现对一个C++实体类的的序列化和反序列化。rapidjson的版本是1.1。 ​
C++基本功之 对象序列化
编写工业强度的软件 - bingfeng的专栏
09-10 7734
稍微正式一点的应用都会用到对象的序列化/反序列化操作，常见的需求包括：对象的持久存储。比如把一个对象存储到文件；在需要的时候，再把对象从文件中读出来；对象的传递。比如要把一个对象通过管道，socket等任何手段传送到对端；从数据构建对象。对象类型未知，但是我们可以从数据中构建一个对象出来。 我们现在来分析这些需求。看看C++如何有效地序列化/反序列化对象。下文中，凡提到序列化，
C++实现结构体序列化和反序列化
qq_55967171的博客
10-30 2477
序列化：就是将对象转化成字节序列的过程。反序列化：就是讲字节序列转化成对象的过程。对象序列化成的字节序列会包含对象的类型信息、对象的数据等，说白了就是包含了描述这个对象的所有信息，能根据这些信息“复刻”出一个和原来一模一样的对象。简单的来说结构体序列化就是将这个结构体里的数据转成一段通用的数据，另一个同类型结构体拿到这段数据后可以反序列化拿到每个结构体成员的值。上述代码中将a的数据拷贝到b，当然像A这样简单的结构体直接=就能进行拷贝了。
C++对象序列化简介与选型
04-16 1803
C++对象序列化，与文件保存类似，但是不一样。比如在运行过程中，需要保存某个对象，是串行化特有的功能。面向对象的语言都有这个功能，比如java。下面是转自wiki 的介绍：http://code.google.com/p/plumgo/wiki/HSNNS_ObjectSerialization C++ Serialization Schemes 常见C++序列化方案
C++ JSON 序列化代码
06-25
在C++中，为了将C++对象转换为JSON格式的字符串，或者将JSON字符串解析为C++对象，我们需要使用JSON序列化库。这篇内容我们将深入探讨C++中的JSON序列化，基于提供的资源，我们可以推测这是一个关于如何在C++中实现...
Visual C++ MFC 编程实例教程
02-17
`CArchive`类尤其有用，它允许以序列化的方式保存和加载对象状态，从而实现持久化存储。 网络编程方面，MFC包含了`CSocket`类，用于实现TCP/IP通信。通过创建和连接套接字，开发者可以构建客户端-服务器应用程序。 ...
Visual.C++.MFC编程实例
11-17
此外，还有序列化机制，用于将对象的状态保存到文件并恢复。 7. 网络编程：MFC包含了对Winsock的支持，允许开发者编写网络应用程序，如TCP/IP客户端和服务器。 8. 异步消息机制：MFC使用消息队列和消息循环来处理...
VISUAL C++MFC扩展编程实例
10-21
本书主要介绍了运用Visual C++ 5.0或6.0的高级编程技巧，内容涉及MFC程序设计的最新概念，全书提供了大量VC的编程实例，旨在帮助读者较为全面地掌握VC编程知识、技巧和方法。全书分为三个部分和附录。第一部分介绍...
c++的struct结构体的序列化和反序列化和json的序列化和反序列化的通俗直白的解释和说明
dz131lsq的博客
01-22 1156
序列化转换成字节流，能方便的进行保持和在网络进行传输。反序列化能把字节流数据转换成结构化的数据，方便读取和识别。首先要明白一个概念，如果用int*指针对，一块内存进行遍历这个指针每次加1实际上是向前移动4个字节，类似的shor*每次移动2个字节，BYTE*每次移动一个字节。
使用C++进行对象序列化
wojiushiwoba的博客
03-02 2854
1 什么是序列化 程序员在编写应用程序的时候往往需要将程序的某些数据存储在内存中，然后将其写入某个文件或是将它传输到网络中的另一台计算机上以实现通讯。这个将程序数据转化成能被存储并传输的格式的过程被称为“序列化”（Serialization），而它的逆过程则可被称为“反序列化”（Deserialization）。 简单来说，序列化就是将对象实例的状态转换为可保持或传输的格式的过程。与序
【原创】C++中对象的序列化
J010101的博客
12-20 434
　　1、对象序列化 　　　　对象的序列化是指将对象的状态信息转换为可以存储或者传输的形式的过程。对象的反序列化是与序列化相反的过程。 　　　　在序列化期间，对象将其当前的状态写入到临时或者永久性的存储区，可以通过从存储区读取或者反序列化对象的状态，重新创建该对象。 　　　　通过序列化，可以将对象从一个应用域发送到另一个应用域中，或者通过网络连接将对象数据发送到另一台主机。 　　　...
如何使用C++进行对象序列化
Memory1011的博客
12-02 266
转自：http://www.pinlue.com/article/2019/05/2205/129006780031.html
C++序列化
zdsji的博客
05-26 535
借用c++元编程实现的序列化与反序列化，感谢大佬YaZi, B站Id: 天天写乱码, 提供的思路。
C++对象序列化
xiaoding133的专栏【Stay hungry,Stay foolish】
07-04 1730
C++语言对文件的处理有一些限制，对于后来出现的一些语言，如Pascal 和Java都提供了对对象进行序列化的支持，而C++只能通过C FILE s结构 或 C++自己的fstream 类来保存程序中变量的值。  二进制序列化      对象序列化包含保存对象中的某些值，这些值是来自类当中的成员变量。在目前的标准当中，C++不存在内在的对象序列化，为了达到对象序列化，可以用二进制序列化来实现。
手撕代码: C++实现数据的序列化和反序列化
最新发布
红军不怕远征难，万水千山只等闲
04-24 2464
在C++应用程序中，经常会涉及到对一些数据进行序列化和反序列化的处理。序列化可以将一个对象转换为一串字节流，这样就可以将其存储在硬盘上或者通过网络传输到其他设备上。而反序列化则是将这些字节流解析成原始的对象。 在Qt中，数据的序列化和反序列化可以使用QDataStream类来完成。QDataStream是一个方便的Qt类，它可以将基本数据类型、Qt数据类型以及用户定义的数据类型都进行序列化和反序列化。在使用QDataStream进行序列化时，需要指定一个QIODevice类的子类（例如QF
C++与序列化
weixin_43728590的博客
06-15 3952
协议/protobuf
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值