Jsoncpp的安装与使用

knight-n

于 2024-09-02 07:24:18 发布

阅读量594

点赞数 23

分类专栏：开发工具文章标签： linux 服务器运维 c++ json

本文链接：https://blog.csdn.net/2301_80926085/article/details/141645060

版权

开发工具专栏收录该内容

3 篇文章 0 订阅

订阅专栏

JsonCpp 是一个C++库，用于解析和生成JSON数据。它支持解析JSON文件或字符串到C++对象，以及将C++对象序列化回JSON格式。

安装Jsoncpp

我们可以输入以下命令安装jsoncpp库。

sudo yum install -y jsoncpp-devel

安装时默认安装动态库。头文件存储在 /usr/include/jsoncpp/json 中。

库文件存储在 /lib64 中，我们可以简单查看一下。

Jsoncpp的使用

对于 jsoncpp 我们只需要掌握三个类就可以覆盖开发时的绝大多数场景。

Json::Value：

这是 JsonCpp 中最核心的类，用于表示 JSON 值。Json::Value 可以包含任何 JSON 类型的数据：对象（一组键值对）、数组、字符串、数字、布尔值（true/false）、null 值。你可以使用这个类来创建、查询和修改 JSON 数据。

Json::Reader：

Json::Reader 类用于解析 JSON 字符串。你可以使用这个类将一个符合 JSON 格式的字符串解析成一个 Json::Value 对象。这个过程称为 JSON 反序列化。

Json::Writer：

Json::Writer 类用于将 Json::Value 对象转换回 JSON 字符串。这个过程称为 JSON 序列化。Json::Writer 还可以格式化 JSON 数据，使其以易于阅读的方式输出。

Jsoncpp库中的类定义在命名空间 Json 中，在使用时我们需要声明命名空间。

Json 支持以下类型：

nullValue	空值
intValue	有符号整数
uintValue	无符号整数
realValue	浮点数
stringValue	字符串
booleanValue	布尔数
arrayValue	数组
objectValue	键值对

Value类

Value 类是数据的容器，它支持存储Json中的所有类型。Value为我们提供了各种类型的构造函数。

构造函数

默认构造函数：

Json::Value value; //创建一个空的value对象

构造一个具有特定类型的值：

Json::Value value(1); // 整数 
Json::Value value(1.0); // 浮点数 
Json::Value value("string"); // 字符串 
Json::Value value(true); // 布尔值

构造一个数组或对象：

Json::Value array(Json::arrayValue); // 空数组 
Json::Value object(Json::objectValue);// 空对象

复制构造函数：

Json::Value value1; Json::Value value2(value1); // value2 是 value1 的副本

构造一个具有特定值的数组或对象：

Json::Value array(Json::arrayValue); // 明确指定数组类型 
Json::Value object(Json::objectValue); // 明确指定对象类型

构造一个包含初始值的数组或对象：

Json::Value array(Json::arrayValue, 10); // 创建一个包含10个元素的数组，每个元素都是null
Json::Value object(Json::objectValue, 5); // 创建一个包含5个元素的对象

从另一个 JSON 值构造：

Json::Value value1("initial value"); 
Json::Value value2 = value1; // value2 是 value1 的副本

Jsoncpp也为我们提供了一系列的检测 Value 中存储的值。这些接口都很简单，从命名即可看出它们的作用，在此不过多介绍。

检测保存的数据类型

bool isNull() const;
bool isBool() const;
bool isInt() const;
bool isInt64() const;
bool isUInt() const;
bool isUInt64() const;
bool isIntegral() const;
bool isDouble() const;
bool isNumeric() const;
bool isString() const;
bool isArray() const;
bool isObject() const;

当我们从一个 Json::Value 对象中提取数据时，我们需要将它转换为相应的实际数据类型，同样Jsoncpp 为我们提供了相应的接口。

提取数据

