用于在C++中表示 JSON 的数据类型

我认为你上一种方法的方向是正确的，但我认为它需要改变一些概念分配。

到目前为止，在我工作过的所有 JSON 解析器中，选择容器类型的决定是在用户端而不是在解析器端，我认为这是一个明智的决定，为什么？ 假设您有一个节点，其中包含一个字符串格式的数字：

{
    "mambo_number": "5"
}

您不知道用户是否希望以字符串或数字的形式检索值。因此，我要指出的是，JSONNumberNode和JSONStringNode不适合最佳方法。我的建议是创建用于保存对象、数组和原始值的节点。

所有这些节点都将包含一个标签（名称）和一个嵌套对象列表（根据其主要类型）：

• JSONNode：包含节点键和节点类型的基节点类。
• JSONValueNode：管理和包含原始值的节点类型，如上面列出的曼波nº5，它将提供一些函数来读取其值，如value_as_string()、value_as_int()、value_as_long()，到目前为止...
• JSONArrayNode ：管理 JSON 数组并包含按索引访问JSONNode节点类型。
• JSONObjectNode：管理 JSON 对象并包含可按名称访问JSONNode节点类型。

我不知道这个想法是否有据可查，让我们看看一些例子：

例 1

{
    "name": "murray",
    "birthYear": 1980
}

上面的 JSON 将是一个未命名的根JSONObjectNode，其中包含两个带有标签 name 和 birthYear 的JSONValueNode。

例 2

{
    "name": "murray",
    "birthYear": 1980,
    "fibonacci": [1, 1, 2, 3, 5, 8, 13, 21]
}

上面的 JSON 将是一个未命名的根JSONObjectNode，其中包含两个 JSONValueNode 和一个 JSONArrayNode 。JSONArrayNode将包含 8 个未命名的JSONObjectNode，其中包含斐波那契数列的 8 个前值。

例 3

{
    "person": { "name": "Fibonacci", "sex": "male" },
    "fibonacci": [1, 1, 2, 3, 5, 8, 13, 21]
}

上面的 JSON 将是一个未命名的根JSONObjectNode，其中包含一个带有两个JSONValueNode的JSONObjectNode，标签为 name 和 sex 以及一个JSONArrayNode。

例 4

{
    "random_stuff": [ { "name": "Fibonacci", "sex": "male" }, "random", 9],
    "fibonacci": [1, 1, 2, 3, 5, 8, 13, 21]
}

JSONObjectNode，第一个标记为 random_stuff 将包含 3 个未命名JSONValueNode其类型为 JSONObjectNode 、JSONValueNode 和 JSONValueNode 按出现顺序排列，第二个JSONArrayNode是之前注释的斐波那契数列。

实现

我将面对节点实现的方式如下：

基节点将通过成员type知道它自己的类型（值节点、数组节点或对象节点），type的值由派生类在构造时提供。

enum class node_type : char {
    value,
    array,
    object
}
class JSONNode {
public:
    JSONNode(const std::string &k, node_type t) : node_type(t) {}
    node_type GetType() { ... }
    // ... more functions, like GetKey()
private:
    std::string key;
    const node_type type;
};

派生类必须在构造时向基元提供节点的类型，值节点向用户提供存储值到用户请求的类型的转换：

class JSONValueNode : JSONNode {
public:
    JSONValueNode(const std::string &k, const std::string &v) :
        JSONNode(k, node_type::value) {} // <--- notice the node_type::value
    std::string as_string() { ... }
    int as_int() { ... }
    // ... more functions
private:
    std::string value;
}

数组节点必须提供operator[]才能将其用作数组;实现一些迭代器是值得的。内部std::vector的存储值（选择您认为最适合此目的的容器）将JSONNode 的。

class JSONArrayNode : JSONNode {
public:
    JSONArrayNode(const std::string &k, const std::string &v) :
        JSONNode(k, node_type::array) {} // <--- notice the node_type::array
    const JSONObjectNode &operator[](int index) { ... }
    // ... more functions
private:
    std::vector<JSONNode> values;
}

我认为对象节点必须为operator[]提供字符串输入，因为C++我们无法复制 JSON node.field 访问器，实现一些迭代器将是值得的。

class JSONObjectNode : JSONNode {
public:
    JSONObjectNode(const std::string &k, const std::string &v) :
        JSONNode(k, node_type::object) {} // <--- notice the node_type::object
    const JSONObjectNode &operator[](const std::string &key) { ... }
    // ... more functions
private:
    std::vector<JSONNode> values;
}

