• json2jsoncpp 基础应用篇


    如果你现在要做一个通讯功能的软件,里面的通讯协议是使用json格式传输的

    如果你要传输 3个整形数据 分辨为age,hp,mp,他们的默认值分辨为 16,99,88

    这次的通讯给他起个名字,叫做rpc1

    那么你就应该写一个这样的json文档:

    demo.json

    {
    
       //先给你的json数据包格式起个名字叫做rpc1
       "rpc1" 
       : 
       {
    
          "age":16,//年龄
          "hp":99,//
          "mp":88//魔法
    
       }
    
    }

    这样与你开发的同事或者是你自己就明白这个通讯格式了

    然后你用j2jc生成一个头文件

    json2jsoncpp demo.json demo.h

    demo.h

    //charset:
    
    #ifndef de1_json_h
    #define de1_json_h
    
    #include <vector>
    #include <string>
    #include "json/json.h"
    
    //////////////////////////////////////////////////////////////////////////
    //先给你的json数据包格式起个名字叫做rpc1
    class rpc1
    {
    private:
    public:
        rpc1()
        {
            age = 16;
            hp = 99;
            mp = 88;
        }
    
        void reset()
        {
            age = 16;
            hp = 99;
            mp = 88;
        }
    
        bool decode(std::string json)
        {
            Json::Reader jr;
            Json::Value jv;
            if(!jr.parse(json,jv))
            {
                printf("parse err!\n");
                return false;
            }
            return decode(jv);
    
        }
    
        bool decode(Json::Value & jv)
        {
            if( jv["age"].type()==Json::intValue || jv["age"].type()==Json::uintValue )
                age = jv["age"].asInt64();
    
            if( jv["hp"].type()==Json::intValue || jv["hp"].type()==Json::uintValue )
                hp = jv["hp"].asInt64();
    
            if( jv["mp"].type()==Json::intValue || jv["mp"].type()==Json::uintValue )
                mp = jv["mp"].asInt64();
    
            return true;
        }
    
        std::string encode2string()
        {
            return encode().toStyledString();
        }
    
        Json::Value encode()
        {
            Json::Value root;
    
            root["age"]=Json::Value(age);
            root["hp"]=Json::Value(hp);
            root["mp"]=Json::Value(mp);
            return root;
        }
    
        long long age; //年龄
    
        long long hp; //
    
        long long mp; //魔法
    
    }
    ;
    //////////////////////////////////////////////////////////////////////////
    
    
    #endif //de1_json_h

    你现在就可以使用它了

    测试一下他

    //先生成一个json数据拿来测试
        rpc1 aa;//建立一个默认的rpc1
        printf("%s\n",aa.encode2string().c_str());//输出他的json格式
        aa.hp=100;//修改里面的内容
        printf("%s\n",aa.encode2string().c_str());//输出他的json格式
        aa.reset();//还原
        printf("%s\n",aa.encode2string().c_str());//输出他的json格式

    执行结果:

    你可以看到,建立出来的对象输出json格式数据,里面的值是正确的

    紧接着,修改了hp的值为100后

    输出的

    image

    你可以看到输出结果第一次是默认值,第二次是修改后的,第三次是还原成默认的

    这就是他的基本功能

    j2jc还支持多维数组以及内嵌对象和对象数组:

    {
    
       //先给你的json数据包格式起个名字叫做rpc1
       "rpc1" 
       : 
       {
    
          "age":16,//年龄
          "hp":99,//
          "mp":88,//魔法
          
          //对象
          "obj"
          :
          {
             "a":1,
             "b":2
          },
          "arr":[[88]],//二维数组
          "arrobj":[{"c":1,"d":2}]//数组内嵌对象
    
       }
    
    }

    生成代码:

    //charset:
    
    #ifndef demo2_json_h
    #define demo2_json_h
    
    #include <vector>
    #include <string>
    #include "json/json.h"
    
    //////////////////////////////////////////////////////////////////////////
    //先给你的json数据包格式起个名字叫做rpc1
    class rpc1
    {
    private:
    public:
        rpc1()
        {
            age = 16;
            hp = 99;
            mp = 88;
        }
    
        void reset()
        {
            age = 16;
            arr.clear();
            arrobj.clear();
            hp = 99;
            mp = 88;
            obj.reset();
        }
    
        bool decode(std::string json)
        {
            Json::Reader jr;
            Json::Value jv;
            if(!jr.parse(json,jv))
            {
                printf("parse err!\n");
                return false;
            }
            return decode(jv);
    
        }
    
        bool decode(Json::Value & jv)
        {
            if( jv["age"].type()==Json::intValue || jv["age"].type()==Json::uintValue )
                age = jv["age"].asInt64();
    
            {
                Json::Value jv0=jv["arr"];
                if(jv0.type()==Json::arrayValue)
                {
                    std::vector<std::vector<long long> >  arr0 ;
                    for (unsigned int i1=0;i1<jv0.size();i1++)
                    {
                        Json::Value jv1=jv0[i1];
                        if(jv1.type()==Json::arrayValue)
                        {
                            std::vector<long long>  arr01 ;
                            for (unsigned int i2=0;i2<jv1.size();i2++)
                            {
                                Json::Value jv2=jv1[i2];
                                if( jv2.type()==Json::intValue || jv2.type()==Json::uintValue )
                                    arr01.push_back( jv2.asInt64() );
                            }
                            arr0.push_back(arr01);
                        }
                    }
                    arr=arr0;
                }
            }
    
            {
                Json::Value jv0=jv["arrobj"];
                if(jv0.type()==Json::arrayValue)
                {
                    std::vector<_class_arrobj>  arrobj0 ;
                    for (unsigned int i1=0;i1<jv0.size();i1++)
                    {
                        Json::Value jv1=jv0[i1];
                        if(jv1.type()==Json::objectValue)
                        {
                            _class_arrobj temp;
                            temp.decode(jv1);
                            arrobj0.push_back( temp );
                        }
                    }
                    arrobj=arrobj0;
                }
            }
    
            if( jv["hp"].type()==Json::intValue || jv["hp"].type()==Json::uintValue )
                hp = jv["hp"].asInt64();
    
            if( jv["mp"].type()==Json::intValue || jv["mp"].type()==Json::uintValue )
                mp = jv["mp"].asInt64();
    
            if(jv["obj"].type()==Json::objectValue)
                obj.decode( jv["obj"] );
    
            return true;
        }
    
        std::string encode2string()
        {
            return encode().toStyledString();
        }
    
        Json::Value encode()
        {
            Json::Value root;
    
            root["age"]=Json::Value(age);
            for(unsigned int i1=0;i1<arr.size();i1++)
            {
                for(unsigned int i2=0;i2<arr[i1].size();i2++)
                {
                    root["arr"][i1][i2]=arr[i1][i2];
                }
            }
            
            for(unsigned int i1=0;i1<arrobj.size();i1++)
            {
                root["arrobj"][i1]=arrobj[i1].encode();
            }
            
            root["hp"]=Json::Value(hp);
            root["mp"]=Json::Value(mp);
            root["obj"]=obj.encode();
            return root;
        }
    
        long long age; //年龄
    
        std::vector<std::vector<long long> >  arr;
    
        class _class_arrobj;
        std::vector<_class_arrobj>  arrobj;
        class _class_arrobj
        {
        private:
        public:
            _class_arrobj()
            {
                c = 1;
                d = 2;
            }
    
            void reset()
            {
                c = 1;
                d = 2;
            }
    
            bool decode(std::string json)
            {
                Json::Reader jr;
                Json::Value jv;
                if(!jr.parse(json,jv))
                {
                    printf("parse err!\n");
                    return false;
                }
                return decode(jv);
    
            }
    
            bool decode(Json::Value & jv)
            {
                if( jv["c"].type()==Json::intValue || jv["c"].type()==Json::uintValue )
                    c = jv["c"].asInt64();
    
                if( jv["d"].type()==Json::intValue || jv["d"].type()==Json::uintValue )
                    d = jv["d"].asInt64();
    
                return true;
            }
    
            std::string encode2string()
            {
                return encode().toStyledString();
            }
    
            Json::Value encode()
            {
                Json::Value root;
    
                root["c"]=Json::Value(c);
                root["d"]=Json::Value(d);
                return root;
            }
    
            long long c;
    
            long long d;
    
        }
        ;
        long long hp; //
    
        long long mp; //魔法
    
        //对象
        class _class_obj
        {
        private:
        public:
            _class_obj()
            {
                a = 1;
                b = 2;
            }
    
            void reset()
            {
                a = 1;
                b = 2;
            }
    
            bool decode(std::string json)
            {
                Json::Reader jr;
                Json::Value jv;
                if(!jr.parse(json,jv))
                {
                    printf("parse err!\n");
                    return false;
                }
                return decode(jv);
    
            }
    
            bool decode(Json::Value & jv)
            {
                if( jv["a"].type()==Json::intValue || jv["a"].type()==Json::uintValue )
                    a = jv["a"].asInt64();
    
                if( jv["b"].type()==Json::intValue || jv["b"].type()==Json::uintValue )
                    b = jv["b"].asInt64();
    
                return true;
            }
    
            std::string encode2string()
            {
                return encode().toStyledString();
            }
    
            Json::Value encode()
            {
                Json::Value root;
    
                root["a"]=Json::Value(a);
                root["b"]=Json::Value(b);
                return root;
            }
    
            long long a;
    
            long long b;
    
        }
        obj;
    
    }
    ;
    //////////////////////////////////////////////////////////////////////////
    
    
    #endif //demo2_json_h

    测试:

    rpc1 rr;
    
        printf("%s\n-----------------------\n",rr.encode2string().c_str());
    
        //测试二维数组
        std::vector<long long> x;
        x.push_back(1);
        x.push_back(2);
        rr.arr.push_back(x);
        x.clear();
        x.push_back(3);
        x.push_back(4);
        rr.arr.push_back(x);
    
        printf("%s\n-----------------------\n",rr.encode2string().c_str());
    
        //测试对象
        rr.reset();//还原默认值
        rr.obj.a=10;
        printf("%s\n-----------------------\n",rr.encode2string().c_str());
    
        //测试对象数组
        rpc1::_class_arrobj ca;//生成一个arrobj的对象,她现在的默认值是1,2
        ca.d=10;//修改d
        rr.arrobj.push_back(ca);
        ca.c=10;//修改c
        rr.arrobj.push_back(ca);
        printf("%s\n-----------------------\n",rr.encode2string().c_str());
    
        //单独reset obj
        rr.obj.reset();
        printf("%s\n-----------------------\n",rr.encode2string().c_str());
    
        //reset rr里的全部内容
        rr.reset();
        printf("%s\n-----------------------\n",rr.encode2string().c_str());

    结果:

    image

    这些就是j2jc的基本功能了。

    慢慢看代码消化一下吧

    本篇博客为原创作品,个人转载或引用时请保留本人的署名及博客网址,商业转载请事先联系。我的博客地址是:http://www.cnblogs.com/vanis/ , 我的hotmail.com邮箱是vanishs
  • 相关阅读:
    游戏热更思路
    Shader实现新手指引挖空圆形和矩形
    C#利用栈实现字符串运算解析
    Unity UGUI和特效(含粒子系统和3D Object)之间层级问题
    Unity中的值传递与引用传递
    Unity3D中的线程与协程
    进程、线程、协程、CPU
    Photon Server与Unity3D客户端的交互
    Photon Server的Unity3D客户端配置
    Photon Server的服务器端配置
  • 原文地址:https://www.cnblogs.com/vanis/p/2936062.html
Copyright © 2020-2023  润新知