C++中rapidjson组装map和数组array的代码示例
rapidjson组装map和数组array的代码示例
直接上码：
#include <iostream>
#include <map>
// 请自己下载开源的rapidjson
#include "rapidjson/prettywriter.h"
#include "rapidjson/rapidjson.h"
#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/writer.h"
#include "rapidjson/memorystream.h"
#include <sys/types.h>
#include <vector>
using namespace std;
using rapidjson::Document;
using rapidjson::StringBuffer;
using rapidjson::Writer;
using namespace rapidjson;
// 注意int和uint64_t
map<string, uint64_t> g_mChildInt;
map<string, string> g_mChildString;
string formJson(const map<string, int> &mInt, const map<string, string> &mString,
const string &strChild="", const map<string, uint64_t> &mChildInt=g_mChildInt, const map<string, string> &mChildString=g_mChildString,
const string &strChild2="", const map<string, uint64_t> &mChildInt2=g_mChildInt, const map<string, string> &mChildString2=g_mChildString)
{
Document document;
Document::AllocatorType& allocator = document.GetAllocator();
Value root(kObjectType);
Value key(kStringType);
Value value(kStringType);
// 当前级别
for(map<string, int>::const_iterator it = mInt.begin(); it != mInt.end(); ++it)
{
key.SetString(it->first.c_str(), allocator);
root.AddMember(key, it->second, allocator);
}
for(map<string, string>::const_iterator it = mString.begin(); it != mString.end(); ++it)
{
key.SetString(it->first.c_str(), allocator);
value.SetString(it->second.c_str(), allocator);
root.AddMember(key, value, allocator);
}
// 孩子级别
if(!strChild.empty())
{
Value child(kObjectType);
for(map<string, uint64_t>::const_iterator it = mChildInt.begin(); it != mChildInt.end(); ++it)
{
key.SetString(it->first.c_str(), allocator);
child.AddMember(key, it->second, allocator);
}
for(map<string, string>::const_iterator it = mChildString.begin(); it != mChildString.end(); ++it)
{
key.SetString(it->first.c_str(), allocator);
value.SetString(it->second.c_str(), allocator);
child.AddMember(key, value, allocator);
}
key.SetString(strChild.c_str(), allocator);
root.AddMember(key, child, allocator);
}
// 孩子级别
if(!strChild2.empty())
{
Value child(kObjectType);
for(map<string, uint64_t>::const_iterator it = mChildInt2.begin(); it != mChildInt2.end(); ++it)
{
key.SetString(it->first.c_str(), allocator);
child.AddMember(key, it->second, allocator);
}
for(map<string, string>::const_iterator it = mChildString2.begin(); it != mChildString2.end(); ++it)
{
key.SetString(it->first.c_str(), allocator);
value.SetString(it->second.c_str(), allocator);
child.AddMember(key, value, allocator);
}
key.SetString(strChild2.c_str(), allocator);
root.AddMember(key, child, allocator);
}
StringBuffer buffer;
Writer<StringBuffer> writer(buffer);
root.Accept(writer);
return buffer.GetString();
}
string formJsonWithArray(const map<string, int> &mInt, const map<string, string> &mString,
const string &strChild1, const map<string, uint64_t> &mChildInt, const map<string, string> &mChildString,
string &strChild2, vector<map<string, uint64_t> >&mVecChildInt, vector<map<string, string> >&mVecChildString)
{
Document document;
Document::AllocatorType& allocator = document.GetAllocator();
Value root(kObjectType);
Value key(kStringType);
Value value(kStringType);
// 当前级别
for(map<string, int>::const_iterator it = mInt.begin(); it != mInt.end(); ++it)
{
key.SetString(it->first.c_str(), allocator);
root.AddMember(key, it->second, allocator);
}
for(map<string, string>::const_iterator it = mString.begin(); it != mString.end(); ++it)
{
key.SetString(it->first.c_str(), allocator);
value.SetString(it->second.c_str(), allocator);
root.AddMember(key, value, allocator);
}
// 孩子级别
if(!strChild1.empty())
{
Value child(kObjectType);
for(map<string, uint64_t>::const_iterator it = mChildInt.begin(); it != mChildInt.end(); ++it)
{
key.SetString(it->first.c_str(), allocator);
child.AddMember(key, it->second, allocator);
}
for(map<string, string>::const_iterator it = mChildString.begin(); it != mChildString.end(); ++it)
{
key.SetString(it->first.c_str(), allocator);
value.SetString(it->second.c_str(), allocator);
child.AddMember(key, value, allocator);
}
key.SetString(strChild1.c_str(), allocator);
root.AddMember(key, child, allocator);
}
// 孩子级别
unsigned int uiSize1 = mVecChildInt.size();
unsigned int uiSize2 = mVecChildString.size();
if(!strChild2.empty() && uiSize1 == uiSize2)
{
Value array(rapidjson::kArrayType);
for(unsigned int i = 0; i < uiSize1; ++i)
{
Value child(kObjectType);
for(map<string, uint64_t>::iterator it = mVecChildInt[i].begin(); it != mVecChildInt[i].end(); ++it)
{
key.SetString(it->first.c_str(), allocator);
child.AddMember(key, it->second, allocator);
}
for(map<string, string>::iterator it = mVecChildString[i].begin(); it != mVecChildString[i].end(); ++it)
{
key.SetString(it->first.c_str(), allocator);
value.SetString(it->second.c_str(), allocator);
child.AddMember(key, value, allocator);
}
array.PushBack(child, allocator);
}
key.SetString(strChild2.c_str(), allocator);
root.AddMember(key, array, allocator);
}
StringBuffer buffer;
Writer<StringBuffer> writer(buffer);
root.Accept(writer);
return buffer.GetString();
}
void test1()
{
map<string, int> mInt;
map<string, string> mString;
mInt["code"] = 0;
mString["msg"] = "ok";
string strChild1 = "xxx";
map<string, uint64_t> mChildInt1;
map<string, string> mChildString1;
mChildInt1["key"] = 729;
mChildString1["kk"] = "vv";
string strChild2 = "yyy";
map<string, uint64_t> mChildInt2;
map<string, string> mChildString2;
mChildInt2["key"] = 730;
mChildString2["kkk"] = "vvv";
string s = formJson(mInt, mString, strChild1, mChildInt1, mChildString1,strChild2, mChildInt2, mChildString2);
cout << s << endl;
}
void test2()
{
map<string, int> mInt;
map<string, string> mString;
mInt["code"] = 0;
mString["msg"] = "ok";
string strChild1 = "xxx";
map<string, uint64_t> mChildInt;
map<string, string> mChildString;
mChildString["kk"] = "vv";
mChildInt["key"] = 729;
string strChild2 = "data";
vector<map<string, uint64_t> >mVecChildInt;
vector<map<string, string> >mVecChildString;
{
map<string, uint64_t> mChildInt;
map<string, string> mChildString;
mChildInt["id"] = 1;
mChildString["path"] = "pa";
mChildString["sha"] = "sh";
mVecChildInt.push_back(mChildInt);
mVecChildString.push_back(mChildString);
}
{
map<string, uint64_t> mChildInt;
map<string, string> mChildString;
mChildInt["id"] = 2;
mChildString["path"] = "pa";
mChildString["sha"] = "sh";
mVecChildInt.push_back(mChildInt);
mVecChildString.push_back(mChildString);
}
string s = formJsonWithArray(mInt, mString, strChild1, mChildInt, mChildString, strChild2, mVecChildInt, mVecChildString);
cout << s << endl;
}
int main(int argc, char *argv[])
{
test1();
test2();
return 0;
}
结果：
{"code":0,"msg":"ok","xxx":{"key":729,"kk":"vv"},"yyy":{"key":730,"kkk":"vvv"}}
{"code":0,"msg":"ok","xxx":{"key":729,"kk":"vv"},"data":[{"id":1,"path":"pa","sha":"sh"},{"id":2,"path":"pa","sha":"sh"}]}
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对我们的支持。如果你想了解更多相关内容请查看下面相关链接
相关推荐
-
strings命令分析浅谈Go和C++编译时的一点小区别
最近查一个bug, 用strings命令分析, 竟然出乎意料地没有结果, 非常纳闷. 最后根据这个线索查出了bug的根本原因. 1. 在C++中, 即使函数在代码层面没有被调用, 也会最终编译到二进制中, 用strings可以分析. #include <iostream> using namespace std; void fun() { printf("hello world\n"); // strings分析有结果 } int main() { return 0;
-
用C/C++代码检测ip能否ping通(配合awk和system可以做到批量检测)
遇到一个小需求, 快速搞定. 来看看用C/C++代码检测ip能否ping通: #include <iostream> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> using namespace std; string getCmdResult(const string &strCmd) // 这个是获取命令执行的结果, 类似于
-
详解C++中虚析构函数的作用及其原理分析
C++中的虚析构函数到底什么时候有用的,什么作用呢. 一.虚析构函数的作用 总的来说虚析构函数是为了避免内存泄露,而且是当子类中会有指针成员变量时才会使用得到的.也就说虚析构函数使得在删除指向子类对象的基类指针时可以调用子类的析构函数达到释放子类中堆内存的目的,而防止内存泄露的. 我们知道,用C++开发的时候,用来做基类的类的析构函数一般都是虚函数.可是,为什么要这样做呢?下面用一个小例子来说明: #include<iostream> using namespace std; class Cl
-
c++文件监控之FileSystemWatcher
具体代码如下: #using <System.dll> #include <iostream> using namespace std; using namespace System; using namespace System::IO; using namespace System::Security::Permissions; public ref class Watcher { private: // Define the event handlers. static vo
-
C++与namespace有关的两个编译错误的讲解
某次,在大型的工程代码中,我这样调用: #include <iostream> using namespace std; namespace A { void fun() { printf("aaa\n"); } } namespace B { void fun() { printf("bbb\n"); } } int main() { fun(); return 0; } 编译出错:error: 'fun' was not declared in th
-
C++类中变量也可以是引用的代码实例
C++类中变量也可以是引用哈------要用初始化列表来初始化(因为C++引用一旦绑定,就无法更换,有点类似const) #include <iostream> using namespace std; class A { public: int &x; int &y; A(int &tmpX, int &tmpY):x(tmpX), y(tmpY){} }; int main() { int tmpX = 1; int tmpY = 2; A a(tmpX,
-
C++直接cout指针名的含义?
首先看下面这个代码实例: #include <iostream> using namespace std; int main() { char *str = "this is a test"; cout << "str=" << str << endl; cout << "*str=" << *str << endl; cout << "&a
-
C++中rapidjson组装继续简化的方法
rapidjson组装继续简化------人生苦短,我用rapidjson 看最简单的: #include <iostream> #include <stdio.h> #include<unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include<sstream> // 请自己下载开源的rapidjson #includ
-
c++编写String类代码实例
本文实例为大家分享了c++编写String类的具体代码,供大家参考,具体内容如下 class String { public: String(const char* = nullptr); //普通构造函数 String(const String& other); //拷贝构造函数 ~String(void); //析构函数 String& operator = (const String& other); //赋值函数 private: char* m_data; }; //普通
-
C++基类指针和派生类指针之间的转换方法讲解
函数重载.函数隐藏.函数覆盖 函数重载只会发生在同作用域中(或同一个类中),函数名称相同,但参数类型或参数个数不同. 函数重载不能通过函数的返回类型来区分,因为在函数返回之前我们并不知道函数的返回类型. 函数隐藏和函数覆盖只会发生在基类和派生类之间. 函数隐藏是指派生类中函数与基类中的函数同名,但是这个函数在基类中并没有被定义为虚函数,这种情况就是函数的隐藏. 所谓隐藏是指使用常规的调用方法,派生类对象访问这个函数时,会优先访问派生类中的这个函数,基类中的这个函数对派生类对象来说是隐藏起来的.