C++11 json的强制结构化定义与rapidjson的JsonObject对象封装

最新推荐文章于 2024-05-06 19:24:23 发布
最新推荐文章于 2024-05-06 19:24:23 发布
阅读量696 收藏 1
点赞数
分类专栏： VC++ C++ json 文章标签： C++11 JSON c++json jsoncpp rapidjson
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/no_this/article/details/103019844
版权
VC++ 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
C++
1 篇文章 0 订阅
订阅专栏
json
1 篇文章 0 订阅
订阅专栏

rapidjson，是C++里性能最好JSON解析库，在自己笔记本上每秒可解析十万次普通规模JSON，非常适合对性能有要求的服务器开发。

但使用起来有些麻烦。所以我封装了下，更方便使用，增加开发效率。

第一步，封装rapidjson为JsonObject，像使用脚本语言一样get set = ，封装函数getIntValue，getStringValue，getBoolValue，getArrValue及对应的set

下面是Object .h代码

#ifndef OBJECT_H
#define OBJECT_H

#pragma once 
#include <memory>
class Object : public std::enable_shared_from_this<Object>
{
public:
	Object();
	virtual ~Object();

	virtual void setBindObject(std::shared_ptr<Object> pObject) { m_pBindObject = pObject; }
	virtual std::shared_ptr<Object> getBindObject() { return m_pBindObject; }
	std::shared_ptr<Object> m_pBindObject;
};

#endif // !OBJECT_H
#include "Object.h"



Object::Object()
{
}


Object::~Object()
{
}

下面是JsonObject代码 

#ifndef JSONOBJECT_H
#define JSONOBJECT_H

#pragma once


#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/stringbuffer.h"
#include <vector>
#include<memory>
#include "Object.h"
using namespace rapidjson;
using namespace std;
class JsonObject :public Object
{
public:
	JsonObject();
	//JsonObject(shared_ptr<Document> pDoc, Value* pValue);

	virtual bool init(shared_ptr<Document> pDoc, Value* pValue);
	virtual void onInit() {};
	JsonObject& operator=(const JsonObject& cls);
	bool operator==(const JsonObject& cls);

	bool Parse(const char* pStrJson);
	bool isNotNull();

	shared_ptr<JsonObject>	getObject(const char *pName);
	shared_ptr<JsonObject>	setObject(const char* pName,const JsonObject& value);
	JsonObject  makeObject(const char* pName);

	template<class T> shared_ptr<T> getObject(const char* pName)
	{
		Value::MemberIterator member = m_pValue->FindMember(pName);
		if (member == m_pValue->MemberEnd())
		{
			return nullptr;
		}



		//T newObject;
		auto newObject =std::make_shared<T>();
		newObject->init(m_pJsonDoc, &member->value);

		return newObject;
	}

	template<class T> shared_ptr<T>	setObject(const char* pName, const T* pValue)
	{
		if ((this) == pValue) {
			return dynamic_pointer_cast<T>(shared_from_this());
		}
		rapidjson::Value obj(rapidjson::kObjectType);
		obj.CopyFrom(*pValue->m_pValue, m_pJsonDoc->GetAllocator());

		auto& all = m_pJsonDoc->GetAllocator();
		m_pValue->AddMember(StringRef(pName), obj, all);

		return getObject<T>(pName);
	}
	template<class T> shared_ptr<T> makeObject(const char* pName);
	bool		haveValue(const char* pName);
	int			getIntValue(const char* pName);
	const char* getStringValue(const char* pName);

	bool		setIntValue(const char* pName,int value);
	bool		setStrValue(const char* pName, const char* value);


	bool		setLongValue(const char* pName, long long value);
	long long			getLongValue(const char* pName);

	bool		getBoolValue(const char* pName);
	void		setBoolValue(const char* pName,bool value);
	bool		setArrValue(const char* pName, const std::vector<std::string>& arrvalue);
	void		addArrValue(const char* pName,const char *pValue);
	void		addArrObjectValue(const char* pName, const JsonObject *pValue);
	std::vector<std::string> getArrValue(const char* pName);
	virtual std::string		toString();
	virtual std::string		preToString();
	std::shared_ptr<Document> m_pJsonDoc;
	