用法

假设所有节点都具有所有必需的功能，则使用我的aproach的想法将是：

JSONNode root = parse_json(file);
for (auto &node : root)
{
    std::cout << "Processing node type " << node.GetType()
              << " named " << node.GetKey() << 'n';
    switch (node.GetType())
    {
        case node_type::value:
            // knowing the derived type we can call static_cast
            // instead of dynamic_cast...
            JSONValueNode &v = static_cast<JSONValueNode>(node);
            // read values, do stuff with values
            break;
        case node_type::array:
            JSONArrayNode &a = static_cast<JSONArrayNode>(node);
            // iterate through all the nodes on the array
            // check what type are each one and read its values
            // or iterate them (if they're arrays or objects)
            auto t = a[100].GetType();
            break;
        case node_type::object:
            JSONArrayNode &o = static_cast<JSONObjectNode>(node);
            // iterate through all the nodes on the object
            // or get them by it's name check what type are
            // each one and read its values or iterate them.
            auto t = o["foo"].GetType();
            break;
    }
}

笔记

我不会使用Json-Whatever-Node命名约定，我倾向于将所有东西放入命名空间并使用较短的名称;在命名空间的范围之外，该名称非常可读且不可更改：

namespace MyJSON {
class Node;
class Value : Node;
class Array : Node;
class Object : Node;
Object o; // Quite easy, short and straightforward.
}
MyJSON::Node n;  // Quite readable, isn't it?
MyJSON::Value v;

我认为值得为每个对象创建空版本，以便在无效访问的情况下提供：

// instances of null objects
static const MyJSON::Value null_value( ... );
static const MyJSON::Array null_array( ... );
static const MyJSON::Object null_object( ... );
if (rootNode["nonexistent object"] == null_object)
{
    // do something
}

前提是：返回 null 对象类型，即访问对象节点中不存在的子对象或越界访问数组节点的情况。

希望对您有所帮助。

您的最后两个解决方案都有效。您在两者中的问题似乎是提取实际值，所以让我们看一下示例。我将介绍 POD 的想法，原因很简单，使用多态确实需要 RTTI，恕我直言，这很丑陋。

杰森：

{
    "foo":5
}

你加载这个JSON文件，你会得到的只是你的POD"包装器"。

json_wrapper wrapper = load_file("example.json");

现在，假设加载的 JSON 节点是 JSON 对象。您现在必须处理两种情况：要么它是对象，要么不是。如果不是，则最终可能会处于错误状态，因此可以使用例外。但是，您将如何提取对象本身呢？好吧，只需使用函数调用即可。

try {
    JsonObject root = wrapper.as_object();
} catch(JSONReadException e) {
    std::cerr << "Something went wrong!" << std::endl;
}

