C++實現(xiàn)對Json數(shù)據(jù)的友好處理

背景

C/C++客戶端需要接收和發(fā)送JSON格式的數(shù)據(jù)到后端以實現(xiàn)通訊和數(shù)據(jù)交互。C++沒有現(xiàn)成的處理JSON格式數(shù)據(jù)的接口，直接引用第三方庫還是避免不了拆解拼接?？紤]到此項目將會有大量JSON數(shù)據(jù)需要處理，避免不了重復(fù)性的拆分拼接。所以打算封裝一套C++結(jié)構(gòu)體對象轉(zhuǎn)JSON數(shù)據(jù)、JSON數(shù)據(jù)直接裝C++結(jié)構(gòu)體對象的接口，類似于數(shù)據(jù)傳輸中常見的序列化和反序列化，以方便后續(xù)處理數(shù)據(jù)，提高開發(fā)效率。

讓客戶滿意是我們工作的目標，不斷超越客戶的期望值來自于我們對這個行業(yè)的熱愛。我們立志把好的技術(shù)通過有效、簡單的方式提供給客戶，將通過不懈努力成為客戶在信息化領(lǐng)域值得信任、有價值的長期合作伙伴，公司提供的服務(wù)項目有：空間域名、網(wǎng)頁空間、營銷軟件、網(wǎng)站建設(shè)、牟平網(wǎng)站維護、網(wǎng)站推廣。

設(shè)計

目標：

通過簡單接口就能將C++結(jié)構(gòu)體對象實例轉(zhuǎn)換為JSON字符串數(shù)據(jù)，或?qū)⒁淮甁SON字符串數(shù)據(jù)加載賦值到一個C++結(jié)構(gòu)體對象實例。理想接口：Json2Object(inJsonString, outStructObject)，或者Object2Json(inStructObject, outJsonString)
支持內(nèi)置基本類型如bool，int，double的Json轉(zhuǎn)換，支持自定義結(jié)構(gòu)體的Json轉(zhuǎn)換，支持上述類型作為元素數(shù)組的Json轉(zhuǎn)換，以及支持嵌套的結(jié)構(gòu)體的Json轉(zhuǎn)換

效果：

先上單元測試代碼

TEST_CASE("解析結(jié)構(gòu)體數(shù)組到JSON串", "[json]")
{
    struct DemoChildrenObject
    {
        bool boolValue;
        int intValue;
        std::string strValue;
        /*JSON相互轉(zhuǎn)換成員變量聲明（必需）*/
        JSONCONVERT2OBJECT_MEMEBER_REGISTER(boolValue, intValue, strValue)
    };

    struct DemoObjct
    {
        bool boolValue;
        int intValue;
        std::string strValue;
        /*嵌套的支持JSON轉(zhuǎn)換的結(jié)構(gòu)體成員變量，數(shù)組形式*/
        std::vector< DemoChildrenObject> children;
        
        /*JSON相互轉(zhuǎn)換成員變量聲明（必需）*/
        JSONCONVERT2OBJECT_MEMEBER_REGISTER(boolValue, intValue, strValue, children)
    };

    DemoObjct demoObj;
    /*開始對demoObj對象的成員變量進行賦值*/
    demoObj.boolValue = true;
    demoObj.intValue = 321;
    demoObj.strValue = "hello worLd";

    DemoChildrenObject child1;
    child1.boolValue = true;
    child1.intValue = 1000;
    child1.strValue = "hello worLd child1";

    DemoChildrenObject child2;
    child2.boolValue = true;
    child2.intValue = ;
    child2.strValue = "hello worLd child2";

    demoObj.children.push_back(child1);
    demoObj.children.push_back(child2);
    /*結(jié)束對demoObj對象的成員變量的賦值*/

    std::string jsonStr;
    /*關(guān)鍵轉(zhuǎn)換函數(shù)*/
    REQUIRE(Object2Json(jsonStr, demoObj)); 
    std::cout << "returned json format: " << jsonStr << std::endl;

    /*打印的內(nèi)容如下：
    returned json format: {
       "boolValue" : true,
       "children" : [
          {
             "boolValue" : true,
             "intValue" : 1000,
             "strValue" : "hello worLd child1"
          },
          {
             "boolValue" : true,
             "intValue" : ,
             "strValue" : "hello worLd child2"
          }
       ],
       "intValue" : 321,
       "strValue" : "hello worLd"
    }
    */
    
    DemoObjct demoObj2;
    /*關(guān)鍵轉(zhuǎn)換函數(shù)*/
    REQUIRE(Json2Object(demoObj2, jsonStr));

    /*校驗轉(zhuǎn)換后的結(jié)構(gòu)體變量中各成員變量的內(nèi)容是否如預(yù)期*/
    REQUIRE(demoObj2.boolValue == true);
    REQUIRE(demoObj2.intValue == 321);
    REQUIRE(demoObj2.strValue == "hello worLd");

    REQUIRE(demoObj2.children.size() == 2);

    REQUIRE(demoObj.children[0].boolValue == true);
    REQUIRE(demoObj.children[0].intValue == 1000);
    REQUIRE(demoObj.children[0].strValue == "hello worLd child1");

    REQUIRE(demoObj.children[1].boolValue == true);
    REQUIRE(demoObj.children[1].intValue == );
    REQUIRE(demoObj.children[1].strValue == "hello worLd child2");
}