	Value* m_pValue;

	std::vector<shared_ptr<Value>> m_vectOutValue;

	std::string m_strJson;
};

#endif // !JSONOBJECT_H

 下面是CPP代码

#include "JsonObject.h"

JsonObject::JsonObject()
{
	m_pJsonDoc = nullptr;
	m_pValue = nullptr;

	init(nullptr, nullptr);
}



bool JsonObject::init(shared_ptr<Document> pDoc, Value* pValue)
{
	if (m_pJsonDoc != pDoc) {
		m_pJsonDoc = pDoc;
	}
	if (m_pValue != pValue) {
		m_pValue = pValue;
	}
	
	if (m_pJsonDoc == nullptr) {
		auto pDoc = std::make_shared<Document>();
		pDoc->SetObject();
		m_pJsonDoc = pDoc;
		m_pValue = pDoc.get();
		
	}
	this->onInit();
	return true;
}

JsonObject& JsonObject::operator=(const JsonObject& cls)
{
	if (this != &cls)
	{
		this->m_pJsonDoc = cls.m_pJsonDoc;
		this->m_pValue = cls.m_pValue;
	}

	return *this;
}

bool JsonObject::operator==(const JsonObject& cls)
{
	if (this == &cls) {
		return true;
	}

	if (this->m_pJsonDoc == cls.m_pJsonDoc && this->m_pValue == cls.m_pValue) {
		return true;
	}

	return false;
}

bool JsonObject::Parse(const char* pStrJson)
{
	if (m_pJsonDoc) {
		//return false;
	}
	
	auto pDoc = m_pJsonDoc;
	pDoc->Parse(pStrJson);

	//auto pValue = pDoc.get();
	//this->init(pDoc,pValue);
	return true;
}

bool JsonObject::isNotNull()
{
	if (m_pJsonDoc && m_pValue) {
		return true;
	}

	return false;
}

shared_ptr<JsonObject> JsonObject::getObject(const char* pName)
{

	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		return nullptr;
	}

	
	//shared_ptr<Value> pValue2(&member->value);
	//m_vectOutValue.push_back(pValue2);

	auto obj = std::make_shared<JsonObject>();
	obj->init(m_pJsonDoc, &member->value);
	return obj;
}

shared_ptr<JsonObject>	JsonObject::setObject(const char* pName, const JsonObject& value)
{
	if ((*this) == value) {
		return dynamic_pointer_cast<JsonObject>(shared_from_this());
	}
	rapidjson::Value obj(rapidjson::kObjectType);
	if (value.m_pJsonDoc != nullptr && value.m_pValue != nullptr) {
		obj.CopyFrom(*value.m_pValue, m_pJsonDoc->GetAllocator());
	}
	

	auto& all = m_pJsonDoc->GetAllocator();
	m_pValue->AddMember(StringRef(pName), obj, all);

	return getObject(pName);
}




template<class T> shared_ptr<T> JsonObject::makeObject(const char* pName)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		auto& all = m_pJsonDoc->GetAllocator();

		rapidjson::Value obj(rapidjson::kObjectType);

		m_pValue->AddMember(StringRef(pName), obj, all);

	}

	member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd()) {
		assert(false);
		std::string str = "JsonObject::makeObject Failed Key:";
		str += pName;
		throw std::invalid_argument(str);
	}

	shared_ptr<Value> pValue2(&member->value);
	m_vectOutValue.push_back(pValue2);

	T newObject;
	newObject.init(m_pJsonDoc, pValue2);

	rapidjson::Value obj;
	return newObject;
}

JsonObject  JsonObject::makeObject(const char* pName)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		auto& all = m_pJsonDoc->GetAllocator();

		rapidjson::Value obj(rapidjson::kObjectType);
		
		m_pValue->AddMember(StringRef(pName), obj, all);
	}

	member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd()) {
		assert(false);
		std::string str = "JsonObject::makeObject Failed Key:";
		str += pName;
		throw std::invalid_argument(str);
	}

	//shared_ptr<Value> pValue2(&member->value);
	//m_vectOutValue.push_back(pValue2);

	JsonObject obj;
	obj.init(m_pJsonDoc, &member->value);
	return obj;
}

