微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

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

分类：软件问题作者：编程之家AI导航网

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

代码

JsonSerialize.h

#pragma once
#ifndef _JSON_SERIALIZE_
#define _JSON_SERIALIZE_
// #include "Util.h"
#include <fstream>
#include <string>
#include <vector>
#include <map>

// NAME_SPACE_START(Json)

enum JsonType {
    None,
    Number,
    String,
    Array,
    Bool,
    Null,
    Object
};

class JNull {
public:
    JNull() {}
    ~JNull() {}
};

template<typename T>
class jbaseObject {
public:
    jbaseObject() {}
    virtual ~jbaseObject() {}
    virtual jbaseObject* clone() = 0;
};

template<typename T>
class JHolderObject :public jbaseObject<T> {
private:
public:
    T value;
    JHolderObject(const T& val) :value(val) {}
    ~JHolderObject() {}
    jbaseObject<T>* clone() override;
};

template<typename ValueType>
class JObject {
private:
    jbaseObject<ValueType>* _value = nullptr;
public:
    JObject() {}
    JObject(const ValueType& value);
    JObject(const JObject& obj) :_value(obj._value->clone()) {}
    ~JObject();
    JObject<ValueType>& operator=(const ValueType& value);
    ValueType* Cast() {
        JHolderObject<ValueType>* temp = dynamic_cast<JHolderObject<ValueType>*>(_value);
        return temp ? &temp->value : NULL;
    }
    ValueType& RefCast() {
        return (static_cast<JHolderObject<ValueType>*>(_value))->value;
    }
};

template<typename T>
class JsonItemBase {
public:
    JsonItemBase() {}
    virtual ~JsonItemBase() {}
    virtual void f() {}
};

template<typename T>
class JsonItem {
private:
    // JObject<T> _value;
    T _value;
public:
    JsonItem() {}
    JsonItem(const JsonItem&);
    JsonItem(const JObject<T>& obj);
    JsonItem(const T& obj);
    ~JsonItem() {};
    T& GetItemRefValue() {
        return this->_value;
    }
    T* GetItemLpValue() {
        return &this->_value;
    }
};

class JsonKey {
public:
    JsonType _type{ JsonType::None };
    std::wstring _key{ L"" };
    JsonKey() {}
    JsonKey(const JsonType& type, const std::wstring& key) :_type(type), _key(key) {}
    bool operator<(const JsonKey&) const;
};

class JsonValue {
public:
    void* _value{ nullptr };
    size_t _size{ 0 };
    JsonValue() {}
    JsonValue(void* value, const int& size) :_value(value), _size(size) {}
};

class JsonSerialize {
    using string = std::string;
private:
    std::vector<std::pair<JsonKey, JsonValue>> content;
    string _filePath;
public:
    JsonSerialize() {}
    JsonSerialize(const string filePath);
    ~JsonSerialize() {};
    bool Load(const string filePath = "");
    template<typename T>
    JsonItem<T>* GetValueByKey(string key);
    std::vector<std::pair<JsonKey, JsonValue>>& GetContent();
    void printAll(int tab = 0);
private:

};


// NAME_SPACE_END()
#endif //!_JSON_SERIALIZE_

JsonSerialize.cpp

#include "JsonSerialize.h"
// #include "Util.h"
#include <iostream>
#include <sstream>
#include <atomic>
#include <exception>
#include <fstream>
#include <ios>
#include <string>
#include <utility>
#include <vector>
#include <stack>

// NAME_SPACE_START(Json)

template<typename T>
jbaseObject<T>* JHolderObject<T>::clone() {
    return new JHolderObject<T>(this->value);
}

// template<typename T>
// T& JHolderObject<T>::GetValue(){
//     return value;
// }

template<typename ValueType>
JObject<ValueType>::JObject(const ValueType& value) {
    _value = new JHolderObject<ValueType>(value);
}

