开源代码学习：json11源码阅读

本篇是《开源代码学习》的第二篇，上一篇为：《一文搞定json解析和封装问题，手把手带你学习CJSON开源代码》
本文阅读一下json11的代码，json11是使用C++11编写的json库，对json11代码或者使用感兴趣的小伙伴可以阅读一下此文。

json11

json11是json11是一个轻量级的C++11库, 提供JSON的序列化和反序列化功能.，
之前在解析json数据的时候，尝试了好几个json库，最终决定使用json11，主要有以下几个原因：

1. json的通用功能
2. 可以像使用C++类一样使用
3. 中文不乱码，这是我选择这个库的主要原因

json11的github地址：json11.

json11源码阅读

项目结构

项目结构比较简单，只有俩个文件

json11.hpp
json11.cpp

ReamME

json11是一个轻量级的C++11库, 提供JSON的序列化和反序列化功能.
核心的对象是 json11::Json. 可以用来表示任意类型的JSON数据：
null, bool, number (int or double), string (std::string), array (std::vector), 或者object (std::map).

json11::Json类型的对象和其他值类型一样，支持赋值、拷贝、传递、比较等操作. 我们还提供了辅助方法

Json::dump用来将json11::Json类型的对象序列化为string Json::parse
(static)用来将std::string反序列化为json11::Json类型的对象

使用C++11提供的初始化器可以很容易创建一个json11::Json对象:

Json my_json = Json::object {
    { "key1", "value1" },
    { "key2", false },
    { "key3", Json::array { 1, 2, 3 } },
};
std::string json_str = my_json.dump();

这里还提供了一些内置的构造函数，可以将标准库类型和用户自定义类型自动的转化为json11::Json对象。例如:

class Point {
public:
    int x;
    int y;
    Point (int x, int y) : x(x), y(y) {}
    Json to_json() const { return Json::array { x, y }; }
};

std::vector<Point> points = { { 1, 2 }, { 10, 20 }, { 100, 200 } };
std::string points_json = Json(points).dump();
json11::

Json同时支持下标和关键字索引：

Json json = Json::array { Json::object { { "k", "v" } } };
std::string str = json[0]["k"].string_value();

json11设计

主要由以下几个类构成

• class Json
• class JsonValue
• class Value
• class JsonInt JsonDouble …

Json类为对外开放的接口，有多种构造方式。

class Json final { 
public
    // Types
    enum Type {
        NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT
    };
    typedef std::vector<Json> array; //array、object直接使用STL容器实现
    typedef std::map<std::string, Json> object;

    Json() noexcept;                // NUL
    Json(std::nullptr_t) noexcept;  // NUL 
    Json(double value);             // NUMBER
    Json(int value);                // NUMBER
    Json(bool value);               // BOOL
    Json(const std::string &value); // STRING
    Json(std::string &&value);      // STRING
    Json(const char * value);       // STRING
    Json(const array &values);      // ARRAY
    Json(array &&values);           // ARRAY
    Json(const object &values);     // OBJECT
    Json(object &&values);          // OBJECT

    template <class T, class = decltype(&T::to_json)>
    Json(const T & t) : Json(t.to_json()) {}

    template <class M, typename std::enable_if<
        std::is_constructible<std::string, decltype(std::declval<M>().begin()->first)>::value
        && std::is_constructible<Json, decltype(std::declval<M>().begin()->second)>::value,
            int>::type = 0>
    Json(const M & m) : Json(object(m.begin(), m.end())) {}
    template <class V, typename std::enable_if<
        std::is_constructible<Json, decltype(*std::declval<V>().begin())>::value,
            int>::type = 0>
    Json(const V & v) : Json(array(v.begin(), v.end())) {}
    Json(void *) = delete;

...

private:
    std::shared_ptr<JsonValue> m_ptr;

其中有几个构造函数比较复杂，详见：

这些数据的实体被存放在m_ptr所指向的对象之中。

class JsonValue {
protected:
    friend class Json;
    friend class JsonInt;
    friend class JsonDouble;
    virtual Json::Type type() const = 0;
    virtual bool equals(const JsonValue * other) const = 0;
    virtual bool less(const JsonValue * other) const = 0;
    virtual void dump(std::string &out) const = 0;
    virtual double number_value() const;
    virtual int int_value() const;
    virtual bool bool_value() const;
    virtual const std::string &string_value() const;
    virtual const Json::array &array_items() const;
    virtual const Json &operator[](size_t i) const;
    virtual const Json::object &object_items() const;
    virtual const Json &operator[](const std::string &key) const;
    virtual ~JsonValue() {}
};

JsonValue是一个抽象基类，定义了一些api，用来操作访问json对象。这些api并不向用户开放，用于内部使用。用户借由Json类中提供的函数来操作和访问。
接下来是其派生类Value:

template <Json::Type tag, typename T>
class Value : public JsonValue {
protected:

    // Constructors
    explicit Value(const T &value) : m_value(value) {}
    explicit Value(T &&value)      : m_value(move(value)) {}

    // Get type tag
    Json::Type type() const override {
        return tag;
    }

    // Comparisons
    bool equals(const JsonValue * other) const override {
        return m_value == static_cast<const Value<tag, T> *>(other)->m_value;
    }
    bool less(const JsonValue * other) const override {
        return m_value < static_cast<const Value<tag, T> *>(other)->m_value;
    }

    const T m_value;
    void dump(string &out) const override { json11::dump(m_value, out); }
};

Value作为一个类模板，实例化出不同的类保存着json对象的数据实体。

而JsonInt，JsonDouble等等类可以直接通过继承对应的实例化类来保存数据。

以JsonInt为例：

class JsonInt final : public Value<Json::NUMBER, int> {
    double number_value() const override { return m_value; }
    int int_value() const override { return m_value; }
    bool equals(const JsonValue * other) const override { return m_value == other->number_value(); }
    bool less(const JsonValue * other)   const override { return m_value <  other->number_value(); }
public:
    explicit JsonInt(int value) : Value(value) {}
};

继承的Value为int版本，因此可以直接通过父类构造函数来保存value。同时实现了专属于该类的一些操作，例如int_value()用来获取value的值。

参考资料

https://www.cnblogs.com/cknightx/p/7717539.html