bool		JsonObject::haveValue(const char* pName)
{
	
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		return false;
	}


	return false;
}

int	JsonObject::getIntValue(const char* pName)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		//assert(false);

		return 0;
	}

	Value& obj = member->value;
	
	return obj.GetInt();
}

const char* JsonObject::getStringValue(const char* pName)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		return nullptr;
	}

	Value& obj = member->value;
	return obj.GetString();
}

bool		JsonObject::setIntValue(const char* pName, int value)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		auto& all = m_pJsonDoc->GetAllocator();
		m_pValue->AddMember(StringRef(pName), rapidjson::Value(value), all);
	}
	else {
		member->value.SetInt(value);
	}

	return true;
}

bool		JsonObject::setLongValue(const char* pName, long long value)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		auto& all = m_pJsonDoc->GetAllocator();
		m_pValue->AddMember(StringRef(pName), rapidjson::Value(value), all);
	}
	else {
		member->value.SetInt64(value);
	}

	return true;
}

long long			JsonObject::getLongValue(const char* pName)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		assert(false);
	}

	Value& obj = member->value;
	return obj.GetInt64();
}

bool		JsonObject::getBoolValue(const char* pName)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		//assert(false);
	}

	Value& obj = member->value;
	return obj.GetBool();
}

void		JsonObject::setBoolValue(const char* pName, bool value)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		auto& all = m_pJsonDoc->GetAllocator();
		m_pValue->AddMember(StringRef(pName), rapidjson::Value(value), all);
	}
	else {
		member->value.SetBool(value);
	}

}

bool		JsonObject::setArrValue(const char* pName, const std::vector<std::string>& arrvalue)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		auto& all = m_pJsonDoc->GetAllocator();
		rapidjson::Value obj(rapidjson::kArrayType);
		m_pValue->AddMember(StringRef(pName), obj, all);

		auto iter = arrvalue.begin();
		for (; iter != arrvalue.end(); iter++) {
			obj.PushBack(StringRef(iter->c_str()), all);
		}
	}
	else {
		member->value.SetArray();
		auto& all = m_pJsonDoc->GetAllocator();
		auto iter = arrvalue.begin();
		for (; iter != arrvalue.end(); iter++) {
			member->value.PushBack(StringRef(iter->c_str()), all);
		}
	}

	return true;
}

void		JsonObject::addArrValue(const char* pName, const char *pValue)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		auto& all = m_pJsonDoc->GetAllocator();
		rapidjson::Value obj(rapidjson::kArrayType);
		m_pValue->AddMember(StringRef(pName), obj, all);
		obj.PushBack(StringRef(pValue), all);
	}
	else {
		auto &value = member->value;
		auto& all = m_pJsonDoc->GetAllocator();
		if (value.IsArray()) {
			value.PushBack(StringRef(pValue), all);
		}
	}
}

void		JsonObject::addArrObjectValue(const char* pName, const JsonObject *pValue)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		auto& all = m_pJsonDoc->GetAllocator();
		rapidjson::Value obj(rapidjson::kArrayType);
		rapidjson::Value iterValue(rapidjson::kObjectType);
		iterValue.CopyFrom((*pValue->m_pValue), all);
		obj.PushBack(iterValue, all);

		
		m_pValue->AddMember(StringRef(pName), obj, all);
	}
	else {
		auto &value = member->value;
		auto& all = m_pJsonDoc->GetAllocator();
		if (value.IsArray()) {
			rapidjson::Value iterValue(rapidjson::kObjectType);
			iterValue.CopyFrom((*pValue->m_pValue), all);
			value.PushBack(iterValue, all);
		}
	}
}

