rapidjosn基本操作

2021-02-05

字数统计: 1.4k字 | 阅读时长≈ 6分

总结rapidjson的基本操作

rapidjson 基本操作
rapidjson中每个节点都是一个Value, 可以表示7种基本数据类型：int32_t, uint32_t, int64_t, uint64_t, float, double, bool, 以及string, array, object, array就相当于数组类型与std::vector类似, object相当于字典map类型, 它的key只能是string, value可以是任意的Value类。

1. 普通数据类型

Value v;    // Null
v.SetInt(10);
v = 10;     // 简写，和上面的相同
Value b(true);    // 调用 Value(bool)
Value i(-123);    // 调用 Value(int)
Value u(123u);    // 调用 Value(unsigned)
Value d(1.5);     // 调用 Value(double)

Value a(1);
Value b(3);
a = b; // 由于转移语句，b 为 NULL
// string
Document d;
char buffer[10];
Value v(buffer, d.GetAllocator());  // 自动调用strlen 计算长度, 无法处理空字符串
Value v(buffer, 10, d.GetAllocator()); // 可处理空字符串
Value v(buffer, 10); // 不加allocator，不复制字符串，原字符串改变,v内容也改变
Value v;
v.SetString("value"); // 对于常量推荐用这种，长度在编译器推导，同时不进行复制
v.SetString(buffer, 10, d.GetAllocator()); // 与构造函数相似
``` 

## 2. Object

```c++
rapidjson::Document d;
d.SetObject();  // 首先需要设置类型
rapidjson::Document d(rapidjson::kObjectType)  // 或者初始化时设置

访问元素

if (d.HasMember("name")){
    rapidjson::Value& v = d["name"];  // []访问需要加判断，赋值只能用引用方式
}
// 迭代器访问
rapidjson::Value::MemberIterator iter = d.FindMember("name");
if (iter != d.MemberEnd()) { iter->name; iter->value; }
for (rapidjson::Value::MemberIterator iter = d.MemberBegin(); iter != d.MemberEnd(); ++iter) { //... }

// c++11 支持
for (auto& m : d.GetObject())
    printf("Type of member %s is %s\n", m.name.GetString(), kTypeNames[m.value.GetType()]);

修改元素

// 添加int,bool,double
// d.AddMember("name", Value(1.0), d.GetAllocator()); // 官方文档说临时变量不能通过编译，但是我测了一下可以通过？
d.AddMember("name", Value(1.0).Move(), d.GetAllocator());  // 加Move返回引用
d.AddMember("name", Value().SetInt(1), d.GetAllocator());  
// 添加string
d.AddMember("name", "value", d.GetAllocator());
d.AddMember("name", rapidjson::Value("123").Move(), d.GetAllocator());
std::string str = "123";
d.AddMember("name", rapidjson::Value(str.c_str(), str.size(), d.GetAllocator()).Move(), d.GetAllocator());
rapidjson::Value v("123", d.GetAllocator());
d.AddMember("name", v, d.GetAllocator());  // v变为NULL
d.AddMember(rapidjson::Value("name").Move(), v, d.GetAllocator()); // key 也为一个Value类型 

// 删除元素
bool RemoveMember(const Ch* name)：使用键名来移除成员（线性时间复杂度）。
bool RemoveMember(const Value& name)：除了 name 是一个 Value，和上一行相同。
MemberIterator RemoveMember(MemberIterator)：使用迭代器移除成员（_ 常数 _ 时间复杂度）。
MemberIterator EraseMember(MemberIterator)：和上行相似但维持成员次序（线性时间复杂度）。
MemberIterator EraseMember(MemberIterator first, MemberIterator last)：移除一个范围内的成员，维持次序（线性时间复杂度）。
MemberIterator RemoveMember(MemberIterator) 使用了“转移最后”手法来达成常数时间复杂度。基本上就是析构迭代器位置的成员，然后把最后的成员转移至迭代器位置。因此，成员的次序会被改变。

// 修改某个key value, 可以通过迭代器
rapidjson::Value::MemberIterator iter = d.FindMember("name");
if (iter != d.MemberEnd()){
    iter->name.SetString("change_name");
}

3. Array

1
2
3

rapidjson::Document d;
d.SetArray();
rapidjson::Document d(rapidjson::kArrayType); // 同object

访问

assert(d.IsArray());
// 索引访问
for (uint32_t i = 0; i < a.Size(); i++){  // 与std::vector不同，用的是unsigned int
        rapidjson::Value& v = d[i];
}
// 迭代器访问
for (rapidjson::Value::ValueIterator iter = d.Begin(); iter != d.End(); ++iter){
        iter->GetInt();
}
// c++11
for (auto& v : d.GetArray())
    printf("%d ", v.GetInt());

修改

// 基本与object相似, 大量使用move操作
// API与std::vector相似
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)
// 添加
d.PushBack(2, d.GetAllocator());
d.PushBack("value", d.GetAllocator());
std::string str = "value";
d.PushBack(rapidjson::Value(str.c_str(), str.size(), d.GetAllocator()).Move(), d.GetAllocator());
// 流畅接口（Fluent interface）,因为返回的是本身的引用
d.PushBack("Lua", d.GetAllocator()).PushBack("Mio", d.GetAllocator());