template<typename ValueType>
JObject<ValueType>::~JObject() {
    if (_value) delete _value;
}

template<typename ValueType>
JObject<ValueType>& JObject<ValueType>::operator=(const ValueType& value) {
    if (_value) delete _value;
    _value = new JHolderObject<ValueType>(value);
    return *this;
}

// template<typename ValueType>
// ValueType* JObject<ValueType>::Cast(){
//     JHolderObject<ValueType>* temp=dynamic_cast<JHolderObject<ValueType>*>(_value);
//     return temp?&temp->GetValue():NULL;
// }

// template<typename ValueType>
// ValueType& JObject<ValueType>::RefCast(){
//     return (dynamic_cast<JHolderObject<ValueType>&>(_value)).GetValue();
// }

// template<typename T>
// JsonItem<T>::JsonItem(const JObject<T>& value)
//     :JsonItemBase<T>(){
//     this->_value=value;
// }
template<typename T>
JsonItem<T>::JsonItem(const T& objList)
{
    this->_value = objList;
}

// //获取值
// template<typename T>
// T& JsonItem<T>::GetItemRefValue(){
//     return this->_value.RefCast();
// }

// template<typename T>
// T* JsonItem<T>::GetItemLpValue(){
//     return this->_value.Cast();
// }

std::ifstream _file;
void OpenFile(const std::string filePath) {
    _file.open(filePath, std::ios::in);
    if (!_file.is_open()) return;
}
void CloseFile() {
    _file.close();
}

bool JsonKey::operator<(const JsonKey& j_key) const {
    return false;
}

JsonSerialize::JsonSerialize(const std::string filePath) {
    this->_filePath = filePath;
}

bool isFirst = true;
bool isQuote = false;
bool isKey = true;
bool isObj = false;
bool isObjEnd = true;
bool isArrEnd = true;
JsonType curType = JsonType::Null;
size_t objListDeep = 0;
size_t arrDeep = 0;
std::wstring key = L"";
std::wstring value = L"";
std::stack<std::wstring> arrKey;
std::stack<JsonType> cer;
std::vector<std::pair<bool,JsonItem<std::vector<JsonValue>>*>> arrValueList; //false直接放到对象中 true 放到objList中
std::vector<std::pair<bool,JsonItem<JsonSerialize>*>> objList;               //false直接放到对象中 true 放到arrValueList中

void freeAll() {
    for (std::pair<bool, JsonItem<std::vector<JsonValue>>*> item : arrValueList)
        if (item.second) delete item.second;
    for (std::pair<bool, JsonItem<JsonSerialize>*> item : objList)
        if (item.second) delete item.second;
}

std::string stows(std::wstring& ws)
{
    std::string curLocale = setlocale(LC_ALL, NULL); // curLocale = "C";
    setlocale(LC_ALL, "chs");
    const wchar_t* _Source = ws.c_str();
    size_t _Dsize = 2 * ws.size() + 1;
    char* _Dest = new char[_Dsize];
    memset(_Dest, 0, _Dsize);
    wcstombs(_Dest, _Source, _Dsize);
    std::string result = _Dest;
    delete[]_Dest;
    setlocale(LC_ALL, curLocale.c_str());
    return result;
}


bool isBool(const std::wstring& str) {
    return str == L"true";
}

bool isNumber(const std::wstring& str) {
    std::wstring wstr = str;
    std::stringstream ss(stows(wstr));
    double d;
    char c;
    if (!(ss >> d)) return false;
    if (ss >> c) return false;
    return true;
}