// 将 Json::Value 对象转换为 int 类型。
Int asInt() const;
// 将 Json::Value 对象转换为 unsigned int 类型。
UInt asUInt() const;
// 将 Json::Value 对象转换为 int64_t 类型。
Int64 asInt64() const;
// 将 Json::Value 对象转换为 uint64_t 类型。
UInt64 asUInt64() const;
// 将 Json::Value 对象转换为最大的整数类型（long long 类型）。
LargestInt asLargestInt() const;
// 将 Json::Value 对象转换为最大的无符号整数类型（unsigned long long 类型）。
LargestUInt asLargestUInt() const;
// 将 Json::Value 对象转换为 std::string 类型。
JSONCPP_STRING asString() const;
// 将 Json::Value 对象转换为 float 类型。
float asFloat() const;
// 将 Json::Value 对象转换为 double 类型。
double asDouble() const;
// 将 Json::Value 对象转换为 bool 类型。
bool asBool() const;
// 将 Json::Value 对象转换为 C 风格的字符串（const char* 类型）。
const char* asCString() const;

在这些接口中，除了 asCString() 类型不匹配会返回空指针，其他接口在类型不匹配时都会则抛出 Json::TypeError。

这些接口都很简单，我们可以简单使用一下。

#include<jsoncpp/json/json.h>
#include<iostream>
using namespace Json;
int main()
{
    Value a(1234);
    if(a.isInt())
    {
        int b=a.asInt();
        std::cout << b << std::endl;
    }
    return 0;
}

因为 jsoncpp 是一个第三方库，所以编译时我们需要使用 -l 指定需要链接的库。

g++ -o test jsontest.cpp -ljsoncpp

可以看到程序按预期输出 1234 。

对于Json数组 Value 同样有一系列接口。

对json数组的操作

Json数组可以存储Json支持的所有类型，包括数组。

ArrayIndex size() const;

返回数组时的大小，即数组中的元素数量。

Value& operator[](ArrayIndex index);
Value& operator[](int index);

重载的 [] 运算符，用于访问 Json::Value 对象作为数组时指定索引的元素。返回 Json::Value 对象的引用，允许修改。

const Value& operator[](ArrayIndex index) const;
const Value& operator[](int index) const;

重载的 [] 运算符，用于访问 Json::Value 对象作为数组时指定索引的元素。返回 Json::Value 对象的常量引用，不允许修改。

Value get(ArrayIndex index, const Value& defaultValue) const;

使用指定的 index 下标访问 Json::Value 对象中的元素。如果 index 在有效范围内，返回对应的 Json::Value 对象。如果 index 无效，返回提供的 defaultValue。

Value& append(const Value& value);

向数组的末尾添加一个新元素，并返回对新元素的引用。

const_iterator begin() const;

返回一个迭代器，指向 Json::Value 对象作为数组或对象的第一个元素。这个迭代器是 const_iterator 类型，只能用于读取元素。

const_iterator end() const;

返回一个迭代器，指向 Json::Value 对象数组或对象末尾的下一个位置。这个迭代器是 const_iterator 类型，表示迭代结束的位置。

#include<jsoncpp/json/json.h>
#include<iostream>
using namespace Json;
int main()
{
    Value arr(arrayValue);
    Value a(1);
    Value b("hello world");
    arr.append(a);
    arr.append(b);

    int x=arr[0].asInt();
    const char* y=arr[1].asCString();

    std::cout << "arr[0]：" << x << std::endl;
    std::cout << "arr[1]：" << y << std::endl; 
    return 0;
}

iterator begin();

返回一个迭代器，指向 Json::Value 对象作为数组或对象的第一个元素。这个迭代器是 iterator 类型，允许修改元素。

iterator end();

返回一个迭代器，指向 Json::Value 对象数组或对象末尾的下一个位置。这个迭代器是 iterator 类型，表示迭代结束的位置。

我们简单使用一下：

#include<jsoncpp/json/json.h>
#include<iostream>
using namespace Json;
int main()
{
    Value arr(arrayValue);
    Value a(1);
    Value b("hello world");
    arr.append(a);
    arr.append(b);

    int x=arr[0].asInt();
    const char* y=arr[1].asCString();

    std::cout << "arr[0]：" << x << std::endl;
    std::cout << "arr[1]：" << y << std::endl; 
    return 0;
}