std::vector<std::string> JsonObject::getArrValue(const char* pName)
{
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		
	}
	else {
		auto &value = member->value;
		auto& all = m_pJsonDoc->GetAllocator();
		if (value.IsArray()) {

			std::vector<std::string> arrValue;
			auto iter =  value.Begin();
			for (; iter != value.End(); iter++) {
				arrValue.push_back(iter->GetString());
			}

			return arrValue;
		}
	}

	return std::vector<std::string>();
}

bool		JsonObject::setStrValue(const char* pName, const char* value)
{
	if (!value) {
		return false;
	}
	Value::MemberIterator member = m_pValue->FindMember(pName);
	if (member == m_pValue->MemberEnd())
	{
		auto& all = m_pJsonDoc->GetAllocator();

		rapidjson::Value setvalue(rapidjson::kStringType);
		setvalue.SetString(value, all);
		m_pValue->AddMember(StringRef(pName), setvalue, all);
	}
	else {
		auto& all = m_pJsonDoc->GetAllocator();
		member->value.SetString(StringRef(value), all);
	}

	return true;
}

std::string		JsonObject::toString()
{
	if (m_strJson.size()) {
		return m_strJson;
	}
	StringBuffer buffer;
	Writer<StringBuffer> writer(buffer);
	m_pValue->Accept(writer);

	return buffer.GetString();
}

std::string		JsonObject::preToString()
{
	StringBuffer buffer;
	Writer<StringBuffer> writer(buffer);
	m_pValue->Accept(writer);

	m_strJson =  buffer.GetString();

	return m_strJson;
}

第二部、强制结构定义实现，主要用C++11宏方式，下面是使用方式。

class NetPack_sendmsg : public JsonObjectDef
{
public:
	JSON_STR(sessiontype);
	JSON_STR(fromuserid);
	JSON_STR(touserid);
	JSON_STR(msgtype);
	JSON_STR(msgdata);
	JSON_BOOL(boffline);
};

NetPack_sendmsg *pMsg = new NetPack_sendmsg;
pMsg->get_sessiontypeWithStr();
pMsg->set_sessiontypeWithStr("");
pMsg->get_bofflineWithBool();
pMsg->set_bofflineWithBool(true);

下面是源码文件：

#include "JsonObject.h"

#define JSON_GETSTR(name) const char* get_##name##WithStr(){return this->getStringValue(#name);}
#define JSON_GETINT(name) int get_##name##WithInt(){return this->getIntValue(#name);}

#define JSON_SETSTR(name) void set_##name##WithStr(const char *pValue){this->setStrValue(#name,pValue);}
#define JSON_SETINT(name) void set_##name##WithInt(int value){this->setIntValue(#name,value);}
#define JSON_SETCLASS(name,classname) classname set_##name##WithObject(const classname& invalue){this->setObject<classname>(#name,invalue);}
#define JSON_GETCLASS(name,classname) classname get_##name##WithObject(){return this->getObject<classname>(#name);}

#define JSON_MAKEOBJECT(name,classname) classname make_##name##WithObject(){return this->makeObject<classname>(#name);}


#define JSON_GETLONG(name) long long get_##name##WithLong(){return this->getLongValue(#name);}
#define JSON_SETLONG(name) void set_##name##WithLong(long long value){this->setLongValue(#name,value);}

#define JSON_GETBOOL(name) bool get_##name##WithBool(){return this->getBoolValue(#name);}
#define JSON_SETBOOL(name) void set_##name##WithBool(bool value){this->setBoolValue(#name,value);}

#define JSON_GETARR(name) std::vector<std::string> get_##name##WithArr(){return this->getArrValue(#name);}
#define JSON_SETARR(name) void set_##name##WithArr(const std::vector<std::string>& arrvalue){this->setArrValue(#name,arrvalue);}
#define JSON_ARRADDVALUE(name) void add_##name##ArrValue(const char *pValue){this->addArrValue(#name,pValue);}


#define JSON_ARRADDOBJVALUE(name) void add_##name##ArrObjValue(const JsonObject *pValue){this->addArrObjectValue(#name,pValue);}

