x2struct rapidjson
项目重构，结构体序列化成json字符串，使用x2struct来进行序列化和反序列化
json与C++结构体互相转换 :https://blog.csdn.net/xyz347/article/details/79338202
注意：
x2struct
1 std::map
std::map
2 局部定义类型，序列化异常。
序列化成json字符串，其中用到rapidjson，据说目前性能最好的json工具。
RapidJSON是腾讯开源的一个高效的C++ JSON解析器及生成器，它是只有头文件的C++库。
RapidJSON 是一个 C++ 的 JSON 解析器及生成器。它的灵感来自 RapidXml。
- RapidJSON 小而全。它同时支持 SAX 和 DOM 风格的 API。SAX 解析器只有约 500 行代码。
- RapidJSON 快。它的性能可与
strlen()相比。可支持 SSE2/SSE4.2 加速。 - RapidJSON 独立。它不依赖于 BOOST 等外部库。它甚至不依赖于 STL。
- RapidJSON 对内存友好。在大部分 32/64 位机器上，每个 JSON 值只占 16 字节（除字符串外）。它预设使用一个快速的内存分配器，令分析器可以紧凑地分配内存。
- RapidJSON 对 Unicode 友好。它支持 UTF-8、UTF-16、UTF-32 (大端序／小端序)，并内部支持这些编码的检测、校验及转码。例如，RapidJSON 可以在分析一个 UTF-8 文件至 DOM 时，把当中的 JSON 字符串转码至 UTF-16。它也支持代理对（surrogate pair）及
"\u0000"（空字符）。
腾讯的开源地址：https://github.com/Tencent/rapidjson/
说明文档：http://rapidjson.org/zh-cn/
安装
RapidJSON 是只有头文件的 C++ 库。只需把 include/rapidjson 目录复制至系统或项目的 include 目录中。
RapidJSON 依赖于以下软件：
- CMake 作为通用生成工具
- (optional) Doxygen 用于生成文档
- (optional) googletest 用于单元及性能测试
生成测试及例子的步骤：
- 执行
git submodule update --init去获取 thirdparty submodules (google test)。 - 在 rapidjson 目录下，建立一个
build目录。 - 在
build目录下执行cmake ..命令以设置生成。Windows 用户可使用 cmake-gui 应用程序。 - 在 Windows 下，编译生成在 build 目录中的 solution。在 Linux 下，于 build 目录运行
make。
成功生成后，你会在 bin 的目录下找到编译后的测试及例子可执行文件。而生成的文档将位于 build 下的 doc/html 目录。要执行测试，请在 build 下执行 make test 或 ctest。使用 ctest -V 命令可获取详细的输出。
我们也可以把程序库安装至全系统中，只要在具管理权限下从 build 目录执行 make install 命令。这样会按系统的偏好设置安装所有文件。当安装 RapidJSON 后，其他的 CMake 项目需要使用它时，可以通过在 CMakeLists.txt 加入一句 find_package(RapidJSON)。
用法一览
此简单例子解析一个 JSON 字符串至一个 document (DOM)，对 DOM 作出简单修改，最终把 DOM 转换（stringify）至 JSON 字符串。
// rapidjson/example/simpledom/simpledom.cpp`
#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/stringbuffer.h"
#include
using namespace rapidjson;
int main() {
// 1. 把 JSON 解析至 DOM。
const char* json = "{\"project\":\"rapidjson\",\"stars\":10}";
Document d;
d.Parse(json);
// 2. 利用 DOM 作出修改。
Value& s = d["stars"];
s.SetInt(s.GetInt() + 1);
// 3. 把 DOM 转换（stringify）成 JSON。
StringBuffer buffer;
Writer writer(buffer);
d.Accept(writer);
// Output {"project":"rapidjson","stars":11}
std::cout << buffer.GetString() << std::endl;
return 0;
} 注意此例子并没有处理潜在错误。
下图展示执行过程。
下面是转至「奋斗-少年」的一篇文章，写的也比较明了
原文链接：https://blog.csdn.net/qq849635649/article/details/52678822
我在工作中一直使用的是rapidjson库，这是我在工作中使用该库作的一些整理，以读写下面的这段json字符串为例来进行整理，该字符串覆盖了平时使用的布尔类型、整型、浮点类型、结构体类型、字符串类型以及相对应的数组类型。
代码地址：https://git.oschina.net/zhaoyf/zhaoyf_csdn/tree/master/test_json
{
"Int": 1,
"Double": 12.0000001,
"String": "This is a string",
"Object": {
"name": "qq849635649",
"age": 25
},
"IntArray": [
10,
20,
30
],
"DoubleArray": [
1,
2,
3
],
"StringArray": [
"one",
"two",
"three"
],
"MixedArray": [
"one",
50,
false,
12.005
],
"People": [
{
"name": "qq849635649",
"age": 0,
"sex": true
},
{
"name": "qq849635649",
"age": 10,
"sex": false
},
{
"name": "qq849635649",
"age": 20,
"sex": true
}
]
}
一、写json协议
1. 下面这段代码是简单明了一种方式，使用字符串缓冲器生成
#include "rapidjson/stringbuffer.h"
#include "rapidjson/writer.h"
#include
#include
using namespace std;
void Serialize_1()
{
rapidjson::StringBuffer strBuf;
rapidjson::Writer writer(strBuf);
writer.StartObject();
//1. 整数类型
writer.Key("Int");
writer.Int(1);
//2. 浮点类型
writer.Key("Double");
writer.Double(12.0000001);
//3. 字符串类型
writer.Key("String");
writer.String("This is a string");
//4. 结构体类型
writer.Key("Object");
writer.StartObject();
writer.Key("name");
writer.String("qq849635649");
writer.Key("age");
writer.Int(25);
writer.EndObject();
//5. 数组类型
//5.1 整型数组
writer.Key("IntArray");
writer.StartArray();
//顺序写入即可
writer.Int(10);
writer.Int(20);
writer.Int(30);
writer.EndArray();
//5.2 浮点型数组
writer.Key("DoubleArray");
writer.StartArray();
for(int i = 1; i < 4; i++)
{
writer.Double(i * 1.0);
}
writer.EndArray();
//5.3 字符串数组
writer.Key("StringArray");
writer.StartArray();
writer.String("one");
writer.String("two");
writer.String("three");
writer.EndArray();
//5.4 混合型数组
//这说明了，一个json数组内容是不限制类型的
writer.Key("MixedArray");
writer.StartArray();
writer.String("one");
writer.Int(50);
writer.Bool(false);
writer.Double(12.005);
writer.EndArray();
//5.5 结构体数组
writer.Key("People");
writer.StartArray();
for(int i = 0; i < 3; i++)
{
writer.StartObject();
writer.Key("name");
writer.String("qq849635649");
writer.Key("age");
writer.Int(i * 10);
writer.Key("sex");
writer.Bool((i % 2) == 0);
writer.EndObject();
}
writer.EndArray();
writer.EndObject();
string data = strBuf.GetString();
cout << data << endl;
}
2. 接下来这种方式使用Document，使用不像上面那么方便
#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/writer.h"
void Serialize_2()
{
rapidjson::Document doc;
doc.SetObject();
rapidjson::Document::AllocatorType& allocator = doc.GetAllocator();
//1. 整型类型
doc.AddMember("Int", 1, allocator);
//2. 浮点类型
doc.AddMember("Double", 12.00001, allocator);
//3. 字符串类型
//正确方式
string str= "This is a string";
rapidjson::Value str_value(rapidjson::kStringType);
str_value.SetString(str.c_str(), str.size());
if(!str_value.IsNull())
{
doc.AddMember("String", str_value, allocator);
}
/**
* 注：以下方式不正确，可能成功，也可能失败，因为字符串写入json要重新开辟内存，
* 如果使用该方式的话，当数据是字符串常量的话是没问题的，如果为变量就会显示乱码，所
* 以为保险起见，我们显式的分配内存(无需释放)
*/
//doc.AddMember("String", str.data(), allocator);
//4. 结构体类型
rapidjson::Value object(rapidjson::kObjectType);
object.AddMember("name", "qq849635649", allocator); //注：常量是没有问题的
object.AddMember("age", 25, allocator);
doc.AddMember("Object", object, allocator);
//5. 数组类型
//5.1 整型数组
rapidjson::Value IntArray(rapidjson::kArrayType);
IntArray.PushBack(10, allocator);
IntArray.PushBack(20, allocator);
IntArray.PushBack(30, allocator);
doc.AddMember("IntArray", IntArray, allocator);
//5.2 浮点型数组
rapidjson::Value DoubleArray(rapidjson::kArrayType);
DoubleArray.PushBack(1.0, allocator);
DoubleArray.PushBack(2.0, allocator);
DoubleArray.PushBack(3.0, allocator);
doc.AddMember("DoubleArray", DoubleArray, allocator);
//5.3 字符型数组
rapidjson::Value StringArray(rapidjson::kArrayType);
string strValue1 = "one";
string strValue2 = "two";
string strValue3 = "three";
str_value.SetString(strValue1.c_str(), strValue1.size());
StringArray.PushBack(str_value, allocator);
str_value.SetString(strValue2.c_str(), strValue2.size());
StringArray.PushBack(str_value, allocator);
str_value.SetString(strValue3.c_str(), strValue3.size());
StringArray.PushBack(str_value, allocator);
doc.AddMember("StringArray", StringArray, allocator);
//5.4 结构体数组
rapidjson::Value ObjectArray(rapidjson::kArrayType);
for(int i = 1; i < 4; i++)
{
rapidjson::Value obj(rapidjson::kObjectType);
obj.AddMember("name", "qq849635649", allocator);//注：常量是没有问题的
obj.AddMember("age", i * 10, allocator);
ObjectArray.PushBack(obj, allocator);
}
doc.AddMember("ObjectArray", ObjectArray, allocator);
rapidjson::StringBuffer strBuf;
rapidjson::Writer writer(strBuf);
doc.Accept(writer);
string data = strBuf.GetString();
cout << data << endl;
} 下面是解析的代码，同样的，采用的依旧上面那个json字符串，分门别类的已经整理好
#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/writer.h"
string data =
"{\"Int\":1,"
"\"Double\":12.0000001,"
"\"String\":\"This is a string\","
"\"Object\":{\"name\":\"qq849635649\",\"age\":25},"
"\"IntArray\":[10,20,30],"
"\"DoubleArray\":[1.0,2.0,3.0],"
"\"StringArray\":[\"one\",\"two\",\"three\"],"
"\"MixedArray\":[\"one\",50,false,12.005],"
"\"People\":[{\"name\":\"qq849635649\",\"age\":0,\"sex\":true},"
"{\"name\":\"qq849635649\",\"age\":10,\"sex\":false},"
"{\"name\":\"qq849635649\",\"age\":20,\"sex\":true}]}";
void parse() {
//创建解析对象
rapidjson::Document doc;
//首先进行解析，没有解析错误才能进行具体字段的解析
if(!doc.Parse(data.data()).HasParseError())
{
//1. 解析整数
if(doc.HasMember("Int") && doc["Int"].IsInt())
{
cout << "Int = " << doc["Int"].GetInt() << endl;
}
//2. 解析浮点型
if(doc.HasMember("Double") && doc["Double"].IsDouble())
{
cout << "Double = " << doc["Double"].GetDouble() << endl;
}
//3. 解析字符串
if(doc.HasMember("String") && doc["String"].IsString())
{
cout << "String = " << doc["String"].GetString() << endl;
}
//4. 解析结构体
if(doc.HasMember("Object") && doc["Object"].IsObject())
{
const rapidjson::Value& object = doc["Object"];
if(object.HasMember("name") && object["name"].IsString())
{
cout << "Object.name = " << object["name"].GetString() << endl;
}
if(object.HasMember("age") && object["age"].IsInt())
{
cout << "Object.age = " << object["age"].GetInt() << endl;
}
}
//5. 解析数组类型
//5.1 整型数组类型
if(doc.HasMember("IntArray") && doc["IntArray"].IsArray())
{
//5.1.1 将字段转换成为rapidjson::Value类型
const rapidjson::Value& array = doc["IntArray"];
//5.1.2 获取数组长度
size_t len = array.Size();
//5.1.3 根据下标遍历，注意将元素转换为相应类型，即需要调用GetInt()
for(size_t i = 0; i < len; i++)
{
cout << "IntArray[" << i << "] = " << array[i].GetInt() << endl;
}
}
//5.2 浮点型数组类型
if(doc.HasMember("DoubleArray") && doc["DoubleArray"].IsArray())
{
const rapidjson::Value& array = doc["DoubleArray"];
size_t len = array.Size();
for(size_t i = 0; i < len; i++)
{
//为防止类型不匹配，一般会添加类型校验
if(array[i].IsDouble())
{
cout << "DoubleArray[" << i << "] = " << array[i].GetDouble() << endl;
}
}
}
//5.3 字符串数组类型
if(doc.HasMember("StringArray") && doc["StringArray"].IsArray())
{
const rapidjson::Value& array = doc["StringArray"];
size_t len = array.Size();
for(size_t i = 0; i < len; i++)
{
//为防止类型不匹配，一般会添加类型校验
if(array[i].IsString())
{
cout << "StringArray[" << i << "] = " << array[i].GetString() << endl;
}
}
}
//5.4 混合型
if(doc.HasMember("MixedArray") && doc["MixedArray"].IsArray())
{
const rapidjson::Value& array = doc["MixedArray"];
size_t len = array.Size();
for(size_t i = 0; i < len; i++)
{
//为防止类型不匹配，一般会添加类型校验
if(array[i].IsString())
{
cout << "MixedArray[" << i << "] = " << array[i].GetString() << endl;
}
else if(array[i].IsBool())
{
cout << "MixedArray[" << i << "] = " << array[i].GetBool() << endl;
}
else if(array[i].IsInt())
{
cout << "MixedArray[" << i << "] = " << array[i].GetInt() << endl;
}
else if(array[i].IsDouble())
{
cout << "MixedArray[" << i << "] = " << array[i].GetDouble() << endl;
}
}
}
//5.5 结构体数组类型
if(doc.HasMember("People") && doc["People"].IsArray())
{
const rapidjson::Value& array = doc["People"];
size_t len = array.Size();
for(size_t i = 0; i < len; i++)
{
const rapidjson::Value& object = array[i];
//为防止类型不匹配，一般会添加类型校验
if(object.IsObject())
{
cout << "ObjectArray[" << i << "]: ";
if(object.HasMember("name") && object["name"].IsString())
{
cout << "name=" << object["name"].GetString();
}
if(object.HasMember("age") && object["age"].IsInt())
{
cout << ", age=" << object["age"].GetInt();
}
if(object.HasMember("sex") && object["sex"].IsBool())
{
cout << ", sex=" << (object["sex"].GetBool() ? "男" : "女") << endl;
}
}
}
}
}
/**
* 最后注意：因为rapidjson不会做安全校验，所以要自己做安全校验，以int整型为例
* “if(object.HasMember("age") && object["age"].IsInt()) {}”
* 这句校验很重要，既要校验有该子段，也要校验类型正确，否则会引发程序崩溃
*/
}还有一种解析方法，这是用于事先不知道name的前提之下，遍历读取，如果已知name，建议使用上面，如果不知道name，则使用下面这种方式
//遍历解析
void parse_1()
{
// 这个是用于遍历json数组，用于不知道name的前提下
string data = "{\"name\":\"qq849635649\",\"age\":20,\"sex\":true}";
rapidjson::Document dom;
if(! dom.Parse(data.data()).HasParseError())
{
for (rapidjson::Value::ConstMemberIterator iter = dom.MemberBegin(); iter != dom.MemberEnd(); ++iter)
{
string name = (iter->name).GetString();
const rapidjson::Value& value = iter->value;
if(value.IsString())
{
cout << name << " : " << value.GetString() << endl;
}
else if(value.IsInt())
{
cout << name << " : " << value.GetInt() << endl;
}
else if(value.IsBool())
{
cout << name << " : " << value.GetBool() << endl;
}
}
}
}