一个类似jsonreader的c++实现

FlyAnyWhere FlyAnyWhere 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 800+累计阅读 871平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄24年
关注
原创 最新推荐文章于 2026-08-04 12:15:39 发布 871 阅读 AI 写同款· GEO 优化 ›
UE5 C++原生WebSocket客户端开发：从连接到JSON处理实战指南 WebSocket作为一种全双工、低延迟的网络通信协议，已成为实时数据流传输的核心技术。其基于TCP连接，通过一次握手建立持久通道，实现了服务器与客户端之间的双向实时通信，有效解决了HTTP轮询带来的延迟与资源消耗问题。在游戏开发、实时聊天、在线协作等对即时性要求高的应用场景中，WebSocket技术价值显著。本文聚焦于在UE5引擎中，利用其内置的IWebSocket模块，从零构建高性能、高可靠性的原生C++ WebSocket客户端。内容涵盖模块配置、连接管理、自动重连机制等核心环节，并重点详解了如何高效 阅读详情 
.h
template<class RT>
class cast_val;

class HelloResource {
	template<class T> friend class cast_val;
protected:	
	HelloResource(){

	}
	HelloResource(const std::string& key):key_prefix(key){
	}
public:
	typedef std::unordered_map<std::string,std::string> resource_object_item;
	~HelloResource(){

	}
public:
	static HelloResource* instance();
public:
	inline bool operator!()const{
		typedef resource_object_item::const_reference resource_item;
		return object_items.end() == std::find_if(object_items.begin(),object_items.end(),[this](resource_item it){
			return strncmp(this->key_prefix.c_str(),it.first.c_str(),this->key_prefix.length()) == 0;
		});
	}
	template<class T>
	inline void set(const std::string& key,const T& val){
		std::stringstream ss;
		ss << val;
		std::string dst(ss.str());
		object_items[key_prefix + key] = dst;
		if(key.find("score.max.value") != std::string::npos){
			update(key,dst);
		}
	}
public:
	template<class T>
	T cast(const std::string& key)const{
		cast_val<T> castor(*this);
		return castor(key);
	}
	template<class T,class Fn>
	const HelloResource& on(const std::string& key,Fn f)const{
		T val = cast<T>(key);
		f(val);
		return *this;
	}

	template<class Fn>
	const HelloResource& for_each(const std::string& key,Fn f)const{
		for(int i = 0; ; ++i){
			std::stringstream ss;
			ss << key_prefix <<  key << "[" << i << "].";
			HelloResource item(ss.str());
			if(!item){
				break;
			}
			f(item);
		}
		return *this;
	}
protected:
	void update(const std::string&key, const std::string& val);
	const std::string& get_value(const std::string& key)const{
		static std::string null_str;
		const std::string real_key = key_prefix + key;
        auto it = object_items.find(real_key);
        return (it == object_items.end()) ? null_str : it->second;
	}
protected:
	std::string key_prefix;
private:
	static resource_object_item& object_items;
	static resource_object_item& score_items;
};


template<>
class cast_val<unsigned int>{
public:
	cast_val<unsigned int>(const HelloResource& h):hr(h){

	}
	unsigned int operator()(const std::string& key){
		unsigned int ret = 0;
		std::stringstream ss;
		ss << std::hex << hr.get_value(key);
		ss >>  ret;
		return ret;
	}
protected:
	const HelloResource& hr;
};

template<>
class cast_val<int>{
public:
    cast_val<int>(const HelloResource& h):hr(h){
        
    }
    int operator()(const std::string& key){
    	int ret = 0;
        std::stringstream ss;
       	ss << hr.get_value(key);
        ss >> ret;
        return ret;
    }
protected:
    const HelloResource& hr;
};

template<>
class cast_val<std::string>{
public:
    cast_val<std::string>(const HelloResource& h):hr(h){
        
    }
    const std::string& operator()(const std::string& key){
        return hr.get_value(key);
    }
protected:
    const HelloResource& hr;
};

template<>
class cast_val<HelloResource>{
public:
    cast_val<HelloResource>(const HelloResource& h):hr(h){
        
    }
    HelloResource operator()(const std::string& key){
		return HelloResource(hr.key_prefix + key + ".");
    }
protected:
    const HelloResource& hr;
};