bool Analysis(const char* buffer, std::vector<std::pair<JsonKey, JsonValue>>& content, const size_t length) {
    size_t charLength = strlen(buffer) < length ? strlen(buffer) : length;
    for (size_t i = 0; i < charLength; i++) {
        char ch = buffer[i];
        std::cout << ch;
        if (ch == '{' && !isQuote) {
            objListDeep++;
            curType = JsonType::Object;
            if (objListDeep >= 2) {
                bool flag = (cer.empty() || cer.top() == JsonType::Object) ? false : true;
                objList.push_back(std::pair<bool, JsonItem<JsonSerialize>*>(flag, new JsonItem<JsonSerialize>()));
                isObj = true;
                isObjEnd = false;
                if (!isArrEnd) cer.push(JsonType::Array);
                cer.push(JsonType::Object);
                if (isKey) arrKey.push(L"");
            }
        }
        else if (ch == '}' && !isQuote) {
            if (objListDeep == 1 && isFirst == true) isFirst = false;
            else if (objListDeep == 1 && isFirst == false) return false;
            objListDeep--;
            isObjEnd = true;
            if (objListDeep != 0)
                goto addArray;
        }
        else if (ch == '[' && !isQuote) {
            bool flag = (cer.empty() || cer.top() == JsonType::Object) ? false : true;
            curType = JsonType::Array;
            arrDeep++;
            arrValueList.push_back(std::pair<bool, JsonItem<std::vector<JsonValue>>*>(flag,new JsonItem<std::vector<JsonValue>>()));
            isArrEnd = false;
            if (!isObjEnd) cer.push(JsonType::Object);
            cer.push(JsonType::Array);
        }
        else if (ch == ']' && !isQuote) {
            arrDeep--;
            if (arrDeep == 0) isArrEnd = true;
            goto addArray;
        }
        else if (ch == ' ' && !isQuote) continue;
        else if (ch == '"' && !isQuote) {
            isQuote = true;
            if (isKey) key += L"\"";
            else value += L"\"";
        }
        else if (ch == '"' && isQuote) {
            isQuote = false;
            if (isKey) key += L"\"";
            else value += L"\"";
        }
        else if (ch == ':' && !isQuote) isKey = false;
        else if ((ch == ',' || ch == '\n') && !isQuote) {

            if ((key == L"" && value == L"" && objList.size() == 0 && arrValueList.size() == 0)
                || (key == L"" && value == L"" && !isArrEnd)) continue;

addArray:   std::wstring inputKey = key == L"" ? L"" : key.replace(0, 1, L"");
            inputKey = inputKey == L"" ? L"" : inputKey.replace(inputKey.find_last_of(L"\""), 1, L"");

            JsonKey j_key;
            JsonValue j_value;
            JsonType insertType = JsonType::Null;
            j_key._key = inputKey;

            if (value == L"true" || value == L"false") {                  //Bool
                JsonItem<bool> *objList=new JsonItem<bool>(isBool(value));
                size_t size = sizeof(objList);
                j_value._value = objList;
                j_value._size = 1;
                j_key._type = JsonType::Bool;
            }
            else if (value.find(L"\"") == 0 && value.find_last_of(L"\"") == value.size() - 1) { //String
                size_t n = value.size();
                std::wstring* temp = new std::wstring(value.begin(), value.end());
                JsonItem<std::wstring*> *objList=new JsonItem<std::wstring*>(temp);
                j_value._value = objList;
                j_value._size = n;
                j_key._type = JsonType::String;
            }
            else if (isNumber(value)) {                                          //Number
                double result = 0;
                std::stringstream ss(stows(value));
                ss >> result;
                JsonItem<double> *objList=new JsonItem<double>(result);
                size_t size = sizeof(objList);
                j_value._value = objList;
                //memcpy_s(j_value._value, size, &objList, size);
                j_value._size = 1;
                j_key._type = JsonType::Number;
            }
            else if (arrValueList.size() != 0 && objList.size() != 0) {//Array Add or Object Add
                if (!isObjEnd) {
                    arrKey.push(inputKey);
                    key = L"";
                    isKey = true;
                    continue;
                }
                cer.pop();
                void* _val = curType == JsonType::Object ? (void*)objList.back().second : (void*)arrValueList.back().second;
                size_t _si = curType == JsonType::Object ?
                    objList.back().second->GetItemRefValue().GetContent().size() :
                    arrValueList.back().second->GetItemLpValue()->size();
                j_key._key = arrKey.top();
                j_value._value = _val;
                j_value._size = _si;
                j_key._type = JsonType::Object;
                if (curType == JsonType::Object) objList.pop_back();
                else arrValueList.pop_back();
                //接下来确认是放到obj 还是 arrvalue 通过cer栈顶元素判断
                JsonType upType = cer.top();
                arrKey.pop();
                if (upType == JsonType::Object)
                    objList.back().second->GetItemLpValue()->GetContent().push_back(std::pair<JsonKey, JsonValue>(j_key, j_value));
                else 
                    arrValueList.back().second->GetItemLpValue()->push_back(j_value);
                continue;
            }
            else if (objList.size() != 0) {//Object
                if (!isObjEnd && isKey) {
                    arrKey.push(inputKey);
                    key = L"";
                    continue;
                }
                cer.pop();
                j_key._key = arrKey.top();
                arrKey.pop();
                j_value._value = objList.back().second;
                j_value._size = objList.back().second->GetItemRefValue().GetContent().size();
                j_key._type = JsonType::Object;
                objList.pop_back();
                if (objList.size() != 0) {
                    objList.back().second->GetItemLpValue()->GetContent().push_back(std::pair<JsonKey, JsonValue>(j_key, j_value));
                    continue;
                }
            }
            else if (arrValueList.size() != 0 && objList.size() == 0) {//Array
                if (!isArrEnd) {
                    arrKey.push(inputKey);
                    key = L"";
                    isKey = true;
                    continue;
                }
                cer.pop();
                j_key._key = arrKey.empty()?inputKey:arrKey.top();
                if (!arrKey.empty()) arrKey.pop();
                j_value._value = arrValueList.back().second;
                j_value._size = arrValueList.back().second->GetItemLpValue()->size();
                j_key._type = JsonType::Array;
                arrValueList.pop_back();
                if (arrValueList.size() != 0) {
                    arrValueList.back().second->GetItemLpValue()->push_back(j_value);
                    continue;
                }
            }
            else if (value == L"") {                               //Null
                JsonItem<JNull>* objList = new JsonItem<JNull>();
                size_t size = sizeof(objList);
                j_value._value = objList;
                j_value._size = 0;
                j_key._type = JsonType::Null;
            }
            std::pair<JsonKey, JsonValue> pair(j_key, j_value);
            if (!isObjEnd) {
                objList.back().second->GetItemRefValue().GetContent().push_back(pair);
            }
            else content.push_back(pair);
            key = L"";
            value = L"";
            isKey = true;
            if (objListDeep == 1 && isObj) isObj = false;
        }
        else {
            if (isKey && isQuote) key += std::wstring(1, ch);
            else if (isKey && !isQuote) return false;
            else if (!isKey) value += std::wstring(1, ch);
        }
        if (objListDeep < 0 || arrDeep < 0) return false;

    }
    return true;
}