實現(xiàn)

本次我們只關(guān)注怎么友好地在結(jié)構(gòu)體與Json字符串之間進行轉(zhuǎn)換，而不深入關(guān)注JSon字符串具體如何與基本數(shù)據(jù)類型進行轉(zhuǎn)換。這個已經(jīng)有不少的第三方庫幫我們解決這個問題，如cJSON、Jsoncpp、rapidjson，不必再重復(fù)造輪子。

此次我們選擇了JsonCPP作為底層的JSON解析支持，如果想替換成其他三方庫也比較簡單，修改對應(yīng)嵌入的內(nèi)容即可。

我們的目標是實現(xiàn)兩個接口：

Json2Object(inJsonString, outStructObject)
Object2Json(inStructObject, outJsonString)

結(jié)合JsonCPP自身定義的類型，我們進一步需要實現(xiàn)的是：

Json2Object(const Json::Value& jsonTypeValue, outStructObject)
Object2Json(inStructObject, const std::string& key, Json::Value& jsonTypeValue)

基本數(shù)據(jù)類型轉(zhuǎn)換

對于如bool、int、double、string等基本數(shù)據(jù)類型，該實現(xiàn)均較為簡單：

/*int 類型支持*/
static bool Json2Object(int& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isInt()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asInt();
        return true;
    }
}

static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, const int& value)
{
    jsonTypeValue[key] = value;
    return true;
}

/*std::string 字符串類型支持*/
static bool Json2Object(std::string& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isString()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asString();
        return true;
    }
}

static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, const std::string& value)
{
    jsonTypeValue[key] = value;
    return true;
}

自定義數(shù)據(jù)結(jié)構(gòu)類型

對于自定義的結(jié)構(gòu)體類型，我們要做的就是要保證其成員變量能夠與JSON節(jié)點一一對應(yīng)，并能夠匹配進行數(shù)據(jù)填充。

   /*Json字符串：
   {
   "boolValue" : true,
   "intValue" : 1234,
   "strValue" : "demo object!"
   }*/

   struct DemoObjct
    {
        bool boolValue;
        int intValue;
        std::string strValue;
    };

如上面示例，在相互轉(zhuǎn)換過程中，"boolValue"能與DemoObjct對象中名為boolValue的成員變量對應(yīng)，"strValue"與DemoObjct對象中名為strValue的成員變量對應(yīng)。

正常情況下，對于這種場景，我們只能對DemoObjct結(jié)構(gòu)體額外實現(xiàn)處理函數(shù)進行數(shù)據(jù)轉(zhuǎn)換，因不同的結(jié)構(gòu)體聲明定義的成員變量都不一樣，所以針對每個結(jié)構(gòu)體均需要單獨實現(xiàn)，工作繁瑣，不通用。

從這里下手，我們要做的就是“隱藏”針對類結(jié)構(gòu)體實現(xiàn)的轉(zhuǎn)換函數(shù)，利用語言自身的特性（函數(shù)模板等）讓他們幫我們?nèi)プ鲞@些事情。

聲明轉(zhuǎn)換成員函數(shù)，在這個成員函數(shù)實現(xiàn)里，讓每個成員變量能從JSON原生數(shù)據(jù)中讀取或?qū)懭胫怠?/li>
注冊成員變量，目的是讓轉(zhuǎn)換成員函數(shù)知道需要處理哪些成員變量，每個成員變量又對應(yīng)JSON原生數(shù)據(jù)中的哪個節(jié)點字段，以便匹配讀寫。
在外部調(diào)用Json2Object 和Object2Json函數(shù)時，觸發(fā)調(diào)用該轉(zhuǎn)換成員函數(shù)，以便填充或輸出成員變量的內(nèi)容。

把大象裝進冰箱里只需要三步，我們來看這三步怎么走。

成員變量處理

考慮到每個結(jié)構(gòu)體的成員變量類型和數(shù)量不可控，并且需要將每個成員變量作為左值（Json2Object時），不能簡單采用數(shù)組枚舉方式處理，可以采用C++11的特性——可變參數(shù)模板，從里到外遍歷處理每個成員變量

template 
static bool JsonParse(const std::vector& names, int index, const Json::Value& jsonTypeValue, T& arg)
{
    const auto key = names[index];
    if (!jsonTypeValue.isMember(key) || Json2Object(arg, jsonTypeValue[key])) {
        return true;
    } else {
        return false;
    }
}

template 
static bool JsonParse(const std::vector& names, int index, const Json::Value& jsonTypeValue, T& arg, Args&... args)
{
    if (!JsonParse(names, index, jsonTypeValue, arg)) {
        return false;
    } else {
        return JsonParse(names, index + 1, jsonTypeValue, args...);
    }
}

成員變量與JSON原生節(jié)點key字段有對應(yīng)關(guān)系，初步先簡單考慮，將成員變量名稱先視為JSON中對應(yīng)節(jié)點的key名稱。這個可以通過宏定義的特性實現(xiàn)，將聲明注冊的成員變量內(nèi)容作為字符串拆分出key名稱列表。