.cpp

 namespace {
 template<class Fn>
 void for_each_line(const std::string& f_name, Fn func) {
	std::string fullPath = CCFileUtils::sharedFileUtils()->fullPathForFilename(f_name.c_str());
	unsigned long nSize = 0,offset = 0;
	unsigned char* pBuffer = CCFileUtils::sharedFileUtils()->getFileData(fullPath.c_str(), "rb", &nSize);

 	if (NULL == pBuffer || 0 == nSize) {
 		free(pBuffer);
 		CCLOG("open file %s failed: %s(%d)",fullPath.c_str(),strerror(errno),errno);
 		return;
 	}
 	std::stringstream ss((char*)pBuffer);
 	for (;!ss.eof();) {
 		char line[1024] = {0};
 		ss.getline(line,sizeof(line));
 		if (0 == strlen(line) || line[0] == ';')
 			continue;
 		func(line);
 	}
 	free(pBuffer);
 }

 HelloResource::resource_object_item items;
 HelloResource::resource_object_item scores;

 void load_items(){
	for_each_line("main_menu.ini",[](const std::string& line){
		char key[128] = {0},val[256] = {0};
		sscanf(line.c_str(),"%[^=]=%[^\n]",key,val);
		items[key] = val;
		if(line.find(".score.max.value") != std::string::npos){
			scores[key] = val;
		}
	});
 }
 void load_scroes(){
	for_each_line("score.ini",[](const std::string& line){
		std::stringstream ss(line);
		std::string key,val;
		ss >> key >> val;
		items[key] = val;
		scores[key] = val;
	});
	std::string scoreFile = CCFileUtils::sharedFileUtils()->getWritablePath() + "score.ini" ;
	for_each_line(scoreFile,[](const std::string& line){
		std::stringstream ss(line);
		std::string key,val;
		ss >> key >> val;
		items[key] = val;
		scores[key] = val;
	});		
 }
 void update_scores(){
	std::string scoreFile = CCFileUtils::sharedFileUtils()->getWritablePath() + "score.ini" ;
	std::ofstream ofs(scoreFile);
	if(!ofs){
		CCLOG("open file %s failed:%s(%d)",scoreFile.c_str(),strerror(errno),errno);
		return;
	}
	std::for_each(scores.begin(),scores.end(),[&ofs](HelloResource::resource_object_item::const_reference it){
		ofs << it.first << "\t" << it.second << std::endl;
	});
 }
 class load_configure{
 public:
	 load_configure(){
		 load_items();
		 load_scroes();
	 }
 };
 }


 HelloResource::resource_object_item& HelloResource::object_items = items;
 HelloResource::resource_object_item& HelloResource::score_items = scores;




HelloResource* HelloResource::instance(){
	static HelloResource inst;
	static load_configure configure;
	return &inst;
}

void HelloResource::update(const std::string& key, const std::string& val) {
	score_items[key] = val;
	update_scores();
}

一个简单的使用 


CCScene* HelloWorld::scene()
{
    CCScene *scene = CCScene::create();
    HelloWorld *layer = HelloWorld::create();
    scene->addChild(layer);
    return scene;
}

class score_context{
public:
	int counts;
	bool add;
public:
	score_context(int c,bool a):counts(c),add(a){

	}
};
void HelloWorld::spriteScoreDone(CCNode* pSender){
	 CCLabelTTF* item = ( CCLabelTTF*)pSender;
	 const std::string& curScoreString = HelloResource::instance()->cast<std::string>(senceName + ".score.cur.label");
	 std::string scoreString;
	 switch(item->getTag()){
	case emDispear: {
		score_context* sc = (score_context*) item->getUserData();
		int score = 10 * std::pow(1.1, sc->counts);
		curScore = sc->add ? curScore + score : curScore - score;
		scoreString = curScoreString + cast_to<std::string>(curScore);
		curScoreLabel->setString(scoreString.c_str());
		sc->counts--;
		item->setTag(0 == sc->counts ? emChanged : emDispear);
		item->runAction(CCSequence::create(
				CCBlink::create(0.1f,1),
				CCCallFuncN::create(this,callfuncN_selector(HelloWorld::spriteScoreDone)),
			NULL)
		);
		break;
	}
	case emChanged: {
		item->stopAllActions();
		int maxScore = HelloResource::instance()->cast<int>(senceName + ".score.max.value");
		if (curScore <= maxScore) {
			return;
		}
		maxScoreLabel->setTag(emFocus);
		maxScoreLabel->runAction(CCSequence::create(
				CCBlink::create(0.5f,1),
				CCCallFuncN::create(this,callfuncN_selector(HelloWorld::spriteScoreDone)),
			NULL)
		);
		break;
	}
	case emFocus: {
		item->stopAllActions();
		const std::string& maxScoreString = HelloResource::instance()->cast<std::string>(senceName + ".score.max.label");
		scoreString = maxScoreString + cast_to<std::string>(curScore);
		maxScoreLabel->setString(scoreString.c_str());
		HelloResource::instance()->set(senceName + ".score.max.value",	curScore);
		break;
	}
	 default:{
		 break;
	 }
	 }
}
void HelloWorld::update_score(int counts,bool add){
	const std::string& curScoreString = HelloResource::instance()->cast<std::string>(senceName + ".score.cur.label");
	std::string scoreString = curScoreString + cast_to<std::string>(curScore);
	curScoreLabel->setUserData(new score_context(counts,add));
	curScoreLabel->setTag(emDispear);
	curScoreLabel->runAction( CCSequence::create(
			CCBlink::create(0.1f,1),
			CCCallFuncN::create( this,callfuncN_selector(HelloWorld::spriteScoreDone)),
		NULL)
	);
}