4. Value 和 string转换

#include <rapidjson/document.h>
#include <rapidjson/stringbuffer.h>
#include <rapidjson/prettywriter.h>
#include <rapidjson/error/en.h>
#include <string>
#include <iostream>
bool StringToJson(const std::string &str, rapidjson::Document &document) {
    document.Parse(str.c_str());
    if (document.HasParseError())
    {
        rapidjson::ParseErrorCode code = document.GetParseError();
        std::cout << "Json parse error:" << GetParseError_En(code) << std::endl;
        return false;
    }
    return true;
}

std::string JsonToString(const rapidjson::Value &value, bool prettyWriter=false) {
    rapidjson::StringBuffer buffer;
    if (prettyWriter) {
        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
        writer.SetIndent(' ', 4);
        value.Accept(writer);
    } else {
        rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
        value.Accept(writer);
    }
    return std::string(buffer.GetString(), buffer.GetSize());
}

5. 关于 allocator, 拷贝操作，移动操作

rapidjson 给每个document分配了allocator, 当一个document析构时对应的allocator也析构了，而rapidjson基本都是移动操作，有时会出现问题，例如一个document(d1)里的部分Value(v1)是通过另一个document(d2)的allocator分配的，那么当d2析构时，分配的v1的内存随时可能被操作系统回收，就会出现空悬指针，可能导致coredump。

rapidjson::Document* d1 = new rapidjson::Document(rapidjson::kTypeObject);
rapidjson::Document* d2 = new rapidjson::Document(rapidjson::kTypeObject);
d1->AddMember("name", "value", d1->GetAllocator());
d2->AddMember("name2", "value2", d1->GetAllocator());
d1->AddMember("d2", *d2, d1->GetAllocator());  // 此时d2为null
delete d2;  // 这时把d2析构掉，如果直接遍历d1可能不会有什么问题，但是之后若执行大段代码导致d2分配的内存被覆盖就会出错。

因此一个document里的Value最好都用同一个allocator分配，实在不行的话，就要确保不同的document的生命周期一致。
比较省事的操作：

rapidjson::Document d1;
rapidjson::Document d2(&d1.GetAllocator());  // 将d1的allocator赋给d2

// 或者直接深拷贝
d1.AddMember("d2", rapidjson::Value().CopyFrom(d2, d1.GetAllocator()), d1.GetAllocator());

参考

官方文档：http://rapidjson.org/zh-cn/
github：https://github.com/Tencent/rapidjson

本文作者： JiXiaw
本文链接： http://jixiaw.github.io/2021/02/05/rapidjson/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！