Question

我是C ++的新手。使用std::Map序列化和反序列化boost类型数据的最简单方法是什么？我找到了一些使用PropertyTree的例子，但它们对我来说很模糊。

Answer 1

请注意property_tree将密钥解释为路径，例如把对“a.b”=“z”放在一起会创建一个{“a”：{“b”：“z”}} JSON，而不是{“a.b”：“z”}。否则，使用property_tree是微不足道的。这是一个小例子。

#include <sstream>
#include <map>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>

using boost::property_tree::ptree;
using boost::property_tree::read_json;
using boost::property_tree::write_json;

void example() {
  // Write json.
  ptree pt;
  pt.put ("foo", "bar");
  std::ostringstream buf; 
  write_json (buf, pt, false);
  std::string json = buf.str(); // {"foo":"bar"}

  // Read json.
  ptree pt2;
  std::istringstream is (json);
  read_json (is, pt2);
  std::string foo = pt2.get<std::string> ("foo");
}

std::string map2json (const std::map<std::string, std::string>& map) {
  ptree pt; 
  for (auto& entry: map) 
      pt.put (entry.first, entry.second);
  std::ostringstream buf; 
  write_json (buf, pt, false); 
  return buf.str();
}

Answer 2

Boost 1.75 及更高版本现在拥有强大的原生 JSON 库：

https://www.boost.org/doc/libs/develop/libs/json/doc/html/index.html

我不建议再使用 Boost.PropertyTree 的 JSON 算法，因为它们不完全符合规范。

Answer 3

一些公司要求我实现比boost lib更快的JSON序列化库。我做到了-比lib提升快约10倍。我将代码发布给任何人使用。

const ModelData = require("../models/data");

async show(req, res) {
let modelData;
await ModelData.findOne({user: req.params.id}, (error, user) => {
   modelData = user;
});
 if (!modelData) {
    res.status(204).json({error: "No Data"});
    return;
    }
return res.status(200).send(modelData);
},


routes.get("/data/:id", ModelDataController.show);
routes.post("/data", ModelDataController.store);
routes.put("/data/:id", ModelDataController.update);

用法示例

创建json树：

#pragma once
#include <string>
#include <vector>
#include <regex>
#include <fstream>

enum class JsonNodeType { Array, Object, String };

class JsonNode
{
    JsonNodeType m_nodeType;
    
    std::vector<JsonNode*>* m_values{0};
    std::vector<std::string>* m_keys{0};
    std::string m_value{};
    inline static int m_indent;
    inline static bool m_formatOutput;
    const int m_indentInc{4};

public:

    JsonNode(JsonNodeType type) 
    {
        m_nodeType = type;
        
        switch (m_nodeType) {
            case JsonNodeType::Object: m_keys = new std::vector<std::string>();
                                       [[fallthrough]];
            case JsonNodeType::Array: m_values = new std::vector<JsonNode*>();
        }
    };

    JsonNode(std::string value) 
    {
        m_nodeType = JsonNodeType::String;
        m_value = value;
    }

    ~JsonNode() 
    {

        if (m_values)       
            for (JsonNode* node : *m_values)
                delete node;
                
        delete m_values; 
        delete m_keys; 
    }

    void Add(JsonNode* node) 
    {               
        assert(m_nodeType == JsonNodeType::Array);
        
        m_values->push_back(node);
    }

    void Add(const char* key, JsonNode* node) 
    {       
        assert(m_nodeType == JsonNodeType::Object);

        m_values->push_back(node);
        m_keys->push_back(key);
    }

    void Add(const char* key, std::string value) 
    {       
        assert(m_nodeType == JsonNodeType::Object);

        m_keys->push_back(key);
        m_values->push_back(new JsonNode(value));
    }

    void Add(std::string value) 
    {
        assert(m_nodeType == JsonNodeType::Array);

        m_values->push_back(new JsonNode(value));
    }

    void Add(int value) 
    {
        assert(m_nodeType == JsonNodeType::Array);

        m_values->push_back(new JsonNode(std::to_string(value)));
    }

    void Add(const char* key, bool value) 
    {
        assert(m_nodeType == JsonNodeType::Object);

        m_keys->push_back(key);
        m_values->push_back(new JsonNode(value ? "true" : "false"));
    }


    void OutputToStream(std::ostream& ofs, bool formatOutput = true) 
    {
        m_indent = 0;       
        m_formatOutput = formatOutput;

        OutputNodeToStream(ofs);

        ofs << std::endl;
    }

    std::string EscapeString(std::string& str) 
    {   
        std::regex html2json("\\\\|\\/|\\\"");
        std::regex newline("\n");

        std::string tmp = std::regex_replace(str, html2json, "\\$&");   
        return std::regex_replace(tmp, newline, "\\n");
    }

private: 

    void OutputNodeToStream(std::ostream& ofs) 
    {
        switch (m_nodeType) {

            case JsonNodeType::String:
                ofs << "\"" << m_value << "\"";
                break;

            case JsonNodeType::Object:
                OutputObjectToStream(ofs);
                break;

            case JsonNodeType::Array:
                OutputArrayToStream(ofs);
                break;
        }

    }

    void ChangeIndent(std::ostream& ofs, int indentDelta) 
    {

        if (!m_formatOutput)
            return;

        m_indent += indentDelta;
        
        ofs << std::endl;
    }

    void OutputIndents(std::ostream& ofs) 
    {

        if (!m_formatOutput)
            return;

        for (int i = 0; i < m_indent; i++)
            ofs << " ";
    }

    void OutputObjectToStream(std::ostream& ofs) 
    {

        assert(m_nodeType == JsonNodeType::Object);
        assert(m_keys->size() == m_values->size());

        if (m_keys->empty()) 
        {
            ofs << "\"\"";
            return;
        }

        ofs << "{";     

        ChangeIndent(ofs, m_indentInc);
        
        for (int i = 0; i < m_keys->size(); i++) 
        {
            
            if (i > 0)
                ofs << ",";

            if (i > 0 && m_formatOutput)
                ofs << std::endl;

            
            OutputIndents(ofs);

            ofs << "\"" << m_keys->at(i) << "\": ";

            m_values->at(i)->OutputNodeToStream(ofs);
        }   
        
        ChangeIndent(ofs, -m_indentInc);
        OutputIndents(ofs);
        ofs << "}";     
    }

    void OutputArrayToStream(std::ostream& ofs) 
    {
    
        assert(m_nodeType == JsonNodeType::Array);

        if (m_values->empty()) 
        {
            ofs << "\"\"";
            return;
        }

        ofs << "[";

        ChangeIndent(ofs, m_indentInc);

        for (int i = 0; i < m_values->size(); i++) 
        {

            if (i > 0)
                ofs << ",";

            if(i > 0 && m_formatOutput)
                ofs << std::endl;

            OutputIndents(ofs);         

            m_values->at(i)->OutputNodeToStream(ofs);
        }
        
        ChangeIndent(ofs, -m_indentInc);
        OutputIndents(ofs);
        ofs << "]";     
    }

};

输出树：

JsonNode* Circuit::GetMyJson()
{
    JsonNode* node = new JsonNode(JsonNodeType::Object);

    JsonNode* gates = new JsonNode(JsonNodeType::Array);

    for (auto& [k, v] : m_gates)
        gates->Add(v.GetMyJson());

    node->Add("gates", gates);

    return node;
}

使用Boost序列化和反序列化JSON

3 个答案: