【C++】封装使用jsoncpp的类

最新推荐文章于 2022-10-11 15:25:12 发布
最新推荐文章于 2022-10-11 15:25:12 发布
阅读量5.4k 收藏 6
点赞数 1
分类专栏： C++ 文章标签： jsoncpp json类封装
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/timothy721/article/details/19993495
版权
C++ 同时被 2 个专栏收录
11 篇文章 0 订阅
订阅专栏
整理
6 篇文章 0 订阅
订阅专栏

封装使用jsoncpp的类包括5种功能

1.是否存在节点

    bool IsNodeExisted(string jsonObj, string strNode);   

2.为数组增加元素

    int AppendArrayObject(string& jsonObj, string strNode, string strValue);

3.获取节点值

   int GetJsonValue(string jsonObj,string strNode,string& strOut);

4.设置节点值

   int SetJsonObejct(string& jsonObj, string strNode, string strValue);

5.获取对象节点列表

   int GetJsonChildNodeArray(string jsonObj, string strNode,vector<string>& vecChildNode);

**************************************************************************************************

JsonBase.h

**************************************************************************************************

#pragma once
#include "json/reader.h"
#include <sstream>
#include <algorithm>
using namespace std;

#pragma comment(lib,"json/json_vc71_libmtd.lib")

class JsonBase
{
public:
    JsonBase(void);
    ~JsonBase(void);
public:
    bool IsNodeExisted(string jsonObj, string strNode);

    int AppendArrayObject(string& jsonObj, string strNode, string strValue);
    int GetJsonValue(string jsonObj,string strNode,string& strOut);
    int GetJsonChildNodeArray(string jsonObj, string strNode,vector<string>& vecChildNode);
    int SetJsonObejct(string& jsonObj, string strNode, string strValue);
private:
    bool ReadJson(string jObect, Json::Value& root);
    bool GetJsonObject(Json::Value &jsonObj, string strValue);
};


**************************************************************************************************

JsonBase.cpp

**************************************************************************************************

#include "JsonBase.h"
#include "json/reader.h"
#include <sstream>
#include <algorithm>

using namespace std;
enum ReturnType
{
    RET_ERROR = -1,
    RET_OK
};

//声明
void ConvertStr(string& str);
void TrimQuotationMarks(string& str);
void RemoveSpaceAndLineFeed(string& strSource);
bool ContainObject(string strValue, Json::Value &jsonObj);

string ReturnJsonIndexString(Json::Value jObejct, string strValue);
string&   replace_all(string&   str,const   string&   old_value,char new_value);
vector<string> SplitObject(string strNode);
vector<string> GetChildNodList(Json::Value jObejct, string strValue);
vector<string> split(const string& src, string delimit,string null_subst);

vector<string> split(const string& src, string delimit,string null_subst="")  
{  
    typedef basic_string<char>::size_type S_T;  
    static const S_T npos = -1;  

    if( src.empty() || delimit.empty() )   
        throw "split: empty string\0";  

    vector<string> v;  
    S_T deli_len = delimit.size();  
    unsigned int index = npos, last_search_position = 0;  
    while( (index=src.find(delimit, last_search_position))!=npos )  
    {  
        if(index==last_search_position)  
            v.push_back(null_subst);  
        else  
            v.push_back( src.substr(last_search_position, index-last_search_position) );  
        last_search_position = index + deli_len;  
    }  
    string last_one = src.substr(last_search_position);  
    v.push_back( last_one.empty()? null_subst:last_one );  
    return v;  
}
vector<string> SplitObject(string strNode)
{
    vector<string> vecRet;
    for (size_t i=0; i<strNode.size(); i++)
    {
        if (strNode[i] == '.')
        {
            vecRet.push_back(strNode.substr(0, i));
        }
        else if (strNode[i] == '[')
        {
            string strTemp = strNode.substr(0,i);
            if (strTemp != "")
            {
                vecRet.push_back(strTemp);
            }
        }
    }
    if (strNode != "")
    {
        vecRet.push_back(strNode);
    }
    return vecRet;
}
vector<string> GetChildNodList(Json::Value jObejct, string strValue)
{
    //查找该节点
    vector<string> vecArray = split(strValue,".");

    bool bFlag = true;
    Json::Value jsonObj = jObejct;
    for (size_t i=0; i<vecArray.size(); i++)
    {
        if (!jsonObj.isMember(vecArray[i]))
        {
            bFlag = false;
            break;
        }
        if (i<vecArray.size())
        {
            jsonObj = jsonObj.get(vecArray[i],NULL);
        }
    }	
    Json::Value jsonChildNode= jsonObj[vecArray[vecArray.size()-1]];
    return jsonChildNode.getMemberNames();
}
bool JsonBase::ReadJson(string jObect, Json::Value& root)
{
    Json::Reader jsonReader;

    if (!jsonReader.parse(jObect, root))
    {
        cout<<"解析Json数据结构失败!\n";
        return false;
    }
    return true;
}
void RemoveSpaceAndLineFeed(string& strSource)
{
    string strRet;
    for (size_t i=0; i< strSource.size(); i++)
    {
        if (strSource[i] != ' ' && strSource[i] != '\n')
        {
            strRet += strSource[i];
        }
    }
    strSource = strRet;
}

bool JsonBase::GetJsonObject(Json::Value &jsonObj, string strValue) 
{
    if (strValue == "")
    {
        return true;
    }

    vector<string> vecArray = split(strValue,".");
    for (size_t i=0; i<vecArray.size(); i++)
    {
        string strKey = vecArray[i];

        int nStart = strKey.find('[');
        int nEnd   = strKey.find(']');

        if (-1 != nStart && -1 != nEnd)
        {
            size_t nPos = -1;
            sscanf(strKey.substr(nStart+1,nEnd-nStart-1).c_str(),"%d", &nPos);

            string strTempKey = "";
            if (nStart != 0)
            {
                strTempKey = strKey.substr(0,nStart);
            }			

            if (strTempKey != "")
            {				
                if (jsonObj.type() != Json::objectValue)
                {
                    cout<<"当前节点不是对象!\n";
                    return false;
                }
                if (!jsonObj.isMember(strTempKey))
                {
                    cout<<"节点不存在!\n";
                    return false;
                }
                if (i<vecArray.size())
                {
                    jsonObj = jsonObj.get(strTempKey,NULL);	
                }
            }

            do 
            {
                Json::ValueType valueType = jsonObj.type();
                if (valueType == Json::arrayValue)
                {
                    if (nPos < 0)
                    {
                        int nSize = jsonObj.size();
                        //负数下标不能超过size大小
                        if (nPos*(-1) > nSize)
                        {
                            cout<<"节点下标越界!\n";
                            return false;							
                        }
                        nPos = nPos % nSize;
                        if (nPos != 0)
                        {
                            nPos += nSize;
                        }
                    }
                    else if (nPos > jsonObj.size()-1)
                    {
                        cout<<"节点下标越界!\n";
                        return false;
                    }

                    jsonObj = jsonObj.get(nPos,NULL);
                }
                else
                {
                    cout<<"节点不是数组!\n";                    
                    return false;
                }

                strKey = strKey.substr(nEnd+1);
                nStart = strKey.find('[');
                nEnd   = strKey.find(']');

                sscanf(strKey.substr(nStart+1,nEnd-nStart-1).c_str(),"%d", &nPos);
            } while (-1 != nStart && -1 != nEnd);
        }
        else 
        {
            if (jsonObj.type() != Json::objectValue)
            {
                cout<<"节点不是数组!\n"; 
                return false;
            }
            if (!jsonObj.isMember(strKey))
            {
                cout<<"节点不存在!\n";
                return false;
            }
            if (i<vecArray.size())
            {
                jsonObj = jsonObj.get(strKey,NULL);
            }
        }
    }	
    return true;
}
JsonBase::JsonBase(void)
{

}
JsonBase::~JsonBase(void)
{

}
int JsonBase::SetJsonObejct(string& jsonObj, string sNode, string strValue)
{
    Json::Value root;
    if (!ReadJson(jsonObj, root))
    {
        return RET_ERROR;
    }	

    string strPreNode; //前一个节点
    string strNode;    //当前节点
    Json::Value obj = root; //当前节点对象

    //需先将值转化为对象
    Json::Reader jsonReader;
    Json::Value newObject;
    jsonReader.parse(strValue, newObject);

    //判断输入，字符串必须以引号括起来
    string strVal = strValue;
    int nStart = strVal.find('\"');
    int nEnd   = strVal.find_last_of('\"');
    if (newObject.type() == Json::stringValue || newObject.type() == Json::nullValue)
    {
        if (!(0 == nStart && strVal.size()-1 == nEnd))
        {
            cout<<"值参数输入错误!\n";
            return RET_ERROR;
        }
        else
        {
            TrimQuotationMarks(strVal);
        }
    }

    string strKey = sNode; 
    vector<string> vecObject = SplitObject(strKey);

    obj = newObject;
    if (newObject.type() == Json::stringValue || newObject.type() == Json::nullValue)
    {
        obj = strVal;
    }
    for (size_t i=vecObject.size()-1; i>=0; i--)
    {
        //节点为空，代表改root
        if (vecObject.size() == 0)
        {
            if (newObject.type() == Json::stringValue || newObject.type() == Json::nullValue)
            {
                root = strVal;
            }
            else
            {
                root = newObject;
            }
            obj = root;
            break;
        }

        strNode = vecObject[i];
        //最后一条
        if (i == 0)
        {
            int nStart = strNode.find('[');
            int nEnd   = strNode.find(']');

            if (-1 != nStart && -1 != nEnd)
            {
                int nPos = -1;
                sscanf(strNode.substr(nStart+1,nEnd-nStart-1).c_str(),"%d", &nPos);
                if (!root.isArray())
                {
                    return RET_ERROR;
                }

                if (nPos < 0)
                {
                    int nSize = root.size();
                    //负数下标不能超过size大小
                    if (nPos*(-1) > nSize)
                    {
                        cout<<"节点下标越界!\n";
                        return RET_ERROR;
                    }
                    nPos = nPos % nSize;
                    if (nPos != 0)
                    {
                        nPos += nSize;
                    }
                }
                else if (nPos > root.size()-1)
                {
                    cout<<"节点下标越界!\n";
                    return RET_ERROR;
                }
                if (obj.type() == Json::stringValue || obj.type() == Json::nullValue)
                {
                    root[nPos] = strVal;
                }
                else
                {
                    root[nPos] = obj;
                }
            }
            else
            {
                if (root.type() != Json::objectValue)
                {
                    cout<<"当前节点不是对象!\n";
                    return RET_ERROR;
                }
                if (obj.type() == Json::stringValue || obj.type() == Json::nullValue)
                {
                    root[strNode] = strVal;
                }
                else
                {
                    root[strNode] = obj;
                }
            }
            obj = root;
            break;
        }

        strPreNode = vecObject[i-1];
        Json::Value tempObject = root; 

        if (!GetJsonObject(tempObject, strPreNode))
        {
            cout<<"节点不存在!\n";
            return RET_ERROR;
        }  

        //获取Key
        if (strNode.substr(strPreNode.size(),1) == ".")
        {
            strKey = strNode.substr(strPreNode.size()+1);
        }  
        else
        {
            strKey = strNode.substr(strPreNode.size());
        }
        //key为数组下标
        int nStart = strKey.find('[');
        int nEnd   = strKey.find(']');

        if (-1 != nStart && -1 != nEnd)
        {
            int nPos = -1;
            sscanf(strKey.substr(nStart+1,nEnd-nStart-1).c_str(),"%d", &nPos);
            if (!tempObject.isArray())
            {
                cout<<"节点不是数组!\n";
                return RET_ERROR;
            }
            if (nPos < 0)
            {
                int nSize = tempObject.size();
                //负数下标不能超过size大小
                if (nPos*(-1) > nSize)
                {
                    cout<<"节点下标越界!\n";
                    return RET_ERROR;
                }
                nPos = nPos % nSize;
                if (nPos != 0)
                {
                    nPos += nSize;
                }
            }
            else if (nPos >tempObject.size()-1)
            {
                cout<<"节点下标越界!\n";
                return RET_ERROR;
            }
            tempObject[nPos] = obj;
        }
        else
        {
            tempObject[strKey] = obj;
        }
        obj = tempObject;
    }
    root = obj;
    jsonObj = root.toStyledString();
    return RET_OK;
}

string ReturnJsonIndexString(Json::Value jObejct, string strValue)
{
    string strKey = strValue;
    int nStart = strKey.find('[');
    int nEnd   = strKey.find(']');
    if (-1 != nStart && -1 != nEnd)
    {
        int nPos = -1;
        sscanf(strKey.substr(nStart+1,nEnd-nStart-1).c_str(),"%d", &nPos);
        if (nPos < 0)
        {
            cout<<"数组下标不正确!\n";
            return "";
        }
        string strTempKey = strKey.substr(0,nStart);
        vector<string> retVec = GetChildNodList(jObejct,strTempKey);
        cout<<"members.size()="<<retVec.size()<<endl;
        for (size_t k=0; k<retVec.size(); k++)
        {
            cout<<"members["<<k<<"]="<<retVec[k]<<endl;
        }
        string strIndex = retVec[nPos];
        string strRet = strKey.substr(0,nStart) + "." + strIndex + strKey.substr(nEnd+1);
        strValue = strRet;
        return ReturnJsonIndexString(jObejct, strValue);
    }
    else
    {
        return strValue;
    }
}
string&   replace_all(string&   str,const   string&   old_value,char new_value)     
{     
    while(true)   {     
        string::size_type   pos(0);     
        if(   (pos=str.find(old_value))!=string::npos   ) 
        {
            string strTemp;
            strTemp += str.substr(0,pos);
            strTemp += new_value;
            strTemp += str.substr(pos+old_value.size());
            str = strTemp;
        }
        else   break;     
    }     
    return   str;     
}  
void TrimQuotationMarks(string& str)
{
    if (0 == str.find('\"'))
    {
        str = str.substr(1);
    }
    if ( str.size()-1 == str.find_last_of('\"'))
    {
        str = str.substr(0,str.size()-1);
    }
}
void ConvertStr(string& str)
{
    string strVal = str;
    strVal = replace_all(strVal,"\\b",'\b');
    strVal = replace_all(strVal,"\\f",'\f');	
    strVal = replace_all(strVal,"\\n",'\n');
    strVal = replace_all(strVal,"\\r",'\r');
    strVal = replace_all(strVal,"\\t",'\t');
    strVal = replace_all(strVal,"\\\"",'\"');
    strVal = replace_all(strVal,"\\\'",'\'');
    strVal = replace_all(strVal,"\\\\",'\\');

    str = strVal;
}
int JsonBase::GetJsonValue(string jsonObj,string strNode,string& strOut)
{
    Json::Value root;
    if (!ReadJson(jsonObj, root))
    {
        return RET_ERROR;
    }

    bool bFlag = true;
    Json::Value jObject = root;
    if (strNode != "")
    {
        bFlag  = GetJsonObject(jObject, strNode);
    }  

    string strRet = "";
    if (!bFlag)
    {
       strOut = strRet;
       return RET_ERROR;
    }
    else
    {
        strRet = jObject.toStyledString();
        strRet = strRet.substr(0,strRet.size()-1);
        if (jObject.type() != Json::objectValue)
        {
            ConvertStr(strRet);
            TrimQuotationMarks(strRet);
        }
        strOut = strRet;
        return jObject.type();
    }
    return RET_OK;	
}

int JsonBase::GetJsonChildNodeArray(string jObject, string strNode,vector<string>& vecChildNode)
{
    Json::Value root;
    if (!ReadJson(jObject, root))
    {
        return RET_ERROR;
    }	
    Json::Value jsonObj = root;

    //查找该节点
    if (!GetJsonObject(jsonObj, strNode))
    {
        cout<<"节点不存在!\n";
        return RET_ERROR;
    }  

    string strRet,strTemp;
    //清空返回值内容
    if (!vecChildNode.empty())
    {
        vecChildNode.clear();
    }

    if (jsonObj.type() == Json::objectValue)
    {
        Json::Value::Members members = jsonObj.getMemberNames();
        Json::Value::Members::iterator it = members.begin();
        while (it != members.end())
        {
            strTemp = *it;
            strTemp = strTemp.substr(0,strTemp.size());
            vecChildNode.push_back(strTemp);
            it++;
        }
    }
    else if (jsonObj.type() == Json::arrayValue)
    {
        for (size_t i=0; i<jsonObj.size(); i++)
        {
            strTemp = jsonObj[i].toStyledString();
            strTemp = strTemp.substr(0,strTemp.size()-1);
            if (jsonObj[i].type() != Json::objectValue)
            {
                ConvertStr(strTemp);
                TrimQuotationMarks(strTemp);
            }
            vecChildNode.push_back(strTemp);
        }
    }
    else
    {
        return RET_ERROR;
    }	
    return RET_OK;
}

bool ContainObject(string strValue, Json::Value &jsonObj)
{
    if (!jsonObj.isMember(strValue))
    {
        return false;
    }
    jsonObj = jsonObj[strValue];
    return true;
}
bool JsonBase::IsNodeExisted(string jObject, string strNode)
{
    Json::Value root;
    if (!ReadJson(jObject, root))
    {
        return false;
    }

    string strValue =strNode;
    if (strValue == "")
    {
        cout<<"输入字符串为空!\n";
        return false;
    }

    vector<string> vecArray = SplitObject(strValue,".");

    for (size_t i=0; i<vecArray.size(); i++)  
    {  
        Json::Value jsonObj = root; 
        if (!GetJsonObject(jsonObj, vecArray[i]))
        {
            return false;
        }  
    }  
    return true;
}

int JsonBase::AppendArrayObject(string& jsonObj, string sNode, string strValue)
{
    Json::Value root;
    if (!ReadJson(jsonObj,root))
    {
        return RET_ERROR;
    }

    string strPreNode;   //前一个节点
    string strNode;      //当前节点
    Json::Value obj = root; //当前节点对象

    //需先将值转化为对象
    Json::Reader jsonReader;
    Json::Value newObject;
    jsonReader.parse(strValue, newObject);

    string strKey = sNode; 
    vector<string> vecObject;

    //append root节点
    if (strKey == "")
    {
        if (!root.isArray())
        {
            cout<<"节点不是数组!\n";
            return RET_ERROR;
        }
        if (newObject.type() == Json::stringValue || newObject.type() == Json::nullValue)
        {
            root.append(strValue);
        }
        else
        {
            root.append(newObject);
        }
        obj = root;
    }
    else
    {
        vecObject = SplitObject(strKey);

        //只有单个节点，操作root
        if (vecObject.size() == 0)
        {
            int nStart = strKey.find('[');
            int nEnd   = strKey.find(']');
            if (-1 != nStart && -1 != nEnd)
            {
                int nPos = -1;
                sscanf(strKey.substr(nStart+1,nEnd-nStart-1).c_str(),"%d", &nPos);

                if (nPos < 0)
                {
                    int nSize = root.size();
                    //负数下标不能超过size大小
                    if (nPos*(-1) > nSize)
                    {
                        cout<<"节点下标越界!\n";
                        return RET_ERROR;
                    }
                    nPos = nPos % nSize;
                    if (nPos != 0)
                    {
                        nPos += nSize;
                    }
                }
                else if (nPos > root.size()-1)
                {
                    cout<<"节点下标越界!\n";
                    return RET_ERROR;
                }
                if (newObject.type() == Json::stringValue || newObject.type() == Json::nullValue)
                {
                    root[nPos].append(strValue);
                }
                else
                {
                    root[nPos].append(newObject);
                }
            }
            else
            {
                if (newObject.type() == Json::stringValue || newObject.type() == Json::nullValue)
                {
                    root[strKey].append(strValue);
                }
                else
                {
                    root[strKey].append(newObject);
                }
            }
            obj = root;
        }
        else
        {
            //插入点
            Json::Value jObejct = root;
            if (!GetJsonObject(jObejct, sNode))
            {
                return RET_ERROR;
            }
            if (!jObejct.isArray())
            {
                cout<<"节点不是数组!\n";
                return RET_ERROR;
            }

             if (newObject.type() == Json::nullValue)
            {
                jObejct.append(strValue);
            }
            else 
            {
                jObejct.append(newObject);
            }
            obj = jObejct;
        }
    }
    for (size_t i=vecObject.size()-1; i>=0; i--)
    {
        if (vecObject.size() == 0)
        {
            break;
        }

        strNode = vecObject[i];
        //最后一条
        if (i == 0)
        {
            int nStart = strNode.find('[');
            int nEnd   = strNode.find(']');

            if (-1 != nStart && -1 != nEnd)
            {
                int nPos = -1;
                sscanf(strNode.substr(nStart+1,nEnd-nStart-1).c_str(),"%d", &nPos);
                if (!root.isArray())
                {
                    return RET_ERROR;
                }

                if (nPos < 0)
                {
                    int nSize = root.size();
                    //负数下标不能超过size大小
                    if (nPos*(-1) > nSize)
                    {
                        cout<<"节点下标越界!\n";
                        return RET_ERROR;
                    }
                    nPos = nPos % nSize;
                    if (nPos != 0)
                    {
                        nPos += nSize;
                    }
                }
                else if (nPos > root.size()-1)
                {
                    cout<<"节点下标越界!\n";
                    return RET_ERROR;
                }
                root[nPos] = obj;
            }
            else
            {
                root[strNode] = obj;
            }
            obj = root;
            break;
        }

        strPreNode = vecObject[i-1];
        Json::Value tempObject = root; 

        if (!GetJsonObject(tempObject, strPreNode))
        {
            return RET_ERROR;
        }  

        //获取Key
        if (strNode.substr(strPreNode.size(),1) == ".")
        {
            strKey = strNode.substr(strPreNode.size()+1);
        }  
        else
        {
            strKey = strNode.substr(strPreNode.size());
        }
        //key为数组下标
        int nStart = strKey.find('[');
        int nEnd   = strKey.find(']');

        if (-1 != nStart && -1 != nEnd)
        {
            int nPos = -1;
            sscanf(strKey.substr(nStart+1,nEnd-nStart-1).c_str(),"%d", &nPos);
            if (!tempObject.isArray())
            {
                return RET_ERROR;
            }
            if (nPos < 0)
            {
                int nSize = tempObject.size();
                //负数下标不能超过size大小
                if (nPos*(-1) > nSize)
                {
                    cout<<"节点下标越界!\n";
                    return RET_ERROR;
                }
                nPos = nPos % nSize;
                if (nPos != 0)
                {
                    nPos += nSize;
                }
            }
            else if (nPos >= tempObject.size())
            {
                cout<<"节点下标越界!\n";
                return RET_ERROR;
            }
            tempObject[nPos] = obj;
        }
        else
        {
            tempObject[strKey] = obj;
        }
        obj = tempObject;
    }
    root = obj;
    jsonObj = root.toStyledString();
    return RET_OK;
}


**************************************************************************************************

main.cpp

**************************************************************************************************

#include <iostream>
#include <string>
#include "JsonBase.h"
using namespace std;
int main()
{
    string strObject = "{\"a\":[\"1\",\"2\"]}";
    JsonBase json;

    //bool GetJsonObject(Json::Value &jsonObj, string strValue);
    vector<string> vec;
    json.GetJsonChildNodeArray(strObject,"",vec);
    for (int i=0;i<vec.size();i++)
    {
        cout<<vec[i]<<endl;
    }
    //int SetJsonObejct(string jsonObj, string strNode, string strValue);
    json.SetJsonObejct(strObject,"a[1]","\"0\"");
    cout<<strObject<<endl;
    
    //int GetJsonValue(string jsonObj,string strNode,string strOut);
    string strOut;
    json.GetJsonValue(strObject,"a[1]",strOut);
    cout<<strOut<<endl;
    //bool IsNodeExisted(string jsonObj, string strNode);
    cout<<json.IsNodeExisted(strObject,"a[1]")<<endl;
    cout<<json.IsNodeExisted(strObject,"a[2]")<<endl;
    //int AppendArrayObject(string jsonObj, string strNode, string strValue);
    json.AppendArrayObject(strObject,"a","\"3\"");
    json.GetJsonValue(strObject,"a",strOut);
    cout<<strOut<<endl;
    return 0;
}


转载源地址：http://blog.csdn.net/timothy721/article/details/19993495



Kayee2012
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
史上最详尽的JsonCpp使用指南（含c++封装的源代码）
03-13
详细介绍如何利用JsonCpp0.5.0生成调试版静态链接库和发行版静态链接库。详细介绍如何使用生成的静态链接库，详细介绍JsonCpp的Value类的构造方法、操作符重载等，详细介绍Writer的三个派生类的使用方法，详细介绍Reder类的使用方法。源代码演示如何封装C++类，使用toJson方法将C++对象转换为json字符串，使用fromJosn方法用json字符串给c++对象赋值。所有源代码都在文档中完整展示。
【C++】jsoncpp封装和解析字符串、数字、布尔值和数组
豆芽菜
06-20 1308
jsoncpp封装和解析字符串、数字、布尔值和数组
jsoncpp类的封装，方便使用
12-19
这是我参考Kayee2012的类进行简单修改了。JsonBase.cpp 的最下面有使用例子。方式使用！
JsonCPP 简易封装
07-12
本人对jsoncpp的一个简易封装，简化了对api的调用，基于jsoncpp r0.60源码，解压后将代码加入C++项目，包含zdJsonWrap.h即可使用基本的json解析和构造方法。
JsonCpp 简易封装 v2.5
11-02
JsonCpp 简易封装: 除了封装基础的API调用，还提供C++数据结构转换到json格式的一种实现案例， v2.5改善对C++二维数组转换的支持.
JsonCpp 简易封装 v2.3
10-31
JsonCpp简易封装，提供C++数据结构转换到JSON的实现方案，完善数组成员的转换支持
jsoncpp封装json与解析json
程序的尽头是数学，一日不推导赶不上买买提
02-09 758
1、封装json假设想将：hello， 封装成：{“result”:”hello”}const static string RESPONSE_KEY = &amp;amp;amp;amp;quot;result&amp;amp;amp;amp;quot;; Json::Value val; val[RESPONSE_KEY] = &amp;amp;amp;amp;quot;hello&amp;amp;amp;amp;quot;; Json::FastWriter jso
JsonCpp 简易封装 v2.4
11-02
JsonCpp简易封装v2.4是针对JsonCpp进行的二次开发，它不仅提供了基本的API接口，使得开发者可以便捷地进行JSON数据的序列化与反序列化，还特别强调了对C++数据结构到JSON格式的转换功能。在这个版本中，一个重要的新...
JsonCpp 简易封装 v2
09-05
对JsonCpp做了简易封装，同时附带了将C++ 数据结构 struct 转换为JSON格式的用例，实现了基本数据类型的自动解析转换，v2版本支持对数据结构中的数组成员转换到Json方案。 使用方法：将代码包含进VC++项目，在源码中包含zdJsonWrap.h。 例如 #include "..\include\zdJson\zdJsonWrap.h"
jsoncpp VC++下的JSON处理类
04-04
JsonCpp是比较出名的c++ json解析库,在json官网也是首推的。
封装后的C++读取json库
08-20
封装后的C++读取json库，以及安全的字段取值。 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。 易于人阅读和编写。同时也易于机器解析和生成。 它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。 这些特性使JSON成为理想的数据交换语言。
C++ 使用jsoncpp 封装及解析 json字符串（包含复杂数组）
Turbyun的博客
10-23 1万+
#include &lt;json/json.h&gt; #include &lt;string&gt; #include &lt;iostream&gt; using namespace std; int main() { //std::string strValue = "{\"name\":\"json\",\"array\":[{\"cpp\":\&
使用JsonCpp编写JSON封装程序的方法
liitdar的博客
08-14 2002
本文主要介绍使用JsonCpp库，通过C++编程语言编写JSON封装程序的具体方法。
JSON封装（C++）
tiny_lxf的博客
09-27 816
本文主要介绍使用 jsoncpp 库，编写C++语言的 JSON 封装程序。 1 示例程序 1.1 封装普通的json结构 示例代码（json_create_test1.cpp）如下：   #include &lt;iostream&gt; #include &lt;string&gt; #include &lt;jsoncpp/json/json.h&gt;...
C++数据交换格式库jsoncpp安装与使用详解
Wendy的博客
03-14 4229
目录一、json介绍1.1 pair1.2 object1.3 array二、jsoncpp库三、jsoncpp库下载、安装与使用四、jsoncpp常用类4.1 Json::Value4.2 Json::Reader4.3 Json::Writer五、代码示例 一、json介绍 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。 易于人阅读和编写。同时也易于机器解析和生成。 它基于JavaScript Programming Language, Standard
cJSON：封装与解析（一）
大川搬砖
07-05 2519
JSON：JavaScript Object Notation，一种数据交互格式。 cJSON：C 语言实现，用于封装和解析 json 数据。 cJSON开源地址：https://github.com/DaveGamble/cJSON 测试字符串： { "name":"sdc", "age":24, "height":1.78 } 1. 封装 enum j...
13008.CJSON 函数封装库操作(linux)
写给自己的笔记
10-11 370
cjson函数库二次封装
c++类 封装cjson_非常简单好用的C++JSON库CJsonObject
weixin_39523887的博客
12-19 508
1. JSON概述JSON： JavaScript 对象表示法( JavaScript Object Notation) 。是一种轻量级的数据交换格式。 它基于ECMAScript的一个子集。许多编程语言都很容易找到JSON 解析器和 JSON 库。 JSON 文本格式在语法上与创建 JavaScript 对象的代码相同。不同语言的不同json库对json标准的支持不尽相同，为了能让尽可能多的js...
C++ 使用Json封装数据和解析数据
热门推荐
学会简单的博客
08-30 3万+
使用C++和别的语言做交互比较常用的一种数据操作方式就是json。可以到GitHub上下载对应C++的json库源码，我自己下了一套之前的版本，可以正常使用。jsoncpp-src 编译出来的库名：json_vc71_libmtd.lib(debug) | json_vc71_libmt.lib(release) 需要包含的头文件： jsoncpp-src(对应源码)/include/json (
C++使用jsoncpp读取json
最新发布
07-27
要在C++中使用JsonCpp库来读取JSON文件，你可以按照以下步骤进行操作： 1. 首先，确保已经下载并安装了JsonCpp库，并将其包含在你的项目中。 2. 创建一个Json::Value对象来存储解析后的JSON数据。 3. 使用Json::...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值