void HelloWorld::spriteActionDone(CCNode* pSender){
	CCMenuItemImage* item = (CCMenuItemImage*)pSender;
	switch(item->getTag()){
	case emDispear : {
	    CCParticleExplosion* explosion = CCParticleExplosion::create();
	    explosion->setPosition(ccp(item->getContentSize().width / 2,item->getContentSize().height / 2));
	    explosion->setDuration(3.0f);
	    item->addChild(explosion,0,1000);
	    item->setTag(emChanged);
		item->runAction(CCSequence::create(
				CCFadeIn::create(0.5),
				CCCallFuncN::create( this,callfuncN_selector(HelloWorld::spriteActionDone)),
				NULL));
		break;
	}
	case emChanged:{
		item->setTag(emFocus);
		updateSpriteItem(item);
		item->runAction(CCSequence::create(
				CCLiquid::create(2.5f,CCSize(50,50),1,1),
				CCCallFuncN::create( this,callfuncN_selector(HelloWorld::spriteActionDone)),
				NULL));
		item->removeChild(item->getChildByTag(1000),true);
		break;
	}
	case emFocus:{
		CCLOG("item action done!!!");
		item->stopAllActions();
		break;
	}
	default:{
		CCLOG("Unknown action done!!!");
		break;
	}
	}
}

void HelloWorld::flush_sprite(bool suc){
	std::for_each(selectedSprites.begin(),selectedSprites.end(),[&suc,this](std::map<void*,bool>::const_reference it){
		CCMenuItemImage* item = (CCMenuItemImage*)it.first;
		item->stopAllActions();
		item->setRotation(0);
		if(!suc){
			return;
		}
		item->setTag(emDispear);
		item->runAction( CCSequence::create(
				CCFadeOut::create(0.5),
				CCCallFuncN::create( this,callfuncN_selector(HelloWorld::spriteActionDone)),
				NULL) );
	});
	update_score(selectedSprites.size(),suc);
	updateBgMusic(suc ? emSuc : emFai);
	selectedSprites.clear();
}

CCMenuItemImage* HelloWorld::updateSpriteItem(CCMenuItemImage* item ){
	int index = rand() % this->allSprites.size();
	const SpriteContex* spriteContext = &this->allSprites[index];
	if(NULL == item){
		item = CCMenuItemImage::create(
				spriteContext->normalImg.c_str(),
				spriteContext->selectImg.c_str(),
				this,
				menu_selector(HelloWorld::menuSelectedCallback));
	}else{
		item->setNormalImage(CCSprite::create(spriteContext->normalImg.c_str()));
		item->setSelectedImage(CCSprite::create(spriteContext->selectImg.c_str()));
	}
	this->sprites[item] = spriteContext;
	item->setUserData((void*)spriteContext);
	return item;
}

void HelloWorld::updateBgMusic(int val) {
    const char* szEfFile = NULL;
    CocosDenshion::SimpleAudioEngine* musicEngine = CocosDenshion::SimpleAudioEngine::sharedEngine();
    switch(val){
    case emSuc:{
    	szEfFile = this->sucMusic.c_str();
    	break;
    }
    case emFai:{
    	szEfFile = this->faiMusic.c_str();
    	break;
    }
    }
    musicEngine->stopAllEffects();
    musicEngine->playEffect(szEfFile);
}

bool HelloWorld::found_all_sprite(const SpriteContex* context,int counts)const{
	typedef std::map<void*,const SpriteContex*>::const_reference sprite_ref;
	int item_counts = std::count_if(sprites.begin(),sprites.end(),[&context](sprite_ref item){
		return (*(item.second) == *context);
	});
	CCLOG("item_counts = %d,input counts = %d",item_counts,counts);
	return item_counts == counts;
}


