enum Type {
kNullType = 0,
kFalseType = 1,
kTrueType = 2,
kObjectType = 3,
kArrayType = 4,
kStringType = 5,
kNumberType = 6
在官网教程中，我们看到了下面的例子，即通过迭代器访问所有的Object成员：代码片段如下
static const char* kTypeNames[] =
;
for (Value::ConstMemberIterator itr = document.MemberBegin();
itr != document.MemberEnd(); ++itr)
printf("Type of member %s is %s\n",
itr->name.GetString(), kTypeNames[itr->value.GetType()]);
代码对应的输出如下：
Type of member hello is String
Type of member t is True
Type of member f is False
Type of member n is Null
Type of member i is Number
Type of member pi is Number
Type of member a is Array
若我们不确定一个成员是否存在，便需要在调用 operator[](const char*) 前先调用 HasMember()。然而，这会导致两次查找。更好的做法是调用 FindMember()，它能同时检查成员是否存在并返回它的 Value：
Value::ConstMemberIterator itr = document.FindMember("hello")
if (itr != document.MemberEnd())
printf("%s\n", itr->value.GetString())
2.7 查询Number
JSON 只提供一种数值类型──Number。数字可以是整数或实数。RFC 4627 规定数字的范围由解析器指定。
由于 C++ 提供多种整数及浮点数类型，DOM 尝试尽量提供最广的范围及良好性能。
当解析一个 Number 时, 它会被存储在 DOM 之中，成为下列其中一个类型：
类型 描述
unsigned 32 位无号整数
int 32 位有号整数
uint64_t 64 位无号整数
int64_t 64 位有号整数
double 64 位双精度浮点数
当查询一个 Number 时, 你可以检查该数字是否能以目标类型来提取：
查检 提取
bool IsNumber() 不适用
bool IsUint() unsigned GetUint()
bool IsInt() int GetInt()
bool IsUint64() uint64_t GetUint64()
bool IsInt64() int64_t GetInt64()
bool IsDouble() double GetDouble()
注意，一个整数可能用几种类型来提取，而无需转换。例如，一个名为 x 的 Value 包含 123，那么 x.IsInt() == x.IsUint() == x.IsInt64() == x.IsUint64() == true。但如果一个名为 y 的 Value 包含 -3000000000，那么仅会令 x.IsInt64() == true。
当要提取 Number 类型，GetDouble() 是会把内部整数的表示转换成 double。注意 int 和 unsigned 可以安全地转换至 double，但 int64_t 及 uint64_t 可能会丧失精度（因为 double 的尾数只有 52 位）。
2.8 比较两个Value
你可使用 == 及 != 去比较两个 Value。当且仅当两个 Value 的类型及内容相同，它们才当作相等。你也可以比较 Value 和它的原生类型值。以下是一个例子。
if (document["hello"] == document["n"]) /*...*/; // 比较两个值
if (document["hello"] == "world") /*...*/; // 与字符串家面量作比较
if (document["i"] != 123) /*...*/; // 与整数作比较
if (document["pi"] != 3.14) /*...*/; // 与 double 作比较
Array／Object 顺序以它们的元素／成员作比较。当且仅当它们的整个子树相等，它们才当作相等。
3. 创建/修改值
有多种方法去创建值。 当一个 DOM 树被创建或修改后，可使用 Writer 再次存储为 JSON。
当使用默认构造函数创建一个 Value 或 Document，它的类型便会是 Null。要改变其类型，需调用 SetXXX() 或赋值操作，例如：
Document d;
d.SetObject();
Value v;
v.SetInt(10);
v = 10;
3.1 构造函数的各个重载
几个类型也有重载构造函数：
Value b(true); // 调用 Value(bool)
Value i(-123); // 调用 Value(int)
Value u(123u); // 调用 Value(unsigned)
Value d(1.5); // 调用 Value(double)
要重建空 Object 或 Array，可在默认构造函数后用 SetObject()/SetArray()，或一次性使用 Value(Type)：
Value o(kObjectType);
Value a(kArrayType);
3.2 转移语义[Move Semantics]
Value复制指的是在两个Value进行复制时不是传统意义上的把来源 Value 复制至目的 Value，而是把把来源 Value 转移（move）至目的 Value。
Value a(123);
Value b(456);
b = a; // a 变成 Null，b 变成数字 123。
3.3 创建String
RapidJSON 提供两个 String 的存储策略。
1. copy-string: 分配缓冲区，然后把来源数据复制至它。
2. const-string: 简单地储存字符串的指针。
Copy-string 总是安全的，因为它拥有数据的克隆。Const-string 可用于存储字符串字面量，以及用于在 DOM 一节中将会提到的 in-situ 解析中。
为了让用户自定义内存分配方式，当一个操作可能需要内存分配时，RapidJSON 要求用户传递一个 allocator 实例作为 API 参数。此设计避免了在每个 Value 存储 allocator（或 document）的指针。
当我们把一个 copy-string 赋值时, 调用含有 allocator 的 SetString() 重载函数：
Document document;
Value author;
char buffer[10];
int len = sprintf(buffer, "%s %s", "Milo", "Yip"); // 动态创建的字符串。
author.SetString(buffer, len, document.GetAllocator());
memset(buffer, 0, sizeof(buffer));
// 清空 buffer 后 author.GetString() 仍然包含 "Milo Yip"
最后，对于字符串字面量或有安全生命周期的字符串，可以使用 const-string 版本的 SetString()，它没有 allocator 参数。对于字符串家面量（或字符数组常量），只需简单地传递字面量，又安全又高效：
Value s;
s.SetString("rapidjson");
s = "rapidjson";
可以通过C++的std::string结构创建rapidjson的String结构，可以通过这种方式创建rapidjson的字符串，代码中同时演示了吧Value转换成std::string的方法，代码示例如下：
std::list<DeviceIdPannelInfo>::const_iterator iter = Remotes.begin();
*Document document;
Document::AllocatorType& allocator = document.GetAllocator();
Value StateInfos(kArrayType);*
for (; iter != Remotes.end(); iter++)
int DevState;
std::string DeviceIdToSearch(iter->deviceId);
int DevicePanelId = iter->panelId;
*Value state(kObjectType);*
int sdkRet = HikTalk_GetDevStatus(const_cast<char*>(DeviceIdToSearch.c_str()), DevicePanelId, &DevState, const_cast<char*>(m_ServerId.c_str()), const_cast<char*>(m_ServerIp.c_str()), m_ServerPort);
if (sdkRet != HIKTALK_E_OK)
TALKCLIENTPLUGIN_ERROR("- Get Device state fail, the deviceId is %s, the errCode is %d", DeviceIdToSearch.c_str(), sdkRet);
Msg = "Get Device State Fail";
return DEV_ERR_FAILED;
}else
Value TempId;
*TempId.SetString(DeviceIdToSearch.c_str(), DeviceIdToSearch.length(), allocator);*
*state.AddMember(TempId, DevState, allocator);*
*StateInfos.PushBack(state, allocator);*
rapidjson::StringBuffer sbBuffer;
rapidjson::Writer<rapidjson::StringBuffer> jWriter(sbBuffer);
StateInfos.Accept(jWriter);
TALKCLIENTPLUGIN_TRACE("- CHikIntercomDevice::GetDeviceState ends");
Msg = std::string(sbBuffer.GetString());
TALKCLIENTPLUGIN_DEBUG("- Msg: %s", Msg.c_str());
return DEV_ERR_SUCCESS;
上面的代码中演示了如果通过C++标准库std::string创建rapidjson的对象的过程。关键语句为
TempId.SetString(DeviceIdToSearch.c_str(), DeviceIdToSearch.length(), allocator);
在工作中实践rapidjson的使用，按照自己的目的来输入和输出是最紧要的事情。
3.4 修改Array
Array 类型的 Value 提供与 std::vector 相似的 API。
• Clear()
• Reserve(SizeType, Allocator&)
• Value& PushBack(Value&, Allocator&)
• template <typename T> GenericValue& PushBack(T, Allocator&)
• Value& PopBack()
• ValueIterator Erase(ConstValueIterator pos)
• ValueIterator Erase(ConstValueIterator first, ConstValueIterator last)
注意，Reserve(…) 及 PushBack(…) 可能会为数组元素分配内存，所以需要一个 allocator。一个简单示例：
Value a(kArrayType)
Document::AllocatorType& allocator = document.GetAllocator()
for (int i = 5
a.PushBack(i, allocator)
// 流畅接口（Fluent interface）
a.PushBack("Lua", allocator).PushBack("Mio", allocator)
PushBack()/PopBack() 返回 Array本身的引用。这称为流畅接口（_fluent interface_）。
Value v(kArrayType)
Value v1(kObjectType)
v1.AddMember("1", "2", d.GetAllocator())
v.PushBack(1, d.GetAllocator()).PushBack("1", d.GetAllocator()).PushBack(v1, d.GetAllocator())
std::string str = JsonToString(v)
输出的结果如下：
{“project”:”rapidjson”,”stars”:11}
[1,”1”,{“1”:”2”}]
上面的代码片段表明，可以在一个在一个类型为数组的Value中添加任意类型的元素。
3.5 修改Object
Object 是键值对的集合。每个键必须为 String。要修改 Object，方法是增加或移除成员。对于集合的操作包括添加成员，删除成员，修改成员。
• Value& AddMember(StringRefType, Value&, Allocator&)template <typename T>
• Value& AddMember(StringRefType, T value, Allocator&)
• Value& AddMember(Value&, Value&, Allocator& allocator)
上述的方法为向一个类型为kObjectType的Value添加键值对的方法。
Value contact(kObject);
contact.AddMember(“name”, “Milo”, document.GetAllocator());
contact.AddMember(“married”, true, document.GetAllocator());
如果你需要从非常数字符串或生命周期不足的字符串创建键名（见 创建 String），你需要使用 copy-string API。为了避免中间变量，可以就地使用 临时值：
// 就地 Value 参数
contact.AddMember(Value("copy", document.GetAllocator()).Move(),
Value().Move(),
document.GetAllocator());
Value key("key", document.GetAllocator());
Value val(42);
contact.AddMember(key, val, document.GetAllocator());
• bool RemoveMember(const Ch* name)：使用键名来移除成员（线性时间复杂度）。
• bool RemoveMember(const Value& name)：除了 name 是一个 Value，和上一行相同。
• MemberIterator RemoveMember(MemberIterator)：使用迭代器移除成员（_ 常数 _ 时间复杂度）。
• MemberIterator EraseMember(MemberIterator)：和上行相似但维持成员次序（线性时间复杂度）。
• MemberIterator EraseMember(MemberIterator first, MemberIterator last)：移除一个范围内的成员，维持次序（线性时间复杂度）。
3.6 深拷贝
若我们真的要复制一个 DOM 树，我们可使用两个 APIs 作深复制：含 allocator 的构造函数及 CopyFrom()：
Document d;
Document::AllocatorType& a = d.GetAllocator();
Value v1("foo");
Value v2(v1, a);
assert(v1.IsString());
d.SetArray().PushBack(v1, a).PushBack(v2, a);
assert(v1.IsNull() && v2.IsNull());
v2.CopyFrom(d, a);
assert(d.IsArray() && d.Size() == 2);
v1.SetObject().AddMember("array", v2, a);
d.PushBack(v1, a);
3.7 交换Value
3.8 解析json然后重新生成json字符串
3.7.1 Document转化为json字符串
之前主要是这个过程看不太明白，因此在网上看到了如下的代码片段，通过Writer将Value转换成json合适的数据格式。而Reader则是把json字符串转换成Value。
下载rapidjson-master.zip，解压后，把include文件夹拷贝到自己的工程中就可以使用了
只需要include，不需要加载.lib,.dll
#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/stringbuffer.h"
#include <iostream>
using namespace rapidjson;
int main() {
const char* json = "{\"project\":\"rapidjson\",\"stars\":10}";
Document d;
d.Parse(json);
if (!d.HasParseError())
Value& s = d["stars"];
Value：value其实就是var，对于value可以理解为int，也是理解为string，或者是bool型变量等其他数据类型。对于定义Value value，只是一个定义，还没有决定其数据类型，如果明确value的值，则相应确定其数据类型了。
Json数据类型是一个map，表示为key-value形式，对于Value转换为基础数据类型有
一下几种方法：
vall.SetArray() vall.SetArrayRaw() vall.SetBool() vall.SetDouble() vall.SetInt()
vall.SetNull() vall.SetObject() vall.SetString() vall.SetStringRaw() vall.SetUint();
同时，对于value的数据类型，是可以重复设置。
s.SetInt(s.GetInt() + 1);
StringBuffer buffer;
Writer<StringBuffer> writer(buffer);
d.Accept(writer);
std::cout << buffer.GetString() << std::endl;
return 0;
上述的代码片段通过StringBuffer作为桥梁，把Document的变量d转化到缓冲数组buffer中，此时输出结果在代码里有显示。这是具体的过程。
3.7.2 Value转化为json字符串
直接通过Value转化为json字符串的代码片段如下
#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/stringbuffer.h"
string strJsonTest = "{\"item_1\":{\"sub_item_1\":\"value_1\",\"sub_item_2\":\"value_2\",\"sub_item_3\":\"value_3\"},\"item_2\":\"value_2\"}"
int main(void) {
Document docTest
docTest.Parse<0>(strJsonTest.c_str())
if (!docTest.HasParseError())
if (docTest.HasMember("item_1"))
rapidjson::Value& valObj = docTest["item_1"]
rapidjson::StringBuffer sbBuf
rapidjson::Writer<rapidjson::StringBuffer> jWriter(sbBuf)
valObj.Accept(jWriter)
std::string strTemp = std::string(sbBuf.GetString())
//strTemp的内容为 {\"sub_item_1\":\"value_1\",\"sub_item_2\":\"value_2\",\"sub_item_3\":\"value_3\"}
把该过程封装函数如下：
std::string JsonToString(const rapidjson::Value& valObj)
rapidjson::StringBuffer sbBuf
rapidjson::Writer<rapidjson::StringBuffer> jWriter(sbBuf)
valObj.Accept(jWriter)
return std::string(sbBuf.GetString())
4. 代码片段–实践出真知
4.1 rapidjson的Value的组成和Value到std::string的转换
下述代码片段描述了使用rapidjson所要包含的常用头文件和基本使用。演示了从Value到String对象的转换，并且也简单演示了Value取不同类型的赋值，即构造Json串的过程。
#include <stdio.h>
#include <stdio.h>
#include <string>
#include <iostream>
#include "rapidjson/document.h"
#include "rapidjson/prettywriter.h"
#include "rapidjson/filestream.h"
#include "rapidjson/stringbuffer.h"
using namespace std;
using namespace rapidjson;
int main(int argc, char *argv[])
printf("Lu//a\"\n");
Document document;
Document::AllocatorType& allocator = document.GetAllocator();
Value contact(kArrayType);
Value contact2(kArrayType);
Value root(kArrayType);
contact.PushBack("Lu//a\"", allocator).PushBack("Mio", allocator).PushBack("", allocator);
contact2.PushBack("Lu// a", allocator).PushBack("Mio", allocator).PushBack("", allocator);
root.PushBack(contact, allocator);
root.PushBack(contact2, allocator);
StringBuffer buffer;
Writer<StringBuffer> writer(buffer);
root.Accept(writer);
string reststring = buffer.GetString();
cout << reststring << endl;
return 0;
输出结果如下所示：
Lu//a"
[["Lu//a\"","Mio",""],["Lu// a","Mio",""]]
对象JSON
下述代码片段包含的重要内容就是如何通过std::string类型的对象创建一个含有相应值得Value(kStringType)对象，并且添加到Value(kObjectType)对象中的演示。
void TestJson2()
Document document
//获得分配器
Document::AllocatorType& allocator = document.GetAllocator()
//root为kObjectType
Value root(kObjectType)
//storage_photo_count为Value的String类型，注意定义的格式
Value storage_photo_count(kStringType)
//使用std::string类型的构造方式创建了一个std::string值
std::string storage_photo_count_str("49")
//通过Value的SetString方法把一个std::string类型对象的内容赋值给了rapidjson的String对象
storage_photo_count.SetString(storage_photo_count_str.c_str(),
storage_photo_count_str.size(),allocator)
Value storage_music_count(kStringType)
std::string storage_music_count_str("48")
storage_music_count.SetString(storage_music_count_str.c_str(),
storage_music_count_str.size(),allocator)
//root为对象，添加成员的方式具有allocator，一个字符串字面值，一个Value(kStringType)
root.AddMember("storage.photo.count",storage_photo_count,allocator)
root.AddMember("storage.music.count",storage_music_count,allocator)
StringBuffer buffer
Writer<StringBuffer> writer(buffer)
root.Accept(writer)
std::string result = buffer.GetString()
cout << "result: " << result << "..........:" << result.size()<< endl
4.3 在Value(kObjectType)添加各种类型的值
rapidjson::Document::AllocatorType&allocator = doc.GetAllocator();
rapidjson::Value strObject(rapidjson::kStringType);
strObject.SetString("love");
doc.AddMember("hello1", strObject,allocator);
rapidjson::Value nullObject(rapidjson::kNullType);
doc.AddMember("null", nullObject,allocator);
rapidjson::Value array(rapidjson::kArrayType);
rapidjson::Value object(rapidjson::kObjectType);
object.AddMember("id", 1,allocator);
object.AddMember("name","lai", allocator);
object.AddMember("age", "12",allocator);
object.AddMember("low", true,allocator);
array.PushBack(object, allocator);
doc.AddMember("player", array,allocator);
rapidjson::Value& aArray1 = doc["a"];
aArray1.PushBack(2.0, allocator);
GitLab–综合例子
下面的例子几乎涵盖了rapidjson常用的各个方面，请在实践中体会。
#include "rapidjson/document.h" // rapidjson's DOM-style API
#include "rapidjson/prettywriter.h" // for stringify JSON
#include <cstdio>
using namespace rapidjson;
using namespace std;
int main(int, char*[]) {
const char json[] = " { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ";
printf("Original JSON:\n %s\n", json);
Document document;
#if 0
if (document.Parse(json).HasParseError())
return 1;
#else
char buffer[sizeof(json)];
memcpy(buffer, json, sizeof(json));
if (document.ParseInsitu(buffer).HasParseError())
return 1;
#endif
printf("\nParsing to document succeeded.\n");
printf("\nAccess values in document:\n");
assert(document.IsObject());
assert(document.HasMember("hello"));
assert(document["hello"].IsString());
printf("hello = %s\n", document["hello"].GetString());
Value::MemberIterator hello = document.FindMember("hello");
assert(hello != document.MemberEnd());
assert(hello->value.IsString());
assert(strcmp("world", hello->value.GetString()) == 0);
(void)hello;
assert(document["t"].IsBool());
printf("t = %s\n", document["t"].GetBool() ? "true" : "false");
assert(document["f"].IsBool());
printf("f = %s\n", document["f"].GetBool() ? "true" : "false");
printf("n = %s\n", document["n"].IsNull() ? "null" : "?");
assert(document["i"].IsNumber());
assert(document["i"].IsInt());
printf("i = %d\n", document["i"].GetInt());
assert(document["pi"].IsNumber());
assert(document["pi"].IsDouble());
printf("pi = %g\n", document["pi"].GetDouble());
const Value& a = document["a"];
assert(a.IsArray());
for (SizeType i = 0; i < a.Size(); i++)
printf("a[%d] = %d\n", i, a[i].GetInt());
int y = a[0].GetInt();
(void)y;
printf("a = ");
for (Value::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
printf("%d ", itr->GetInt());
printf("\n");
static const char* kTypeNames[] = { "Null", "False", "True", "Object", "Array", "String", "Number" };
for (Value::ConstMemberIterator itr = document.MemberBegin(); itr != document.MemberEnd(); ++itr)
printf("Type of member %s is %s\n", itr->name.GetString(), kTypeNames[itr->value.GetType()]);
uint64_t f20 = 1;
for (uint64_t j = 1; j <= 20; j++)
f20 *= j;
document["i"] = f20;
assert(!document["i"].IsInt());
Value& a = document["a"];
Document::AllocatorType& allocator = document.GetAllocator();
for (int i = 5; i <= 10; i++)
a.PushBack(i, allocator);
a.PushBack("Lua", allocator).PushBack("Mio", allocator);
document["hello"] = "rapidjson";
Value author;
char buffer2[10];
int len = sprintf(buffer2, "%s %s", "Milo", "Yip");
author.SetString(buffer2, static_cast<SizeType>(len), document.GetAllocator());
memset(buffer2, 0, sizeof(buffer2));
document.AddMember("author", author, document.GetAllocator());
assert(author.IsNull());
printf("\nModified JSON with reformatting:\n");
StringBuffer sb;
PrettyWriter<StringBuffer> writer(sb);
document.Accept(writer);
puts(sb.GetString());
return 0;
5. 引用
https://www.cnblogs.com/549294286/p/6067763.html
http://rapidjson.org/md_doc_tutorial.html#ValueDocument
rapidjson是什么 rapidjson是腾讯的开源Json解析框架，用C++代码实现，用于解析和生成JSON由于全部代码仅用头文件实现，因此很容易集成在项目中。根据其作者Milo Yipz所做的比较，可以看出rapidjson的性能非常可观。通过使用DOM（Document Object Model）可以很方便的将Json转化成DOM，然后查询修改，再转化为一个Json。通过rapidj...
采用pb11.5 + pbni + vs2015 + rapidjson的开源库，生成解析json,支持datawindow快速导入导出字段名有大写字母的json，支持dw导入出json时对指定字段进行des加密，并在导入到dw时时进行des解密，修改了pbvm115.dll(内存修改方法的文件，请看n_datastore的api定义)，
******2022-05-11更新说明，1.增加一种dw导入导出成json的方式，以列数组方式生成json数据，可以有效降低json字符串体积；2.增加dw按字符串列统计数值功能，例如收款记录报表，一般可能按付款方式汇总付款金额，如果要在此dw按收款记录的营销人员汇总收款金额，可以用此功能，比用纯PB写代码高效的多，此功能还可以作为图形报表的数据源；3.增加跟PB程序现有数据库连结的绑定（sqlca或者自建的transobject对象）(目前只支持SNC sqlserver 2008接口)，直接sql语句生成json的功能，会比dw浏览完数据再生成json要快很多。
rapidjson实现将得到的Value中的值变为string，主要应用如下场景
"{\"item_1\":{\"sub_item_1\":\"value_1\",\"sub_item_2\":\"value_2\",\"sub_item_3\":\"value_3\"},\"item_2\":\"value_2\"}中拿到item_1的值
#include "rapidjson
index.js
import styles from "./styles.css" ;
console . log ( styles ) ; // ".text{color:#162D3D}"
npm i --save-dev parcel-plugin-css-to-string
yarn add -D parcel-plugin-css-to-string
我建议对样式使用自定义扩展名，该扩展名将作为字符串导入。 对于全局样式或css-modules，这将有助于避免与.css文件的冲突。 默认资产类型css 。
您可以将自定义扩展列表添加到.parcelrc配置中。
例如： styles
"age":18,
"sub":["a","b"], //value是数组
"elp":[ {"a":"A","b":"B"}, //value是一个数组且里面每个元素又是一个json格式
Json 是一种轻量级数据交换格式，具有易于人阅读和编写，同时也易于机器解析和生成。相较于XML，json更小、读写更快、更易解析。另一方面，Rapidjson作为json的升级版，在效率方面，具有更好的优势。
Json语法规则
Rapdijson解析
数据读取、解析成json格式.......
RapidJSON 是一个 C++ 的 JSON 解析器及生成器。它的灵感来自 RapidXml。使用方法：RapidJSON: 首页http://rapidjson.org/zh-cn/index.html
这里 rapidjson 为作用域；
那么现在该 JSON 就会被解析至 中，成为一棵 *DOM 树 *:
让我们查询一下根 Object 中有没有 成员。由于一个 可包含不同类型的值，我们可能需要验证它的类型，并使用合适的 API 去获取其值。在此例中， 成员关联
string a;char b[4]={'a','b','c','d'};//string是字符串类型的数据，用b这个字符型数组演示
for(int i=0;i<4;i++)
a=a+b[i];
cout<<a;
以上可以简单的将一个字符数组转换为一个字.
我在使用VS2015进行调试（Debug x64）时，出现了如下图所示的错误信息，在网上查了大佬的介绍，最后得出结论，问题应该由代码运行时分配和释放堆内存不一致导致的。一般是指在使用std::vector&lt;&gt;时，会进行动态内存的分配和释放，当析构某个vector时，如果找不到vector分配的空间（也许已经释放过了），就会出现上述的问题。
我的解决方案是定位到：项目–属性–C/C+±...
#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/stringbuffer.h"
using namespace rapidjson;
int main() {
// 将string转换为rapidjson的Value类型
std::string jsonString = "{\"name\": \"小明\", \"age\": 18}";
Document document;
document.Parse(jsonString.c_str()); // 字符串转换为JSON对象
Value& name = document["name"]; // 取出name字段值
std::string nameStr = name.GetString(); // 将name字段值转换为string类型
// 将rapidjson的Value类型转换为string
StringBuffer buffer;
Writer<StringBuffer> writer(buffer);
document.Accept(writer); // 将JSON对象转换为字符串
std::string jsonStr = buffer.GetString(); // 将字符串存储到jsonStr中
return 0;
