windows客户端开发--使用json11解析json

我就是我 2022-07-28 01:39 155阅读 0赞

![这里写图片描述][20160328224011947]  
类似xml，JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。

json11是适用于c++11的一个轻量级的库，用于解析json.

**什么是json?**  
JSON is short for JavaScript Object Notation, and is a way to store information in an organized, easy-to-access manner. In a nutshell, it gives us a human-readable collection of data that we can access in a really logical manner.

**json如何存储？**

var jason = {
        "age" : "24",
        "hometown" : "Missoula, MT",
        "gender" : "male"
    };

**将json存为数组**

var family = [{
        "name" : "Jason",
        "age" : "24",
        "gender" : "male"
    },
    {
        "name" : "Kyle",
        "age" : "21",
        "gender" : "male"
    }];

**使用json11进行解析**

#include <string.h>
    #include <cstdio>
    #include <iostream>
    #include <sstream>
    #include "lasote/json11/json11.hpp"
    #include <cassert>
    #include <list>
    #include <set>
    #include <unordered_map>
    
    using namespace json11;
    using std::string;
    
    
    int main(int argc, char **argv) {
    
    
        // STRING TO JSON
        const string simple_test =
            R"({"k1":"v1", "k2":42, "k3":["a",123,true,false,null]})";
    
        string err;
        auto json = Json::parse(simple_test, err);
        std::cout << "k1: " << json["k1"].string_value() << "\n";
        std::cout << "k3: " << json["k3"].dump() << "\n";
    
    
        // JSON FROM LITERAL
        Json obj = Json::object({
            { "k1", "v1" },
            { "k2", 42.0 },
            { "k3", Json::array({ "a", 123.0, true, false, nullptr }) },
        });
    
        std::cout << "obj: " << obj.dump() << "\n";
    
        // CUSTOM CLASS JSON ENCODE
        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();
        printf("%s\n", points_json.c_str());
    }

**josn11源码头文件**

class __declspec(dllexport) Json final {
    public:
        // Types
        enum Type {
            NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT
        };
    
        // Array and object typedefs
        typedef std::vector<Json> array;
        typedef std::map<std::string, Json> object;
    
        // Constructors for the various types of JSON value.
        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
    
        // Implicit constructor: anything with a to_json() function.
        template <class T, class = decltype(&T::to_json)>
        Json(const T & t) : Json(t.to_json()) {}
    
        // Implicit constructor: map-like objects (std::map, std::unordered_map, etc)
        template <class M, typename std::enable_if<
            std::is_constructible<std::string, typename M::key_type>::value
            && std::is_constructible<Json, typename M::mapped_type>::value,
                int>::type = 0>
        Json(const M & m) : Json(object(m.begin(), m.end())) {}
    
        // Implicit constructor: vector-like objects (std::list, std::vector, std::set, etc)
        template <class V, typename std::enable_if<
            std::is_constructible<Json, typename V::value_type>::value,
                int>::type = 0>
        Json(const V & v) : Json(array(v.begin(), v.end())) {}
    
        // This prevents Json(some_pointer) from accidentally producing a bool. Use
        // Json(bool(some_pointer)) if that behavior is desired.
        Json(void *) = delete;
    
        // Accessors
        Type type() const;
    
        bool is_null()   const { return type() == NUL; }
        bool is_number() const { return type() == NUMBER; }
        bool is_bool()   const { return type() == BOOL; }
        bool is_string() const { return type() == STRING; }
        bool is_array()  const { return type() == ARRAY; }
        bool is_object() const { return type() == OBJECT; }
    
        // Return the enclosed value if this is a number, 0 otherwise. Note that json11 does not
        // distinguish between integer and non-integer numbers - number_value() and int_value()
        // can both be applied to a NUMBER-typed object.
        double number_value() const;
        int int_value() const;
    
        // Return the enclosed value if this is a boolean, false otherwise.
        bool bool_value() const;
        // Return the enclosed string if this is a string, "" otherwise.
        const std::string &string_value() const;
        // Return the enclosed std::vector if this is an array, or an empty vector otherwise.
        const array &array_items() const;
        // Return the enclosed std::map if this is an object, or an empty map otherwise.
        const object &object_items() const;
    
        // Return a reference to arr[i] if this is an array, Json() otherwise.
        const Json & operator[](size_t i) const;
        // Return a reference to obj[key] if this is an object, Json() otherwise.
        const Json & operator[](const std::string &key) const;
    
        // Serialize.
        void dump(std::string &out) const;
        std::string dump() const {
            std::string out;
            dump(out);
            return out;
        }
    
        // Parse. If parse fails, return Json() and assign an error message to err.
        static Json parse(const std::string & in, std::string & err);
        static Json parse(const char * in, std::string & err) {
            if (in) {
                return parse(std::string(in), err);
            } else {
                err = "null input";
                return nullptr;
            }
        }
        // Parse multiple objects, concatenated or separated by whitespace
        static std::vector<Json> parse_multi(const std::string & in, std::string & err);
    
        bool operator== (const Json &rhs) const;
        bool operator<  (const Json &rhs) const;
        bool operator!= (const Json &rhs) const { return !(*this == rhs); }
        bool operator<= (const Json &rhs) const { return !(rhs < *this); }
        bool operator>  (const Json &rhs) const { return  (rhs < *this); }
        bool operator>= (const Json &rhs) const { return !(*this < rhs); }
    
        /* has_shape(types, err) * * Return true if this is a JSON object and, for each item in types, has a field of * the given type. If not, return false and set err to a descriptive message. */
        typedef std::initializer_list<std::pair<std::string, Type>> shape;
        bool has_shape(const shape & types, std::string & err) const;
    
    private:
        std::shared_ptr<JsonValue> m_ptr;
    };
    
    // Internal class hierarchy - JsonValue objects are not exposed to users of this API.
    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() {}
    };
    
    } // namespace json11

哦对了，写到现在连个windows还没提到呢？难道博主是挂鸡头卖鸭头？

错。在客户端开发中，pc也好 移动也好，总是需要服务器返回的数据。  
这个response往往就是json类型的，所以我们做客户端的需要对json对象进行解析，然后进行使用~~

[20160328224011947]: /images/20220727/3185950d0ed44558a9a0c59413a3fd4f.png