void HelloWorld::menuSelectedCallback(CCObject* pSender){
	CCMenuItemImage* pSprite = (CCMenuItemImage*)pSender;
	const SpriteContex* sel = (const SpriteContex*)pSprite->getUserData();
	CCLOG("%s selected",sel->name.c_str());
	typedef std::map<void*,const SpriteContex*>::const_reference sprite_ref;

	if(selectedSprites.empty()){
		std::for_each(sprites.begin(),sprites.end(),[this,&sel](sprite_ref it){
			if(*sel == *(it.second)){
				this->selectedSprites[it.first] = false;
			}
		});
	}
	if(selectedSprites.find(pSprite) == selectedSprites.end()){
		flush_sprite(false);
		return;
	}
	selectedSprites[pSprite] = true;
	CCRepeatForever* forever = CCRepeatForever::create(CCRotateBy::create(0.5f, 360));
	pSprite->runAction(forever);
	int size = std::count_if(selectedSprites.begin(),selectedSprites.end(),[](std::map<void*,bool>::const_reference it){
		return it.second;
	});
	if(size == selectedSprites.size()){
		flush_sprite(true);
		return;
	}
	CCLOG("%s selected : %d == %d", sel->name.c_str(), selectedSprites.size(), size);
}


void HelloWorld::initScoreSystem(const HelloResource& score,CCLabelTTF*& scoreLabel){
	if(!score){
		CCLOG("get score information failed");
		return;
	}
	std::string maxVal = score.cast<std::string>("label") + score.cast<std::string>("value");
    scoreLabel = CCLabelTTF::create(maxVal.c_str(), "Arial", HelloResource::instance()->cast<int>("font.size"));
    scoreLabel->setColor(ccRED);
    scoreLabel->setPosition(ccp(score.cast<int>("posion.x"),score.cast<int>("posion.y")));
    this->addChild(scoreLabel);
}