现在，如果wrapper包装的 JSON 节点确实是 JSON 对象，则可以继续在 try { 块中执行要对该对象执行的任何操作。同时，如果 JSON "格式不正确"，您将进入catch() {块。

在内部，您将实现如下：

class JsonWrapper {
    enum NodeType {
       Object,
       Number,
       ...
    };
    NodeType type;
    union {
        JsonObject object;
        double number
    };
    JsonObject as_object() {
        if(type != Object) {
            throw new JSONReadException;
        } else {
            return this->object;
        }
    }

我知道你说你对库不感兴趣，但我过去做过一个C++解码/编码 JSON 的库：

https://github.com/eteran/cpp-json

这是一个相当小的库，只有标题，所以你可以从中收集我的策略。

本质上，我有一个包裹boost::variant的json::value，所以它可以是基本类型之一（string，number，boolean，null），当然也可以是array或object。

前向声明和动态分配有点棘手，因为array和object包含value s，而 s 又可以是 array s 和 object s。但这是一般的想法。

希望这有帮助。

如果你有兴趣学习，我强烈建议你通读jq源代码——它真的是干净的C代码，没有外部json库依赖。

在内部，jq 将类型信息保存在一个简单的枚举中，从而避免了大多数编译时类型问题。 尽管这确实意味着您必须建立基本操作。

我已经为JSON解析器编写了一个库。JSON 表示形式由模板类json::value实现，符合C++标准库。它需要 C++11 和符合标准的容器。

JSON 值基于类json::variant。这与 v1.52 boost::variant没有什么不同，但使用的是更现代的实现（利用可变参数模板）。这种变体实现更加简洁，尽管由于无处不在的模板技术不是很简单。它只是一个文件，而boost::variant的实现似乎过于复杂（由于设计时缺乏可变参数模板）。此外，json：：variant 在可能的情况下利用移动语义，并实现一些技巧来变得相当高性能（优化的代码比 boost 1.53 中的代码快得多）。

类json::value定义了其他一些类型，表示基元类型（数字、布尔值、字符串、Null）。对象和数组容器类型将通过模板参数定义，这些参数必须是符合标准的容器。因此，基本上可以在几个标准的lib兼容容器中进行选择。

最后，JSON 值包装了一个变体成员，并提供了一些成员函数和一个漂亮的 API，这使得使用 JSON 表示变得非常容易。

该实现具有一些不错的功能。例如，它支持"作用域分配器"。有了它，就可以在构建 JSON 表示时使用"竞技场分配器"来提高性能。这需要一个符合要求且完全实现的容器库，它支持作用域分配器模型（clang 的 std lib 就是这样做的）。但是，将此功能实现到变体类中增加了一层额外的复杂性。

另一个功能是，创建和访问表示非常容易。

下面是一个示例：

#include "json/value/value.hpp"
#include "json/generator/write_value.hpp"
#include <iostream>
#include <iterator>
int main(int argc, const char * argv[])
{
    typedef json::value<> Value;
    typedef typename Value::object_type Object;
    typedef typename Value::array_type Array;
    typedef typename Value::string_type String;
    typedef typename Value::integral_number_type IntNumber;
    typedef typename Value::float_number_type FloatNumber;
    typedef typename Value::boolean_type Boolean;
    typedef typename Value::null_type Null;
    Value json = Array();
    json.as<Array>().push_back("Hello JSON!");
    json.as<Array>().push_back("This is a quoted "string".");
    json.as<Array>().push_back("First line.nSecond line.");
    json.as<Array>().push_back(false);
    json.as<Array>().push_back(1);
    json.as<Array>().push_back(1.0);
    json.as<Array>().push_back(json::null);
    json.as<Array>().push_back(
        Object({{"parameters",
        Object({{"key1", "value"},{"key2", 0},{"key3", 0.0}})
    }}));

    std::ostream_iterator<char> out_it(std::cout, nullptr);
    json::write_value(json, out_it, json::writer_base::pretty_print);
    std::cout << std::endl;
    std::string jsonString;
    json::write_value(json, std::back_inserter(jsonString));
    std::cout << std::endl << jsonString << "nn" << std::endl;
}

程序将以下内容打印到控制台：

[
    "Hello JSON!",
    "This is a quoted "string".",
    "First line.nSecond line.",
    false,
    1,
    1.000000,
    null,
    {
        "parameters" : {
            "key1" : "value",
            "key2" : 0,
            "key3" : 0.000000
        }
    }
]
["Hello JSON!","This is a quoted "string".","First line.nSecond line.",false,1,1.000000,null,{"parameters":{"key1":"value","key2":0,"key3":0.000000}}]

当然，还有一个解析器，它可以创建这样的json::value表示。解析器针对速度和低内存占用进行了高度优化。

虽然我认为C++表示（json::value）的状态仍然是"Alpha"，但有一个完整的Objective-C包装器，它基于C++核心实现（即解析器），可以被认为是最终的。不过，C++表示（json::value）仍然需要一些工作才能完成。

尽管如此，该库可能是您想法的来源：代码位于 GitHub：JPJson 上，尤其是文件夹 Source/json/utility/ 中variant.hpp和mpl.hpp的文件以及文件夹 Source/json/value/ 和 Source/json/generator/ 中的所有文件。

实现技术和源代码的数量可能令人费解，并且仅在iOS和Mac OS X上使用现代clang进行了测试/编译 - 请注意;)

我会实现一个只有 4 种类型的简化boost::variant：unordered_map、vector、string和（可选）数值类型（我们需要无限精度吗？

每个容器都将包含指向相同类型实例的智能指针。

boost::variant存储它所持有类型的union，以及它所具有的类型enum或索引。 我们可以向它询问类型索引，我们可以询问它是否具有一个特定的类型 i，或者我们可以编写一个带有distict覆盖的访问者，variant向其发送正确的调用。 （最后一个是apply_visitor）。

我会模仿那个界面，因为我发现它既有用又相对完整。 简而言之，重新实现部分boost，然后使用它。 请注意，variant 是仅标头类型，因此它可能足够轻，可以只包含。