#define JSON_INT(name) JSON_GETINT(name) JSON_SETINT(name);

#define JSON_LONG(name) JSON_GETLONG(name) JSON_SETLONG(name);
#define JSON_STR(name) JSON_GETSTR(name) JSON_SETSTR(name);

#define JSON_ARR(name) JSON_GETARR(name) JSON_SETARR(name) JSON_ARRADDVALUE(name)

#define JSON_BOOL(name) JSON_GETBOOL(name) JSON_SETBOOL(name);

#define JSON_CMD(name) virtual std::string getCmdStr() { return MsgType::##name##; }
class JsonObjectDef :
	public JsonObject
{
public:
	virtual std::string getCmdStr() { return MsgType::nulldef; }
};

 

no_this
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ rapidjson 对类序列化(完美二次封装)下载
02-22
本工程源码，基于rapidjson实现二次封装，使C++序列化一个类的变得代码非常小，耦合性非常低，且不损失原有序列化性能。详细使用可关联本人博客:http://blog.csdn.net/lightspear/article/details/54836656
【C++】rapidjson: 读取复杂的json串
梦想博客
09-03 2931
Rapidjson简介：C++11模板库方式实现的json解析库 Rapidjson文档：http://rapidjson.org/zh-cn/index.html 以如下json为例，使用rapidjson解析 { "data": { "security_token": "CAIS+QJ1q6Ft5B2yfSj...Hvo2LHm", "access_key_id": "STS.NTAgDURZo3op8zMRrfYvPG6yF", "access_key_secr.
C++使用json11开源库快速生成JSON格式的数据
最新发布
晓琴儿
05-06 452
在程序开发中，JSON格式的接口数据应用很广泛，C++生态中有许多高效的JSON库，如nlohmann/json、RapidJSON、jsoncpp等，这些库提供了便捷的API来实现JSON数据的解析、生成、序列化和反序列化，简化了C++程序对JSON数据的操作，本文记录一个轻量级的开源库json11来生成JSON格式的数据。json11是C++11的一个小型JSON库，提供JSON解析和序列化。在使用过程中只需要引用json11.hpp和json11.cpp两个文件即可使用json11的接口。
C++ 封装RapidJson把一个类Json序列化和反序列化
lightspear的专栏
02-02 1万+
很多人都知道rapidjson这个json库，大家也都知道他的高效，可是你一定也对他的使用方法，函数API接口感受到非常不适应，你一定非常怀念使用java和C#对一个实体类的那么轻松加简单的直接json序列化，是的本篇博客将免费开源一个我自己平时做项目研发使用的一个RapidJsonHelper类，将帮你实现对一个C++实体类的的序列化和反序列化。 先贴上可完美可运行测试源码（含rapidjso
C++对象Json序列化最佳实践（基于Rapidjson库）：C++内存对象和Json字符串互相转换
热门推荐
C++ 爱好者 make_it_simple888
04-17 2万+
介绍：RapidjsonRapidjson库是C++对象序列化到Json字符串的非常好的工具，以效率著称，腾讯的人写的。官方网站：点击打开链接本文全部资源百度云这个库的缺点（个人拙见）：1 暴露的细节相对较多：容器，迭代器，类型，成员函数，序列化，反序列化，都有非常细致的操作。这个给使用者带来记忆负担较重。至少需要同时暴露Value类型和Document类型才能完整的实现Object内部包含Obj...
03rapidJson学习之对象的创建、遍历
weixin_44517656的博客
12-11 2383
03rapidJson学习之对象的创建、遍历 概述： 这里强调一点，对象是可以作为返回值返回的，因为对象是一个整体。而数组是不能返回的,因为数组必须依赖一个对象才能返回。数组一般依赖doc作引用参数时，伴随根对象返回。 1 对象的创建 //从doc中获取string字符串内容 std::string GetStrWithDoc(Document &doc) { rapidjson::StringBuffer buffer;//画板 rapidjson::Writer<StringBuff
QT纯C++实现JSON的封装、解析、修改、删除！
04-08
要实现JSON的封装，我们需要创建一个QJsonObject或QJsonArray，然后通过添加键值对或者元素来构建JSON结构。例如： ```cpp QJsonObject jsonObject; jsonObject.insert("name", "John"); jsonObject.insert("age", ...
JSON与js对象序列化实例详解
10-20
序列化是将JavaScript对象转换为JSON字符串的过程，这通常通过`JSON.stringify()`方法完成。反序列化则是将JSON字符串转换回JavaScript对象，通过`JSON.parse()`实现。 例如： ```javascript let obj = { name: '...
java的JsonObject对象提取值方法
10-18
在Java编程中，`JsonObject` 是用来处理JSON数据的一个关键对象。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，广泛应用于网络通信及数据存储。本篇将详细介绍如何在Java中使用`JsonObject`来...
net.sf.json.JSONObject实现Object对象与Json字符串的互转
08-13
在进行JSON与Java对象互转时，需要注意的是，Java对象的属性必须有对应的getter和setter方法，因为`JSONObject`依赖于Java的反射机制来读取和设置属性。此外，`JSONObject`在处理枚举类型时可能需要特别处理，通常会...
用于java对象与json对象间的相互转换(net.sf.json.JSONObject)
03-03
`JSONObject`提供了一种将JSON数据映射到Java对象的方法，这在反序列化时非常有用。假设我们有一个名为`Person`的Java类： ```java public class Person { private String name; private int age; // getters ...
C++ [ rapidjson 使用、封装、UT]、[Base64加码及解码]
06-21
C++ [ rapidjson 使用、封装、UT]、[Base64加码及解码]
【C++】rapidjson库—all is object
qq_44886213的博客
04-16 1242
首先，json（JavaScript objection notation）是一种轻量级的数据交换格式，正是由于其轻量的这个特点，经常替代程序中的变量、对象，被用作程序之间数据传输的格式。 rapidjson？是不是听起来很耳熟，想到了java中使用的fastjson这个依赖，fastjson用来进行java对象和json数据格式之间的转换，一个rapid一个fast哈哈哈，知道你们都是轻量级的了。 rapidjson一个应用在C++程序中json的生成器和解析器。 相较于jsoncpp库，rapid
c++实现对rapidjson的封装，更方便的用户接口
贺生技术专栏
03-16 2539
/******************************************************************* * summery: 提供便捷的方法操作rapidjson * author: hejl * date: 2017-02-17 * description: 有效避免string(NULL), element=NULL,...
在c++项目中使用rapidjson(有具体的步骤，十分详细) windows10系统
smilehjl
05-02 2978
本文章介绍了如何在c++项目中引入rapidjson，并由具体的案例实现
C/C++编程：RapidJSON
OceanStar的博客
05-31 3452
RapidJSON是一个 C++ 的 JSON 解析器及生成器。它的灵感来自 RapidXml。 RapidJSON 小而全。它同时支持 SAX 和 DOM 风格的 API。SAX 解析器只有约 500 行代码。 RapidJSON 快。它的性能可与 strlen() 相比。可支持 SSE2/SSE4.2 加速。 RapidJSON 独立。它不依赖于 BOOST 等外部库。它甚至不依赖于 STL。 RapidJSON 对内存友好。在大部分 32/64 位机器上，每个 JSON 值只占 16 字节（除字符串
rapidjson的使用
qq_34552942的博客
06-17 282
Json使用
cocos2dx中的Rapidjson
weixin_30788731的博客
07-30 164
1 Json基础 JSON 概念和特点： JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation） JSON 是轻量级的文本数据交换格式，类似 XML，但比 XML 更小、更快，更易解析 JSON 独立于语言 * JSON 具有自我描述性，更易理解 。 JSON的创建方式与创建 JavaScript 对象的代码相同。J...
Java中如何定义一个JSONobject对象要求有值
05-25
如果要定义一个JSONObject对象，并且要求有值，可以通过以下代码实现： ```java import org.json.JSONObject; public class Main { public static void main(String[] args) { // 创建一个JSONObject对象，并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值