bool HelloWorld::init()
{
    //////////////////////////////
    // 1. super init first
    if ( !CCLayer::init() )
    {
        return false;
    }
    curScore = 0;
    //setTouchEnabled(true);

    std::stringstream ss;
    ss << "sence[" << HelloResource::instance()->cast<int>("cur_sence") << "]";
    senceName = ss.str();
    CCLOG("get %s information ...",senceName.c_str());
    HelloResource hr = HelloResource::instance()->cast<HelloResource>(senceName);
    if(!hr){
		CCLOG("get %s information failed",senceName.c_str());
		return false;
    }
    hr.for_each("sprite",[this](const HelloResource& sprite){
    	if(!sprite){
    		CCLOG("get sprite information failed");
    		return;
    	}
    	SpriteContex context = {
    			sprite.cast<unsigned int>("property"),
    			this->senceName,
    			sprite.cast<std::string>("normal"),
    			sprite.cast<std::string>("selected")
    	};
    	this->allSprites.push_back(context);
    }).on<HelloResource>("back_ground",[this](const HelloResource& bg){
    	if(!bg){
    		CCLOG("get back ground information failed");
    		return;
    	}		
    	HelloWorld* that = this;
    	bg.on<std::string>("music",[](const std::string& music){
    		if(music.empty()){
        		CCLOG("get back ground music failed");
        		return;
    		}
            CocosDenshion::SimpleAudioEngine* musicEngine = CocosDenshion::SimpleAudioEngine::sharedEngine();
            musicEngine->stopBackgroundMusic(true);
            musicEngine->playBackgroundMusic(music.c_str(),true);
    	}).on<std::string>("img",[&that](const std::string& img){
    		if(img.empty()){
        		CCLOG("get back ground img failed");
        		return;
    		}
            CCSprite* bg = CCSprite::create(img.c_str());
            CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();
    		bg->setPosition(ccp(visibleSize.width/2, visibleSize.height / 2));
            that->addChild(bg,-10);
    	});
    }).on<HelloResource>("score",[this](const HelloResource& score){
    	if(!score){
    		CCLOG("get score information failed");
    		return;
    	}
		auto that = this;
    	score.on<HelloResource>("max",[&that](const HelloResource& max){
    		that->initScoreSystem(max,that->maxScoreLabel);
    	}).on<HelloResource>("cur",[&that](const HelloResource& cur){
    		that->initScoreSystem(cur,that->curScoreLabel);
    	});
    }).on<HelloResource>("head",[this](const HelloResource& head){
        if(!head){
    		CCLOG("get head information failed");
    		return;
        }
        CCSprite* pSprite = CCSprite::create(head.cast<std::string>("img").c_str());
        pSprite->setPosition(ccp(head.cast<int>("posion.x"),head.cast<int>("posion.y")));
        this->addChild(pSprite, 0);
    }).on<std::string>("title",[this](const std::string& title){
		if(title.empty()){
    		CCLOG("get title information failed");
    		return;
        }
        CCLabelTTF* pLabel = CCLabelTTF::create(title.c_str(), "Arial", HelloResource::instance()->cast<int>("font.size"));
        CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();
        CCPoint origin = CCDirector::sharedDirector()->getVisibleOrigin();
        pLabel->setPosition(ccp(origin.x + visibleSize.width/2,
                                origin.y + visibleSize.height - pLabel->getContentSize().height));
        this->addChild(pLabel, 1);
	}).on<HelloResource>("menu.return",[this](const HelloResource& rt) {
		if(!rt) {
			CCLOG("get return  menu information failed");
			return;
		}
		CCMenuItemImage *pReturnItem = CCMenuItemImage::create(
			rt.cast<std::string>("img.normal").c_str(),
			rt.cast<std::string>("img.select").c_str(),
			this,
			menu_selector(HelloWorld::menuCloseCallback));
        CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();
        CCPoint origin = CCDirector::sharedDirector()->getVisibleOrigin();
        pReturnItem->setPosition(ccp(origin.x + visibleSize.width - pReturnItem->getContentSize().width/2 ,
								origin.y + pReturnItem->getContentSize().height/2));
		CCMenu* pMenu = CCMenu::create(pReturnItem, NULL);
		pMenu->setPosition(ccp(rt.cast<int>("x"),rt.cast<int>("y")));
		this->addChild(pMenu, 1);
	}).on<HelloResource>("grid",[this,&hr](const HelloResource& grid){
		if(!grid) {
			CCLOG("get grid information failed");
			return;
		}
    	const int colCount = grid.cast<int>("col");
    	const int rowCount = grid.cast<int>("raw");
    	const int imgWidth = grid.cast<int>("size");
    	const int maxItem = colCount * rowCount;
    	CCArray* items = CCArray::createWithCapacity(maxItem);
    	for(int i = 1,x = 1,y = 1; i <= maxItem; ++i){
    		CCMenuItemImage* pSprite = this->updateSpriteItem(NULL);
    		pSprite->setPosition(ccp(x*imgWidth,y*imgWidth));
    		items->addObject(pSprite);
    		(i % colCount == 0)? (x = 1,++y) : (++x);
    	}
        CCMenu* pMenu = CCMenu::createWithArray(items);
        pMenu->setPosition(ccp(grid.cast<int>("x"),grid.cast<int>("y")));
        this->addChild(pMenu, 1);
        items->release();
    }).on<HelloResource>("state",[this](const HelloResource& state){
		if(!state) {
			CCLOG("get state information failed");
			return;
		}
		this->sucMusic = state.cast<std::string>("succ.music");
		this->faiMusic = state.cast<std::string>("fail.music");
    });
    return true;
}


void HelloWorld::menuCloseCallback(CCObject* pSender)
{
	this->allSprites.clear();
	CocosDenshion::SimpleAudioEngine::sharedEngine()->stopBackgroundMusic(true);
	CCDirector::sharedDirector()->replaceScene(WellCome::scene());
}


收录于
互联网

当前文章被收录于：

互联网
16 篇文章 0 人学习
订阅专栏 查看详情
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
C++利用jsoncpp库实现写入和读取json文件（含中文处理） C++中json序列化和反序列化操作 阅读详情

相关推荐

GDCM库JSON测试程序演示

GDCM（Grassroots DICOM）是一款用于处理DICOM（数字成像和通信医疗图像）图像的C++库，它提供了许多用于读取、写入和操作DICOM文件的工具。上面的代码片段中，我们首先创建了一个GDCM的Reader对象，并设置要读取的DICOM文件的名称。如果读取失败，则返回1。接着，我们创建了一个JSONReader对象，并使用Read()方法将GDCL::File对象转换为JSON对象。本文演示了如何在GDCM库中使用JSON类将DICOM数据转换为JSON格式，并进行解析和处理。

TechRoarX的博客 146

用C++写一款简单的JSON库

