开发前端软件素材源码教程下载网站

全部
网站模板
网页特效
网站源码
素材资源
建站学院
软件工具
mysql mysql 微信 微信 小程序 苹果 dedecms 修真图
当前位置：首页 > 建站学院 > 前端开发 >  基于C++怎么编写一个Json解析器

基于C++怎么编写一个Json解析器

前端开发   发布日期：2023年08月10日   浏览次数：533次

这篇文章主要介绍了基于C++怎么编写一个Json解析器的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇基于C++怎么编写一个Json解析器文章都会有所收获，下面我们一起来看看吧。

代码

JsonSerialize.h

  1. #pragma once
  2. #ifndef _JSON_SERIALIZE_
  3. #define _JSON_SERIALIZE_
  4. // #include "Util.h"
  5. #include <fstream>
  6. #include <string>
  7. #include <vector>
  8. #include <map>
  10. // NAME_SPACE_START(Json)
  12. enum JsonType {
  13.     None,
  14.     Number,
  15.     String,
  16.     Array,
  17.     Bool,
  18.     Null,
  19.     Object
  20. };
  22. class JNull {
  23. public:
  24.     JNull() {}
  25.     ~JNull() {}
  26. };
  28. template<typename T>
  29. class JBaseObject {
  30. public:
  31.     JBaseObject() {}
  32.     virtual ~JBaseObject() {}
  33.     virtual JBaseObject* clone() = 0;
  34. };
  36. template<typename T>
  37. class JHolderObject :public JBaseObject<T> {
  38. private:
  39. public:
  40.     T value;
  41.     JHolderObject(const T& val) :value(val) {}
  42.     ~JHolderObject() {}
  43.     JBaseObject<T>* clone() override;
  44. };
  46. template<typename ValueType>
  47. class JObject {
  48. private:
  49.     JBaseObject<ValueType>* _value = nullptr;
  50. public:
  51.     JObject() {}
  52.     JObject(const ValueType& value);
  53.     JObject(const JObject& obj) :_value(obj._value->clone()) {}
  54.     ~JObject();
  55.     JObject<ValueType>& operator=(const ValueType& value);
  56.     ValueType* Cast() {
  57.         JHolderObject<ValueType>* temp = dynamic_cast<JHolderObject<ValueType>*>(_value);
  58.         return temp ? &temp->value : NULL;
  59.     }
  60.     ValueType& RefCast() {
  61.         return (static_cast<JHolderObject<ValueType>*>(_value))->value;
  62.     }
  63. };
  65. template<typename T>
  66. class JsonItemBase {
  67. public:
  68.     JsonItemBase() {}
  69.     virtual ~JsonItemBase() {}
  70.     virtual void f() {}
  71. };
  73. template<typename T>
  74. class JsonItem {
  75. private:
  76.     // JObject<T> _value;
  77.     T _value;
  78. public:
  79.     JsonItem() {}
  80.     JsonItem(const JsonItem&);
  81.     JsonItem(const JObject<T>& obj);
  82.     JsonItem(const T& obj);
  83.     ~JsonItem() {};
  84.     T& GetItemRefValue() {
  85.         return this->_value;
  86.     }
  87.     T* GetItemLpValue() {
  88.         return &this->_value;
  89.     }
  90. };
  92. class JsonKey {
  93. public:
  94.     JsonType _type{ JsonType::None };
  95.     std::wstring _key{ L"" };
  96.     JsonKey() {}
  97.     JsonKey(const JsonType& type, const std::wstring& key) :_type(type), _key(key) {}
  98.     bool operator<(const JsonKey&) const;
  99. };
  101. class JsonValue {
  102. public:
  103.     void* _value{ nullptr };
  104.     size_t _size{ 0 };
  105.     JsonValue() {}
  106.     JsonValue(void* value, const int& size) :_value(value), _size(size) {}
  107. };
  109. class JsonSerialize {
  110.     using string = std::string;
  111. private:
  112.     std::vector<std::pair<JsonKey, JsonValue>> content;
  113.     string _filePath;
  114. public:
  115.     JsonSerialize() {}
  116.     JsonSerialize(const string filePath);
  117.     ~JsonSerialize() {};
  118.     bool Load(const string filePath = "");
  119.     template<typename T>
  120.     JsonItem<T>* GetValueByKey(string key);
  121.     std::vector<std::pair<JsonKey, JsonValue>>& GetContent();
  122.     void printAll(int tab = 0);
  123. private:
  125. };
  128. // NAME_SPACE_END()
  129. #endif //!_JSON_SERIALIZE_