#define JSONCONVERT2OBJECT_MEMEBER_REGISTER(...)  \
bool ParseHelpImpl(const Json::Value& jsonTypeValue)
{
    std::vector names = Member2KeyParseWithStr(#__VA_ARGS__);
    return JsonParse(names, 0, jsonTypeValue, __VA_ARGS__);
}

成員變量注冊

例如DemoObjct這個類結(jié)構(gòu)體，添加JSONCONVERT2OBJECT_MEMEBER_REGISTER并帶上成員變量的注冊聲明：

   struct DemoObjct
    {
        bool boolValue;
        int intValue;
        std::string strValue;
       
       JSONCONVERT2OBJECT_MEMEBER_REGISTER(boolValue, intValue, strValue)
           
    };

等同于：

   struct DemoObjct
    {
        bool boolValue;
        int intValue;
        std::string strValue;
       
       bool ParseHelpImpl(const Json::Value& jsonTypeValue, 
                          std::vector &names)
        {
            names = Member2KeyParseWithStr("boolValue, intValue, strValue");
            //names 得到 ["boolValue","intValue", "strValue"]
            //然后帶著這些key逐一從Json中取值賦值到成員變量中
            return JsonParse(names, 0, jsonTypeValue, boolValue, intValue, strValue);
        }      
    };

模板匹配防止編譯報錯

到目前為止，核心的功能已經(jīng)實現(xiàn)。如果目標結(jié)構(gòu)體類未添加JSON轉(zhuǎn)換的聲明注冊，外部在使用Json2Object接口時會導(dǎo)致編譯報錯，提示找不到ParseHelpImpl這個成員函數(shù)的聲明定義……，我們可以采用enable_if來給未聲明注冊宏的結(jié)構(gòu)體提供缺省函數(shù)。

template ::has, int>::type = 0>
static inline bool Json2Object(TClass& aimObj, const Json::Value& jsonTypeValue)
{
    std::vector names = PreGetCustomMemberNameIfExists(aimObj);
    return aimObj.JSONCONVERT2OBJECT_MEMEBER_REGISTER_RESERVERD_IMPLE(jsonTypeValue, names);
}

template ::has, int>::type = 0>
static inline bool Json2Object(TClass& aimObj, const Json::Value& jsonTypeValue)
{
    return false;
}

成員變量匹配Key重命名

目前的實現(xiàn)均為將成員變量的名稱作為JSON串中的Key名稱，為靈活處理，再補充一個宏用于重新聲明結(jié)構(gòu)體成員變量中對應(yīng)到JSON串中的key，例如：

    struct DemoObjct
    {
        bool boolValue;
        int intValue;
        std::string strValue;

        JSONCONVERT2OBJECT_MEMEBER_REGISTER(boolValue, intValue, strValue)
        /*重新聲明成員變量對應(yīng)到JSON串的key，注意順序一致*/
        JSONCONVERT2OBJECT_MEMEBER_RENAME_REGISTER("bValue", "iValue", "sValue")
    };

    DemoObjct demoObj;
    /*boolValue <--> bValue; intValue <--> iValue; ...*/
    REQUIRE(Json2Object(demoObj, std::string("{\"bValue\":true, \"iValue\":1234, \"sValue\":\"demo object!\"}")));
    REQUIRE(demoObj.boolValue == true);
    REQUIRE(demoObj.intValue == 1234);
    REQUIRE(demoObj.strValue == "demo object!");

Object2Json實現(xiàn)

上面提到為大多為實現(xiàn)Json2Object接口所提供的操作，從結(jié)構(gòu)體對象轉(zhuǎn)成Json也是類似的操作，這里就不再闡述，詳細可參考源碼。

亮點

簡化C++對JSON數(shù)據(jù)的處理，屏蔽注意拆分處理JSON數(shù)據(jù)的操作；
提供簡易接口，從結(jié)構(gòu)體到JSON串、JSON串轉(zhuǎn)結(jié)構(gòu)體切換自如

源碼



#include "json/json.h"
#include 
#include 
#include 

#define JSONCONVERT2OBJECT_MEMEBER_REGISTER(...)  \
bool JSONCONVERT2OBJECT_MEMEBER_REGISTER_RESERVERD_IMPLE(const Json::Value& jsonTypeValue, std::vector &names) \
{     \
    if(names.size() <= 0)  { \
        names = Member2KeyParseWithStr(#__VA_ARGS__); \
    }   \
    return JsonParse(names, 0, jsonTypeValue, __VA_ARGS__); \
}   \
bool OBJECTCONVERT2JSON_MEMEBER_REGISTER_RESERVERD_IMPLE(Json::Value& jsonTypeValue, std::vector &names) const \
{     \
    if(names.size() <= 0)  { \
        names = Member2KeyParseWithStr(#__VA_ARGS__); \
    }   \
    return ParseJson(names, 0, jsonTypeValue, __VA_ARGS__); \
}   \


#define JSONCONVERT2OBJECT_MEMEBER_RENAME_REGISTER(...)  \
std::vector JSONCONVERT2OBJECT_MEMEBER_RENAME_REGISTER_RESERVERD_IMPLE() const \
{     \
    return Member2KeyParseWithMultiParam({ __VA_ARGS__ }); \
}

namespace JSON
{
template 
struct enable_if
{
};

template 
struct enable_if
{
    typedef TYPE type;
};
} //JSON

template 
struct HasConverFunction
{
    template 
    static char func(decltype(&TT::JSONCONVERT2OBJECT_MEMEBER_REGISTER_RESERVERD_IMPLE)); //@1
    
    template 
    static int func(...); //@2

    const static bool has = (sizeof(func(NULL)) == sizeof(char));

    template 
    static char func2(decltype(&TT::JSONCONVERT2OBJECT_MEMEBER_RENAME_REGISTER_RESERVERD_IMPLE)); //@1
    template 
    static int func2(...); //@2
    const static bool has2 = (sizeof(func2(NULL)) == sizeof(char));
};

static std::vector Member2KeyParseWithMultiParam(std::initializer_list il)
{
    std::vector result;
    for (auto it = il.begin(); it != il.end(); it++) {
        result.push_back(*it);
    }
    return result;
}

inline static std::string NormalStringTrim(std::string const& str)
{
    static char const* whitespaceChars = "\n\r\t ";
    std::string::size_type start = str.find_first_not_of(whitespaceChars);
    std::string::size_type end = str.find_last_not_of(whitespaceChars);
    return start != std::string::npos ? str.substr(start, 1 + end - start) : std::string();
}

inline static std::vector NormalStringSplit(std::string str, char splitElem)
{
    std::vector strs;
    std::string::size_type pos1, pos2;
    pos2 = str.find(splitElem);
    pos1 = 0;
    while (std::string::npos != pos2) {
        strs.push_back(str.substr(pos1, pos2 - pos1));
        pos1 = pos2 + 1;
        pos2 = str.find(splitElem, pos1);
    }
    strs.push_back(str.substr(pos1));
    return strs;
}

static std::vector Member2KeyParseWithStr(const std::string& values)
{
    std::vector result;
    auto enumValues = NormalStringSplit(values, ',');
    result.reserve(enumValues.size());
    for (auto const& enumValue : enumValues) {
        result.push_back(NormalStringTrim(enumValue));
    }
    return result;
}

//////////////////////////////////////////////////////////////////////////////

static bool Json2Object(bool& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isBool()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asBool();
        return true;
    }
}
static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, bool value)
{
    jsonTypeValue[key] = value;
    return true;
}

static bool Json2Object(int& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isInt()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asInt();
        return true;
    }
}
static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, const int& value)
{
    jsonTypeValue[key] = value;
    return true;
}