项目地址 jsoncpp ，此项目受到 leptjson 启发，实现了最基本的功能，仅作学习使用。 提供简单的 parse() 和 generate() 方法将 JSON 文本解析成对象，反之亦然 仅支持将基本类型为 Value 的 JSON 抽象语法树与 JSON 文本相互转换 使用标准 C/C++ 语言 (C++11) 不依赖第三方库 启动 启动此项目需要安装 gcc4.8 以...

zzzz76C的博客 531

C++的JSON库及使用方法

jsoncpp 主要包含三个class：Value、Reader、Writer。注意Json::Value 只能处理 ANSI 类型的字符串，如果 C++ 程序是用 Unicode 编码的，最好加一个 Adapt 类来适配

C/C++之读写JSON数据

前言 在进行配置文件读取或者进行RPC(Remote Produce Call)，我们需要在两个进程间传递大量的数据，这时我们一般会选择json/xml/protobuf来序列化数据，加快数据的传输与解析速度。 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。JSON采用完全独立于语言的文本格式，这些特性使JSON成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成。关于json数据格式的具体介绍，大家可以自己去搜索，今天主要介绍下C/C++如何

dddgggd的博客 1万+

小白学电路之cadance搭建buffer电路

Buffer（缓冲器）是一种放大器或驱动电路，主要用于隔离输入和输出，以防止负载对前级电路造成干扰或影响。本文作者在电路方面是小白水平，目前正在学习，有不足之处欢迎指正。3.创建新的cellview，对此buffer进行仿真验证。2.创建buffer的symbol。电路中的V2的详细参数。

weixin_58051657的博客 1984

碳纳米管NRAM：突破5纳米制程的下一代存储技术

在半导体存储领域，非易失性存储器和随机存取存储器是两大基础技术方向。传统DRAM速度快但断电易失，NAND Flash非易失但写入慢、寿命有限，两者在先进制程下都面临物理极限挑战。碳纳米管作为一种新型纳米材料，凭借其优异的导电性、机械强度和尺寸微缩潜力，为存储技术革新提供了物理基础。基于碳纳米管的NRAM技术，通过控制纳米管间的可逆接触实现电阻状态切换，兼具DRAM级速度和Flash的非易失性，同时具备近乎无限的擦写寿命和出色的CMOS工艺兼容性。这项技术不仅能满足5纳米以下制程的存储需求，在数据中心缓存、

weixin_42576804的博客 427

C++的Json库的简单实现