bool JsonSerialize::Load(const string filePath) {
    try {
        if (filePath != "") {
            this->_filePath = filePath;
        }
        OpenFile(this->_filePath);
        while (!_file.eof()) {
            char buffer[0x4000] = "";
            size_t length = sizeof(buffer) / sizeof(char);
            _file.read(buffer, length);
            if (!Analysis(buffer, content, length)) {
                CloseFile();
                return false;
            }
        }
        CloseFile();
        freeAll();
        return objListDeep == 0 && arrDeep == 0;
    }
    catch (std::exception ex) {
        throw ex;
    }
}

std::vector<std::pair<JsonKey, JsonValue>>& JsonSerialize::GetContent() {
    return this->content;
}
template<typename T>
JsonItem<T>* JsonSerialize::GetValueByKey(string key)
{
    JsonItem<T>* temp_value = nullptr;
    for (auto item : this->content) {
        if (item.first._key == key) {
            temp_value = (JsonItem<T>*)(item.second._value);
            break;
        }
    }
    return temp_value;
}

void coutTab(int count) {
    while (count--) {
        std::cout << '\t';
    }
}

void JsonSerialize::printAll(int tab) {
    auto res = this->content;
    coutTab(tab);
    std::cout << "{" << std::endl;
    for (auto it = res.begin(); it != res.end(); it++) {
        JsonKey temp_key = it->first;
        if (temp_key._type == JsonType::Number) {
            JsonItem<double>* temp_value = (JsonItem<double>*)(it->second._value);
            coutTab(tab + 1);
            std::wcout << temp_key._key << " : " << temp_value->GetItemRefValue() << std::endl;
        }
        else if (temp_key._type == JsonType::String) {
            JsonItem<std::wstring*>* temp_value = (JsonItem<std::wstring*>*)(it->second._value);
            coutTab(tab + 1);
            std::wcout << temp_key._key << " : " << *temp_value->GetItemRefValue() << "" << std::endl;
        }
        else if (temp_key._type == JsonType::Null) {
            JsonItem<JNull>* temp_value = (JsonItem<JNull>*)(it->second._value);
            coutTab(tab + 1);
            std::wcout << temp_key._key << " : " << "NULL" << std::endl;
        }
        else if (temp_key._type == JsonType::Bool) {
            JsonItem<bool>* temp_value = (JsonItem<bool>*)(it->second._value);
            coutTab(tab + 1);
            std::wcout << temp_key._key << " : " << (temp_value->GetItemRefValue() ? "true" : "false") << std::endl;
        }
        else if (temp_key._type == JsonType::Object) {
            JsonItem<JsonSerialize>* temp_value = (JsonItem<JsonSerialize>*)(it->second._value);
            temp_value->GetItemRefValue().printAll(tab + 1);
        }
        else if (temp_key._type == JsonType::Array) {
            JsonItem<std::vector<JsonValue>>* temp_value =
                (JsonItem<std::vector<JsonValue>>*)(it->second._value);
            coutTab(tab + 1);
            std::wcout << temp_key._key << ":[" << std::endl;
            for (auto item : temp_value->GetItemRefValue()) {
                JsonItem<JsonSerialize>* tt_value = (JsonItem<JsonSerialize>*)(item._value);
                tt_value->GetItemLpValue()->printAll(tab + 2);
            }
            coutTab(tab + 1);
            std::cout << "]" << std::endl;
        }
    }
    coutTab(tab);
    std::cout << "}" << std::endl;
}