static bool Json2Object(unsigned int& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isUInt()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asUInt();
        return true;
    }
}
static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, const unsigned int& value)
{
    jsonTypeValue[key] = value;
    return true;
}

static bool Json2Object(double& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isDouble()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asDouble();
        return true;
    }
}
static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, const double& value)
{
    jsonTypeValue[key] = value;
    return true;
}

static bool Json2Object(std::string& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isString()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asString();
        return true;
    }
}
static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, const std::string& value)
{
    jsonTypeValue[key] = value;
    return true;
}

template ::has2, int>::type = 0>
static inline std::vector PreGetCustomMemberNameIfExists(const TClass& aimObj)
{
    return aimObj.JSONCONVERT2OBJECT_MEMEBER_RENAME_REGISTER_RESERVERD_IMPLE();
}

template ::has2, int>::type = 0>
static inline std::vector PreGetCustomMemberNameIfExists(const TClass& aimObj)
{
    return std::vector();
}

template ::has, int>::type = 0>
static inline bool Json2Object(TClass& aimObj, const Json::Value& jsonTypeValue)
{
    std::vector names = PreGetCustomMemberNameIfExists(aimObj);
    return aimObj.JSONCONVERT2OBJECT_MEMEBER_REGISTER_RESERVERD_IMPLE(jsonTypeValue, names);
}

template ::has, int>::type = 0>
static inline bool Json2Object(TClass& aimObj, const Json::Value& jsonTypeValue)
{
    return false;
}

template 
static bool Json2Object(std::vector& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isArray()) {
        return false;
    } else {
        aimObj.clear();
        bool result(true);
        for (int i = 0; i < jsonTypeValue.size(); ++i) {
            T item;
            if (!Json2Object(item, jsonTypeValue[i])) {
                result = false;
            }
            aimObj.push_back(item);
        }
        return result;
    }
}

template 
static bool JsonParse(const std::vector& names, int index, const Json::Value& jsonTypeValue, T& arg)
{
    const auto key = names[index];
    if (!jsonTypeValue.isMember(key) || Json2Object(arg, jsonTypeValue[key])) {
        return true;
    } else {
        return false;
    }
}

template 
static bool JsonParse(const std::vector& names, int index, const Json::Value& jsonTypeValue, T& arg, Args&... args)
{
    if (!JsonParse(names, index, jsonTypeValue, arg)) {
        return false;
    } else {
        return JsonParse(names, index + 1, jsonTypeValue, args...);
    }
}