我的Json库实现Json实现Json[我的源码（点这里）](https://github.com/jo-qzy/MyJson/)和效果图Json库中的类实现JSON::Value类JSON::ReaderJSON::WriterFastWriterStyleWriter序列化部分（Reader）空值、布尔值number字符串转义字符UTF-8转换arrayobject反序列化输出（Writer部...

无聊星期三的博客 1万+

【逆向实战】Unity游戏资源提取与解密全攻略：从AssetBundle到libil2cpp.so的破解技巧

本文详细介绍了Unity游戏资源提取与解密的完整流程，涵盖从AssetBundle到libil2cpp.so的破解技巧。通过AssetStudio和Il2CppDumper等工具，读者可以学习如何提取未加密资源、处理加密文件，并掌握动态dump技术。文章还提供了自动化脚本编写和常见问题解决方案，帮助逆向工程爱好者高效完成资源提取任务。

weixin_29012765的博客 1046

C++ 之 C++ 操作 json 文件（C++读写json文件）及jsoncpp配置详解

目录 前言 一、json文件简介 1、json文件 2、json与其他存储数据方式比较 二、C++操作json文件 1、jsoncpp 库下载 2、C++从字符串中读取json 3、C++从文件中读取json 4、C++写入json文件 5、主函数 附：jsoncpp库配置 1、解压并转移 2、配置属性 3、配置项目 前言 json文件是比较轻量级的文件，格式简单，使用方便。用来存放信息相比其他方式有自己得天独厚的优势。 今天给大家分享的是如何利用C++来操作json文件.

天涯路的专栏 1万+

PLC期末速成——顺序功能图转梯形图

一、根据顺序功能图写出梯形图程序 顺序功能图： 梯形图： 1、程序段1，系统运行标志M0.0的启-保-停控制电路。 2、程序段2，PLC上电与逆行，初始化脉冲M1.0激活初始化步M2.0。 3、程序段3，当M2.0初始化步为活动步，并且M0.0系统运行标志位为1时，置位M2.1步，复位M2.0步。 4、当M2.1为活动步，并且I0.3中液位传感器为1时，置位M2.2步，复位M2.1步。 5、程序段5，当M2.2为活动步，并且I0.2高液位传感器为1时，置位M2.3步，复位M2.2步。 6、程序段

qq_52251819的博客 1万+

用面包板实测MOSFET：手把手教你测量跨导和开关时间

本文详细介绍了如何使用面包板、Arduino和示波器搭建测试平台，实测MOSFET的跨导和开关时间。通过分步测量流程和示波器技巧，帮助电子设计初学者深入理解MOSFET的动态特性，包括跨导计算、开关时间参数解析以及米勒平台现象分析。

beer8的博客 219

11.Chromium指纹浏览器开发教程之JSON工具类

Chromium指纹浏览器开发教程之JSON工具类

浏览器开发教学 1321

KVM — 与 QEMU 和 Libvirt 的关系

目录目录 前言 KVM QEMU KVM 与 QEMU qemu-kvm Libvirt Libvirt 在 OpenStack 中的应用前言如果是刚开始接触虚拟机技术的话, 对上述的概念肯定会有所混淆, 傻傻的分不清. 尤其在看虚拟化技术文档时导致理解能力下降, 所以在开始学习虚拟化技术之前对这些概念有一个整体的认识和清晰的理解, 就显得很有必要了.KVMKVM(Kernel-basedVirtu

烟云的计算 5735

SimdJsonSharp：揭秘每秒解析GB级JSON的C高性能库

SimdJsonSharp是一个专为C#开发者打造的高性能JSON解析库，它通过SIMD指令集和优化算法实现了每秒解析GB级JSON数据的惊人速度。作为lemire/simdjson项目的C#绑定及完整C#移植版本，该库为处理大规模JSON数据提供了革命性的解决方案。 ## 🚀 为什么选择SimdJsonSharp？ 在当今数据驱动的应用中，JSON解析性能往往成为系统瓶颈。SimdJson

gitblog_00028的博客 1050

【Python图像处理局部放大】输入图像，选择两处不同的区域进行放大操作，然后将原始图像、处理后的两个区域以及标记合成新图像进行展示

Python图像处理与区域放大连接标记：选择特定区域并对其进行放大操作，然后将原始图像、处理后的两个区域进行标记后的新图像保存到文件中。

qq_35831906的博客 2243

智能挂锁软件需求规格说明书（SRS）

智能挂锁系统SmartPadlockV1.0是一款融合蓝牙通信、指纹识别和远程控制技术的便携式安防设备。系统由设备端、移动App和云平台三部分组成，支持蓝牙配对（10米内）、指纹识别、OTP一次性密码等多种开锁方式，响应时间＜1.5秒。产品采用SM2/SM4加密技术保障安全，日均20次使用下续航达180天，兼容iOS13+/Android8.0+系统。功能包括设备绑定、远程授权、开锁记录查询和OTA固件升级，符合个人信息保护法规要求，适用于仓储、快递柜等多场景应用。

moton2017的博客 2111

chromium json read 使用

使用chromium base json 实现json读写

weixin_43473033的博客 374

WINCC7.3破解文件

WINCC7.3硬件够破解文件，有需要的下载！WINCC7.3硬件够破解文件，有需要的下载！

JsonReader.dll jrsysMSCryptoDll.dll jhi_servicePS64.dll JcTransaction.dll JCCOMSharedTypes.dll

以上只是通用的运行库dll处理方式，如果你遇到缺失文件是第三方的软件文件，那么就需要下载到属于这个程序所匹配的版本的文件，然后将这个文件复制到这个程序的安装目录下才能解决问题。如果我们遇到关于文件在系统使用过程中提示缺少找不到的情况，如果文件是属于运行库文件的可以单独下载文件解决，但还是建议安装完整的运行库，可以尝试采用手动下载替换的方法解决问题！文件下载完成后，下方列表会有很多个不同版本的文件，这里所有文件都是免费可下载的，我们根据自己所需要的版本文件，点击右边的“打开”，这样就找到了下载的文件。

python学习 414

Camera2Demo

在Camera2 的基础上进行封装，使得Camera2一堆初始化逻辑与Activity分离，降低耦合度，完成预览拍照并保存的操作

NTscan扫描工具

ntscan是一个扫描器，可以扫描没有密码和弱密码的共享，先到配置文件中填写猜测的用户名和密码，扫描过程中右侧出现的是扫描日志。

newtonsoft 数组反序列化_c++基于反射的序列化和反序列化深入实践

1 序列化与反序列化目的 12 序列化库的设计思路 22.1 思路 22.2 序列化流程图 32.3 序列化中的主要结构 53 TypeInfo的设计 53.1 类的信息 53.2 类的信息结构 63.3 类型注册 83.3.1 宏定义使用示例 83.3.2 全局类型信息数组 93.3.3 注册类 93.3.4 注册类名 93.3.5 注册类的父类 103.3.6 构造成员变量信息 103.3.7...

weixin_39932181的博客 366

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。，新界面，新视觉，

虚幻引擎C++文件交互与JSON序列化实战指南

在游戏开发与工具链构建中，文件读写与数据序列化是连接内存数据与持久化存储的核心技术。其原理在于通过操作系统API或引擎接口获取文件路径，并利用序列化技术将复杂的数据结构转换为可存储的字节流或文本格式（如JSON）。这项技术的价值在于实现了配置、存档、日志等游戏数据的持久化与跨会话共享，是构建编辑器扩展、数据驱动系统和玩家进度管理的基础。虚幻引擎（UE4/UE5）为此提供了强大的原生支持，例如通过`DesktopPlatform`模块调用系统文件对话框，以及利用`JsonUtilities`模块实现UObje

weixin_33754065的博客 327

UE4 C++ JSON数据解析实战：从文件读取到游戏配置应用

JSON作为一种轻量级数据交换格式，其核心原理是基于文本的键值对结构，易于人类阅读和机器解析。在游戏开发领域，JSON的技术价值在于实现数据与代码的解耦，支持运行时动态配置加载和热更新，从而提升开发迭代效率。常见的应用场景包括游戏配置表、角色属性、存档数据和网络通信协议等。本文聚焦于Unreal Engine 4 C++开发，通过构建完整的JSON文件读取、解析与数据应用工作流，深入解析UE4的Json与JsonUtilities模块，并分享手动解析、字段校验、性能优化等实战技巧，帮助开发者掌握数据驱动设计

weixin_30765577的博客 291

UE5 C++ WebSocket客户端开发：从配置到JSON解析与实战优化

在实时网络应用开发中，WebSocket协议是实现全双工通信的核心技术，它通过在客户端与服务器之间建立持久连接，克服了传统HTTP协议请求-响应模式的局限性，实现了低延迟、高效率的数据双向实时传输。其技术价值在于为在线游戏、实时聊天、金融行情推送等对即时性要求高的场景提供了底层通信保障。在Unreal Engine 5这类游戏引擎中，集成WebSocket客户端是实现上述应用场景的关键工程实践。本文聚焦于UE5 C++环境下的WebSocket客户端开发，详细阐述了从插件配置、连接管理到JSON数据解析的完

weixin_30432579的博客 345

c/c++ jsoncpp使用

// file to json #include <iostream> #include <cstdlib> #include <fstream> #include <jsoncpp/json/json.h> using namespace std; int main() { string file_path = "./conf.json" ...

qq1187239259的博客 573

c++ json reader如何遍历key

Json::Reader reader; CString strJson,strError; Json::Value m_JsonData; if(!reader.parse((LPCTSTR)strJson,m_JsonData)) { return -1; } if(m_JsonData.type()==Json::nullValue) { return -1; }

tianyu的专栏 - Linux site:blog.youkuaiyun.com/wishfly 8512

UE5 C++实战：构建原生HTTP客户端与JSON数据解析器

本文详细介绍了在UE5中使用C++构建原生HTTP客户端与JSON数据解析器的实战方法。通过模块配置、GET请求实现、JSON数据处理等核心步骤，帮助开发者高效完成网络通信功能开发，特别适合需要轻量级、高性能网络交互的UE5项目。

332

Unreal Engine集成轻量级中文OCR：实现游戏场景文字实时交互

光学字符识别（OCR）技术是计算机视觉领域的关键分支，其核心原理是通过深度学习模型自动检测并识别图像中的文字信息，将其转化为可编辑和处理的文本数据。这项技术的核心价值在于打通了视觉信息与语义信息之间的壁垒，极大地提升了信息处理的自动化程度。在游戏开发领域，OCR技术能够将静态的环境文字转化为动态的游戏交互元素，为玩法创新提供了新的可能性。通过将轻量级、开源的中文OCR库chineseocr_lite集成到Unreal Engine中，开发者可以在游戏运行时实时识别画面中的中文文字，驱动复杂的游戏逻辑，例如实

weixin_30292745的博客 296
上一篇： 一个有意思的类型实现，可惜是个半成品
下一篇： 关于宏的制表功能
点赞 0
评论 0
书签 书签 0
FlyAnyWhere
FlyAnyWhere
博客等级 码龄24年 5粉丝 28原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值