JsonSerialize.cpp

  1. #include "JsonSerialize.h"
  2. // #include "Util.h"
  3. #include <iostream>
  4. #include <sstream>
  5. #include <atomic>
  6. #include <exception>
  7. #include <fstream>
  8. #include <ios>
  9. #include <string>
  10. #include <utility>
  11. #include <vector>
  12. #include <stack>
  14. // NAME_SPACE_START(Json)
  16. template<typename T>
  17. JBaseObject<T>* JHolderObject<T>::clone() {
  18.     return new JHolderObject<T>(this->value);
  19. }
  21. // template<typename T>
  22. // T& JHolderObject<T>::GetValue(){
  23. //     return value;
  24. // }
  26. template<typename ValueType>
  27. JObject<ValueType>::JObject(const ValueType& value) {
  28.     _value = new JHolderObject<ValueType>(value);
  29. }
  31. template<typename ValueType>
  32. JObject<ValueType>::~JObject() {
  33.     if (_value) delete _value;
  34. }
  36. template<typename ValueType>
  37. JObject<ValueType>& JObject<ValueType>::operator=(const ValueType& value) {
  38.     if (_value) delete _value;
  39.     _value = new JHolderObject<ValueType>(value);
  40.     return *this;
  41. }
  43. // template<typename ValueType>
  44. // ValueType* JObject<ValueType>::Cast(){
  45. //     JHolderObject<ValueType>* temp=dynamic_cast<JHolderObject<ValueType>*>(_value);
  46. //     return temp?&temp->GetValue():NULL;
  47. // }
  49. // template<typename ValueType>
  50. // ValueType& JObject<ValueType>::RefCast(){
  51. //     return (dynamic_cast<JHolderObject<ValueType>&>(_value)).GetValue();
  52. // }
  54. // template<typename T>
  55. // JsonItem<T>::JsonItem(const JObject<T>& value)
  56. //     :JsonItemBase<T>(){
  57. //     this->_value=value;
  58. // }
  59. template<typename T>
  60. JsonItem<T>::JsonItem(const T& objList)
  61. {
  62.     this->_value = objList;
  63. }
  65. // //获取值
  66. // template<typename T>
  67. // T& JsonItem<T>::GetItemRefValue(){
  68. //     return this->_value.RefCast();
  69. // }
  71. // template<typename T>
  72. // T* JsonItem<T>::GetItemLpValue(){
  73. //     return this->_value.Cast();
  74. // }
  76. std::ifstream _file;
  77. void OpenFile(const std::string filePath) {
  78.     _file.open(filePath, std::ios::in);
  79.     if (!_file.is_open()) return;
  80. }
  81. void CloseFile() {
  82.     _file.close();
  83. }
  85. bool JsonKey::operator<(const JsonKey& j_key) const {
  86.     return false;
  87. }
  89. JsonSerialize::JsonSerialize(const std::string filePath) {
  90.     this->_filePath = filePath;
  91. }
  93. bool isFirst = true;
  94. bool isQuote = false;
  95. bool isKey = true;
  96. bool isObj = false;
  97. bool isObjEnd = true;
  98. bool isArrEnd = true;
  99. JsonType curType = JsonType::Null;
  100. size_t objListDeep = 0;
  101. size_t arrDeep = 0;
  102. std::wstring key = L"";
  103. std::wstring value = L"";
  104. std::stack<std::wstring> arrKey;
  105. std::stack<JsonType> cer;
  106. std::vector<std::pair<bool,JsonItem<std::vector<JsonValue>>*>> arrValueList; //false直接放到对象中 true 放到objList中
  107. std::vector<std::pair<bool,JsonItem<JsonSerialize>*>> objList;               //false直接放到对象中 true 放到arrValueList中
  109. void freeAll() {
  110.     for (std::pair<bool, JsonItem<std::vector<JsonValue>>*> item : arrValueList)
  111.         if (item.second) delete item.second;
  112.     for (std::pair<bool, JsonItem<JsonSerialize>*> item : objList)
  113.         if (item.second) delete item.second;
  114. }
  116. std::string stows(std::wstring& ws)
  117. {
  118.     std::string curLocale = setlocale(LC_ALL, NULL); // curLocale = "C";
  119.     setlocale(LC_ALL, "chs");
  120.     const wchar_t* _Source = ws.c_str();
  121.     size_t _Dsize = 2 * ws.size() + 1;
  122.     char* _Dest = new char[_Dsize];
  123.     memset(_Dest, 0, _Dsize);
  124.     wcstombs(_Dest, _Source, _Dsize);
  125.     std::string result = _Dest;
  126.     delete[]_Dest;
  127.     setlocale(LC_ALL, curLocale.c_str());
  128.     return result;
  129. }
  132. bool isBool(const std::wstring& str) {
  133.     return str == L"true";
  134. }
  136. bool isNumber(const std::wstring& str) {
  137.     std::wstring wstr = str;
  138.     std::stringstream ss(stows(wstr));
  139.     double d;
  140.     char c;
  141.     if (!(ss >> d)) return false;
  142.     if (ss >> c) return false;
  143.     return true;
  144. }
  146. bool Analysis(const char* buffer, std::vector<std::pair<JsonKey, JsonValue>>& content, const size_t length) {
  147.     size_t charLength = strlen(buffer) < length ? strlen(buffer) : length;
  148.     for (size_t i = 0; i < charLength; i++) {
  149.         char ch = buffer[i];
  150.         std::cout << ch;
  151.         if (ch == '{' && !isQuote) {
  152.             objListDeep++;
  153.             curType = JsonType::Object;
  154.             if (objListDeep >= 2) {
  155.                 bool flag = (cer.empty() || cer.top() == JsonType::Object) ? false : true;
  156.                 objList.push_back(std::pair<bool, JsonItem<JsonSerialize>*>(flag, new JsonItem<JsonSerialize>()));
  157.                 isObj = true;
  158.                 isObjEnd = false;
  159.                 if (!isArrEnd) cer.push(JsonType::Array);
  160.                 cer.push(JsonType::Object);
  161.                 if (isKey) arrKey.push(L"");
  162.             }
  163.         }
  164.         else if (ch == '}' && !isQuote) {
  165.             if (objListDeep == 1 && isFirst == true) isFirst = false;
  166.             else if (objListDeep == 1 && isFirst == false) return false;
  167.             objListDeep--;
  168.             isObjEnd = true;
  169.             if (objListDeep != 0)
  170.                 goto addArray;
  171.         }
  172.         else if (ch == '[' && !isQuote) {
  173.             bool flag = (cer.empty() || cer.top() == JsonType::Object) ? false : true;
  174.             curType = JsonType::Array;
  175.             arrDeep++;
  176.             arrValueList.push_back(std::pair<bool, JsonItem<std::vector<JsonValue>>*>(flag,new JsonItem<std::vector<JsonValue>>()));
  177.             isArrEnd = false;
  178.             if (!isObjEnd) cer.push(JsonType::Object);
  179.             cer.push(JsonType::Array);
  180.         }
  181.         else if (ch == ']' && !isQuote) {
  182.             arrDeep--;
  183.             if (arrDeep == 0) isArrEnd = true;
  184.             goto addArray;
  185.         }
  186.         else if (ch == ' ' && !isQuote) continue;
  187.         else if (ch == '"' && !isQuote) {
  188.             isQuote = true;
  189.             if (isKey) key += L""";
  190.             else value += L""";
  191.         }
  192.         else if (ch == '"' && isQuote) {
  193.             isQuote = false;
  194.             if (isKey) key += L""";
  195.             else value += L""";
  196.         }
  197.         else if (ch == ':' && !isQuote) isKey = false;
  198.         else if ((ch == ',' || ch == '
  199. ') && !isQuote) {
  201.             if ((key == L"" && value == L"" && objList.size() == 0 && arrValueList.size() == 0)
  202.                 || (key == L"" && value == L"" && !isArrEnd)) continue;
  204. addArray:   std::wstring inputKey = key == L"" ? L"" : key.replace(0, 1, L"");
  205.             inputKey = inputKey == L"" ? L"" : inputKey.replace(inputKey.find_last_of(L"""), 1, L"");
  207.             JsonKey j_key;
  208.             JsonValue j_value;
  209.             JsonType insertType = JsonType::Null;
  210.             j_key._key = inputKey;
  212.             if (value == L"true" || value == L"false") {                  //Bool
  213.                 JsonItem<bool> *objList=new JsonItem<bool>(isBool(value));
  214.                 size_t size = sizeof(objList);
  215.                 j_value._value = objList;
  216.                 j_value._size = 1;
  217.                 j_key._type = JsonType::Bool;
  218.             }
  219.             else if (value.find(L""") == 0 && value.find_last_of(L""") == value.size() - 1) { //String
  220.                 size_t n = value.size();
  221.                 std::wstring* temp = new std::wstring(value.begin(), value.end());
  222.                 JsonItem<std::wstring*> *objList=new JsonItem<std::wstring*>(temp);
  223.                 j_value._value = objList;
  224.                 j_value._size = n;
  225.                 j_key._type = JsonType::String;
  226.             }
  227.             else if (isNumber(value)) {                                          //Number
  228.                 double result = 0;
  229.                 std::stringstream ss(stows(value));
  230.                 ss >> result;
  231.                 JsonItem<double> *objList=new JsonItem<double>(result);
  232.                 size_t size = sizeof(objList);
  233.                 j_value._value = objList;
  234.                 //memcpy_s(j_value._value, size, &objList, size);
  235.                 j_value._size = 1;
  236.                 j_key._type = JsonType::Number;
  237.             }
  238.             else if (arrValueList.size() != 0 && objList.size() != 0) {//Array Add or Object Add
  239.                 if (!isObjEnd) {
  240.                     arrKey.push(inputKey);
  241.                     key = L"";
  242.                     isKey = true;
  243.                     continue;
  244.                 }
  245.                 cer.pop();
  246.                 void* _val = curType == JsonType::Object ? (void*)objList.back().second : (void*)arrValueList.back().second;
  247.                 size_t _si = curType == JsonType::Object ?
  248.                     objList.back().second->GetItemRefValue().GetContent().size() :
  249.                     arrValueList.back().second->GetItemLpValue()->size();
  250.                 j_key._key = arrKey.top();
  251.                 j_value._value = _val;
  252.                 j_value._size = _si;
  253.                 j_key._type = JsonType::Object;
  254.                 if (curType == JsonType::Object) objList.pop_back();
  255.                 else arrValueList.pop_back();
  256.                 //接下来确认是放到obj 还是 arrvalue 通过cer栈顶元素判断
  257.                 JsonType upType = cer.top();
  258.                 arrKey.pop();
  259.                 if (upType == JsonType::Object)
  260.                     objList.back().second->GetItemLpValue()->GetContent().push_back(std::pair<JsonKey, JsonValue>(j_key, j_value));
  261.                 else 
  262.                     arrValueList.back().second->GetItemLpValue()->push_back(j_value);
  263.                 continue;
  264.             }
  265.             else if (objList.size() != 0) {//Object
  266.                 if (!isObjEnd && isKey) {
  267.                     arrKey.push(inputKey);
  268.                     key = L"";
  269.                     continue;
  270.                 }
  271.                 cer.pop();
  272.                 j_key._key = arrKey.top();
  273.                 arrKey.pop();
  274.                 j_value._value = objList.back().second;
  275.                 j_value._size = objList.back().second->GetItemRefValue().GetContent().size();
  276.                 j_key._type = JsonType::Object;
  277.                 objList.pop_back();
  278.                 if (objList.size() != 0) {
  279.                     objList.back().second->GetItemLpValue()->GetContent().push_back(std::pair<JsonKey, JsonValue>(j_key, j_value));
  280.                     continue;
  281.                 }
  282.             }
  283.             else if (arrValueList.size() != 0 && objList.size() == 0) {//Array
  284.                 if (!isArrEnd) {
  285.                     arrKey.push(inputKey);
  286.                     key = L"";
  287.                     isKey = true;
  288.                     continue;
  289.                 }
  290.                 cer.pop();
  291.                 j_key._key = arrKey.empty()?inputKey:arrKey.top();
  292.                 if (!arrKey.empty()) arrKey.pop();
  293.                 j_value._value = arrValueList.back().second;
  294.                 j_value._size = arrValueList.back().second->GetItemLpValue()->size();
  295.                 j_key._type = JsonType::Array;
  296.                 arrValueList.pop_back();
  297.                 if (arrValueList.size() != 0) {
  298.                     arrValueList.back().second->GetItemLpValue()->push_back(j_value);
  299.                     continue;
  300.                 }
  301.             }
  302.             else if (value == L"") {                               //Null
  303.                 JsonItem<JNull>* objList = new JsonItem<JNull>();
  304.                 size_t size = sizeof(objList);
  305.                 j_value._value = objList;
  306.                 j_value._size = 0;
  307.                 j_key._type = JsonType::Null;
  308.             }
  309.             std::pair<JsonKey, JsonValue> pair(j_key, j_value);
  310.             if (!isObjEnd) {
  311.                 objList.back().second->GetItemRefValue().GetContent().push_back(pair);
  312.             }
  313.             else content.push_back(pair);
  314.             key = L"";
  315.             value = L"";
  316.             isKey = true;
  317.             if (objListDeep == 1 && isObj) isObj = false;
  318.         }
  319.         else {
  320.             if (isKey && isQuote) key += std::wstring(1, ch);
  321.             else if (isKey && !isQuote) return false;
  322.             else if (!isKey) value += std::wstring(1, ch);
  323.         }
  324.         if (objListDeep < 0 || arrDeep < 0) return false;
  326.     }
  327.     return true;
  328. }
  330. bool JsonSerialize::Load(const string filePath) {
  331.     try {
  332.         if (filePath != "") {
  333.             this->_filePath = filePath;
  334.         }
  335.         OpenFile(this->_filePath);
  336.         while (!_file.eof()) {
  337.             char buffer[0x4000] = "";
  338.             size_t length = sizeof(buffer) / sizeof(char);
  339.             _file.read(buffer, length);
  340.             if (!Analysis(buffer, content, length)) {
  341.                 CloseFile();
  342.                 return false;
  343.             }
  344.         }
  345.         CloseFile();
  346.         freeAll();
  347.         return objListDeep == 0 && arrDeep == 0;
  348.     }
  349.     catch (std::exception ex) {
  350.         throw ex;
  351.     }
  352. }
  354. std::vector<std::pair<JsonKey, JsonValue>>& JsonSerialize::GetContent() {
  355.     return this->content;
  356. }
  357. template<typename T>
  358. JsonItem<T>* JsonSerialize::GetValueByKey(string key)
  359. {
  360.     JsonItem<T>* temp_value = nullptr;
  361.     for (auto item : this->content) {
  362.         if (item.first._key == key) {
  363.             temp_value = (JsonItem<T>*)(item.second._value);
  364.             break;
  365.         }
  366.     }
  367.     return temp_value;
  368. }
  370. void coutTab(int count) {
  371.     while (count--) {
  372.         std::cout << '	';
  373.     }
  374. }
  376. void JsonSerialize::printAll(int tab) {
  377.     auto res = this->content;
  378.     coutTab(tab);
  379.     std::cout << "{" << std::endl;
  380.     for (auto it = res.begin(); it != res.end(); it++) {
  381.         JsonKey temp_key = it->first;
  382.         if (temp_key._type == JsonType::Number) {
  383.             JsonItem<double>* temp_value = (JsonItem<double>*)(it->second._value);
  384.             coutTab(tab + 1);
  385.             std::wcout << temp_key._key << " : " << temp_value->GetItemRefValue() << std::endl;
  386.         }
  387.         else if (temp_key._type == JsonType::String) {
  388.             JsonItem<std::wstring*>* temp_value = (JsonItem<std::wstring*>*)(it->second._value);
  389.             coutTab(tab + 1);
  390.             std::wcout << temp_key._key << " : " << *temp_value->GetItemRefValue() << "" << std::endl;
  391.         }
  392.         else if (temp_key._type == JsonType::Null) {
  393.             JsonItem<JNull>* temp_value = (JsonItem<JNull>*)(it->second._value);
  394.             coutTab(tab + 1);
  395.             std::wcout << temp_key._key << " : " << "NULL" << std::endl;
  396.         }
  397.         else if (temp_key._type == JsonType::Bool) {
  398.             JsonItem<bool>* temp_value = (JsonItem<bool>*)(it->second._value);
  399.             coutTab(tab + 1);
  400.             std::wcout << temp_key._key << " : " << (temp_value->GetItemRefValue() ? "true" : "false") << std::endl;
  401.         }
  402.         else if (temp_key._type == JsonType::Object) {
  403.             JsonItem<JsonSerialize>* temp_value = (JsonItem<JsonSerialize>*)(it->second._value);
  404.             temp_value->GetItemRefValue().printAll(tab + 1);
  405.         }
  406.         else if (temp_key._type == JsonType::Array) {
  407.             JsonItem<std::vector<JsonValue>>* temp_value =
  408.                 (JsonItem<std::vector<JsonValue>>*)(it->second._value);
  409.             coutTab(tab + 1);
  410.             std::wcout << temp_key._key << ":[" << std::endl;
  411.             for (auto item : temp_value->GetItemRefValue()) {
  412.                						
  413. 						
  414. 						
  415. 						
  416. 						
  417. 						
  418. 						
  419.

以上就是基于C++怎么编写一个Json解析器的详细内容，更多关于基于C++怎么编写一个Json解析器的资料请关注九品源码其它相关文章！

相关热词： 基于编写一个Json解析
上一篇：微信小程序 confirm（删除提示）
下一篇：Three.js中如何实现Bloom效果

文章分类

IT资讯 CMS教程 服务器 数据库 前端开发 后端开发 工具使用 其他教程

最后更新

热门排行

网站首页 | 关于我们 | 免责声明 | 网站建设 | 在线工具 | 网站地图

版权声明：本站发布的资源部分自互联网，所有资源版权归原作者所有。如果有侵犯到您的权益，请联系本站删除，谢谢合作！

Copyright 2018-2025 ©19jp.com All Rights Reserved. 陕ICP备16002142号-1