// NAME_SPACE_END()

main.cpp

int main() {
    JsonSerialize json("F:\\C++\\mySource\\example\\test.json");
    json.Load();
    json.printAll();
    return 0;
}

关于“基于C++怎么编写一个Json解析器”这篇文章的内容就介绍到这里，感谢各位的阅读！相信大家对“基于C++怎么编写一个Json解析器”知识都有一定的了解，大家如果还想学习更多知识，欢迎关注编程之家行业资讯频道。

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

蚂蚁庄园小课堂2024年6月29日答案 6月29日蚂蚁森林庄园答案今日最新
蚂蚁庄园小课堂2024年6月29日答案是什么?进入支付宝一起饲养小鸡，小鸡会生产爱心鸡蛋，这些鸡蛋是可以拿去捐赠的，也是一个公益小游戏。玩家每天都可以领取180g饲料，前提是回答正确，错误的话只能获得30g的鸡饲料。蚂蚁庄园小课堂2024年6月29日答案是什么?用户可以查看
谷歌小恐龙怎么调出来 谷歌浏览器调出小恐龙的方法
谷歌小恐龙怎么调出来，我们将连接电脑的网络拔掉或者禁用网络，然后打开Google Chrome浏览器，随便输入一个网址，然后在未连接到互联网这行字上就会出现恐龙了。小伙伴想知道谷歌小恐龙怎么调出来，下面小编给大家带来了谷歌浏览器调出小恐龙的方法。
蚂蚁庄园小课堂2024年6月22日答案 6月22日蚂蚁森林庄园答案今日最新
蚂蚁庄园小课堂2024年6月22日答案是什么?每天蚂蚁庄园小课堂都会更新题目为大家提供一个获取小鸡饲料的渠道，只要玩家能够正确的回答就可以获得180g的小鸡饲料，如果回答错误只能获得30g的饲料，蚂蚁庄园小课堂2024年6月22日答案是什么?为了用户可以获得满满的小鸡饲料，
火绒为什么不建议大家用 火绒不建议大家用的原因
火绒为什么不建议大家用，火绒对于用户的要求比较高，查杀病毒的水平不是很高，需要使用自定义规则进行使用，对小白用户不友好，资源占用不低，可能对电脑性能造成影响。小伙伴想知道为什么不建议使用火绒，下面小编给大家带来了火绒不建议大家用的原因
百度网盘电脑版订阅的分享在哪 百度网盘电脑版订阅的分享在什么位置
百度网盘电脑版订阅的分享在哪?百度网盘电脑版订阅的分享在什么位置?最近有很多小伙伴在使用百度网盘电脑版的时候，需要打开订阅的分享，不知道怎么去具体操作。首先双击打开软件，接着点击上方的更多选项，然后点击其中的分享动态，最后点击其中的订阅即可。接下
notepad怎么替换换行符 notepad替换换行符教程
notepad怎么替换换行符，打开notepad++软件，点击菜单栏的视图，选择显示符合-显示所有符号，按下ctrl+h打开替换窗口，在查找中输入“ ”，点击下方的扩展，然后输入要替换的字符就好啦。小伙伴想知道在notepad中吧换行符给替换掉，下面小编给大家带来了notepad替换换行符教程
蚂蚁庄园小课堂2024年6月28日答案 6月28日蚂蚁森林庄园答案今日最新
蚂蚁庄园小课堂2024年6月28日答案是什么?蚂蚁庄园小课堂每天都更新题目，只要正确回答问题每天都可以获得180g饲料，回答错误则是获得30g，用户可以每天都参与活动，领取小鸡饲料。蚂蚁庄园小课堂2024年6月28日答案是什么?这次的问题很简单，如果有关注一些实时资讯的都会
蚂蚁庄园小课堂2024年7月3日答案 7月3日蚂蚁森林庄园答案今日最新
蚂蚁庄园小课堂2024年7月3日答案是什么?蚂蚁庄园小课堂每天都会更新新的问题提供给玩家，玩家可以正确的回答然后获取180g的鸡饲料，鸡饲料能够帮助自己的小鸡快速的产蛋，这些简单可以进行一些公益的捐款，蚂蚁庄园小课堂2024年7月3日答案是什么?一共有两个问题，回答
蚂蚁庄园小课堂2024年6月20日答案 6月20日蚂蚁森林庄园答案今日最新
蚂蚁庄园小课堂2024年6月20日答案是什么?蚂蚁庄园小课堂开课了，在支付宝中我们可以通过回答问题去获取饲料，使用饲料去喂养小鸡，小鸡就可以产出鸡蛋，这些鸡蛋可以进行工艺捐款。蚂蚁庄园小课堂2024年6月20日答案是什么?这些问题有时候很简单，但有时候却有些冷知识
蚂蚁庄园小课堂2024年6月26日答案 6月26日蚂蚁森林庄园答案今日最新
蚂蚁庄园小课堂2024年6月26日答案是什么?蚂蚁庄园小课堂开课了，玩家如果有在饲养小鸡就会知道蚂蚁庄园小课堂其实是一个非常简单的回答问题领饲料的任务，玩家每天都可以在这里获得新的问题，正确回答就可以获得180g的饲料，这些饲料可以加速小鸡成长，快速获得鸡蛋
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native