运行结果：

对Json对象的操作

JSON 对象由一系列键值对组成，其中每个键都是一个字符串，与一个值关联。JSON 对象的键值对是无序的，这意味着键值对的顺序可能会在不同的 JSON 对象中有所不同，但它们表示相同的数据。同时JSON 对象中的每个键都是唯一的，不允许有重复的键。

添加键值对：

obj["key1"] = "value1"; // 使用操作符 [] 添加键值对 obj["key2"] = 123; // 键可以关联不同类型的值

访问值：

Json::Value value = obj["key1"]; // 获取键 "key1" 对应的值

检查键是否存在：

if (obj.isMember("key1"))  // 键 "key1" 存在

获取所有键的名称：

Json::Value::Members members = obj.getMemberNames(); 
for (const auto& key : members) { std::cout << key << std::endl; }

Members是std::vector<std::string>的typedef别名。

修改值：

obj["key1"] = "new value"; // 修改已存在的键 "key1" 对应的值

删除键值对：

obj.removeMember("key1"); // 删除键 "key1" 及其对应的值

检查 JSON 对象是否为空：

bool isEmpty = obj.empty();

获取 JSON 对象的大小

Json::ArrayIndex size = obj.size(); // 返回对象中键值对的数量

我们简单演示一下使用。

#include<jsoncpp/json/json.h>
#include<iostream>
using namespace Json;
int main()
{
    Value obj(Json::objectValue);
    obj["age"]=18;
    obj["name"]="张三";
    Json::Value::Members members = obj.getMemberNames(); 
    for (const auto& key : members) 
    { 
        std::cout << key << std::endl; 
    }
    for (const auto &e : members)
    {
        std::cout << e << ":" << obj[e] << std::endl;
    }
    return 0;
}

我们运行一下。

Value也为我们提供了接口将对象序列化。

std::string toStyledString() const;

这个接口序列化出的字符串是带缩进与换行的，我们简单演示一下。

#include<jsoncpp/json/json.h>
#include<iostream>
#include<string>
using namespace Json;
int main()
{
    Value obj(Json::objectValue);
    obj["age"]=18;
    obj["name"]="张三";
    std::string s = obj.toStyledString();
    std::cout << s << std::endl;
    return 0;
}

运行结果

FastWriter类

在 JsonCpp 中，FastWriter可以将 Json::Value 对象转换为 JSON 格式的字符串。与StyledStreamWriter 不同，FastWriter 不进行任何美化（不添加空格和缩进），因此通常会产生更紧凑的输出，但写入速度更快。在网络通信中，我们通常用它将数据序列化为单行，便于进行网络数据的传输。

std::string Json::FastWriter::write(const Value& root);

我们只需要掌握这一个接口即可，它会将传入的对象序列化为单行的字符串。

我们简单使用一下。

#include<jsoncpp/json/json.h>
#include<iostream>
#include<string>
using namespace Json;
int main()
{
    Value obj(Json::objectValue);
    obj["age"]=18;
    obj["name"]="张三";
    FastWriter writer;
    std::string s=writer.write(obj);
    std::cout << s ;
    return 0;
}

运行结果：

Reader类

有序列化，就有反序列化，在将Json对象进行序列化后，我们可以通过 read 类进行反序列化，

bool Json::Reader::parse(const std::string& document,Value& root, bool collectComments = true);

参数:

document: json格式字符串
root: 传出参数, 存储了json字符串中解析出的数据
collectComments: 是否保存json字符串中的注释信息默认true

parse有其他重载，但在这里我们不过多介绍。这里我们简单演示一下parse的使用

#include<jsoncpp/json/json.h>
#include<iostream>
#include<string>
using namespace Json;
int main()
{
    Value obj(Json::objectValue);
    obj["age"]=18;
    obj["name"]="张三";
    FastWriter writer;
    std::string s=writer.write(obj);
    std::cout << s ;
    Reader reader;
    Value val;
    reader.parse(s,val);
    std::cout << val["age"] << std::endl;
    std::cout << val["name"] << std::endl;
    return 0;
}