/** Provider interface*/
template
bool Json2Object(TClass& aimObj, const std::string& jsonTypeStr)
{
    Json::Reader reader;
    Json::Value root;

    if (!reader.parse(jsonTypeStr, root) || root.isNull()) {
        return false;
    }
    return Json2Object(aimObj, root);
}

static bool GetJsonRootObject(Json::Value& root, const std::string& jsonTypeStr)
{
    Json::Reader reader;
    if (!reader.parse(jsonTypeStr, root)) {
        return false;
    }
    return true;
}

////////////////////////////////////////////////////////////////////////

template ::has, int>::type = 0>
static inline bool Object2Json(Json::Value& jsonTypeOutValue, const std::string& key, const TClass& objValue)
{
    std::vector names = PreGetCustomMemberNameIfExists(objValue);
    if (key.empty()) {
        return objValue.OBJECTCONVERT2JSON_MEMEBER_REGISTER_RESERVERD_IMPLE(jsonTypeOutValue, names);
    } else {
        Json::Value jsonTypeNewValue;
        const bool result = objValue.OBJECTCONVERT2JSON_MEMEBER_REGISTER_RESERVERD_IMPLE(jsonTypeNewValue, names);
        if (result) {
            jsonTypeOutValue[key] = jsonTypeNewValue;
        }
        return result;
    }
}

template ::has, int>::type = 0>
static inline bool Object2Json(Json::Value& jsonTypeOutValue, const std::string& key, const TClass& objValue)
{
    return false;
}

template 
static bool Object2Json(Json::Value& jsonTypeOutValue, const std::string& key, const std::vector& objValue)
{
    bool result(true);
    for (int i = 0; i < objValue.size(); ++i) {
        Json::Value item;
        if (!Object2Json(item, "", objValue[i])) {
            result = false;
        } else {
            if (key.empty()) jsonTypeOutValue.append(item);
            else jsonTypeOutValue[key].append(item);
        }
     }
    return result;
}

template 
static bool ParseJson(const std::vector& names, int index, Json::Value& jsonTypeValue, const T& arg)
{
    if (names.size() > index) {
        const std::string key = names[index];
        return Object2Json(jsonTypeValue, key, arg);
    } else {
        return false;
    }
}

template 
static bool ParseJson(const std::vector& names, int index, Json::Value& jsonTypeValue, T& arg, Args&... args)
{
    if (names.size() - (index + 0) != 1 + sizeof...(Args)) {
        return false;
    }
    const std::string key = names[index];
    Object2Json(jsonTypeValue, key, arg);

    return ParseJson(names, index + 1, jsonTypeValue, args...);
}

/** Provider interface*/
template
bool Object2Json(std::string& jsonTypeStr, const T& obj)
{
    //std::functionplacehoder = [&]()->Json::Value { return Json::Value(); };
    //auto func = [&](std::functionf) { return f(); };
    //Json::Value val = func(placehoder);

    Json::StyledWriter writer;
    Json::Value root;
    const bool result = Object2Json(root, "", obj);
    if (result) {
        jsonTypeStr = writer.write(root);
    }
    return result;
}

參考文檔

C++類結(jié)構(gòu)體與json相互轉(zhuǎn)換
C++ 輕量級對象JSON序列化實現(xiàn)

名稱欄目：C++實現(xiàn)對Json數(shù)據(jù)的友好處理
網(wǎng)頁地址：http://weahome.cn/article/dsogosj.html

真实的国产乱ⅩXXX66竹夫人,五月香六月婷婷激情综合,亚洲日本VA一区二区三区,亚洲精品一区二区三区麻豆

C++實現(xiàn)對Json數(shù)據(jù)的友好處理

背景

設(shè)計

目標：

效果：

實現(xiàn)

基本數(shù)據(jù)類型轉(zhuǎn)換

自定義數(shù)據(jù)結(jié)構(gòu)類型

成員變量處理

成員變量注冊

模板匹配防止編譯報錯

成員變量匹配Key重命名

Object2Json實現(xiàn)

亮點

源碼

參考文檔

其他資訊

網(wǎng)站制作

企業(yè)服務(wù)

網(wǎng)站建設(shè)

服務(wù)器托管