c++ - Boostを使用したJSONのシリアル化と逆シリアル化

Question

私はC++の初心者です。std::Mapを使用してタイプのデータをシリアル化および逆シリアル化する最も簡単な方法は何ですかboost。を使用していくつかの例を見つけましPropertyTreeたが、それらは私にはわかりません。

Answer 1

キーをパスとして解釈することに注意してくださいproperty_tree。たとえば、ペア「ab」= "z"を配置すると、{"ab"： "z"}ではなく、{"a"：{"b"："z"}}JSONが作成されます。 。それ以外の場合、使用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

ある会社から、boostlibよりも高速なJSONシリアル化ライブラリを実装するように依頼されました。私はそれをしました-それはlibをブーストするよりも約10倍高速です。私は誰でも使用できるようにコードを公開しています。

#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 << "]";     
    }

};

使用例

jsonツリーを作成します。

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;
}

出力ツリー：

std::unique_ptr<JsonNode> node (simulation->GetMyJson());
std::ofstream output("output.json", std::ios::out);
node->OutputToStream(output);