c++编写json解析类

最新推荐文章于 2024-05-13 11:54:06 发布
最新推荐文章于 2024-05-13 11:54:06 发布
阅读量3.5k 收藏 15
点赞数 1
分类专栏： c++ 文章标签： c++ json string output delete insert
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sx1989827/article/details/8067073
版权

      好久没有更新博客了，今天就将我之前写的一些代码陆续发上来。

json.h

#include<iostream>
#include <string>
using namespace std;

class CJson
{
public:
	enum TYPE{STRING,LONG,ARRAY,OBJECT,BOOL,NAMEDOBG,STRINGA,LONGA,ARRAYA,OBJECTA,BOOLA,NAMEDOBGA};
	typedef struct _NODE
	{
		friend CJson;
		string m_key;
		TYPE type;
		string m_strVal;
		bool m_boolVal;
		long m_longVal;
		string m_objVal;
		_NODE(){memset(this,0,sizeof(_NODE));}
		_NODE* GetChild(){return m_child;}
		_NODE* GetNext(){return m_next;}
		_NODE* GetParent(){return m_parent;}
		_NODE* Get(int index)
		{
			NODE* n=m_child;
			for(int i=0;i<index;i++)
			{
				if(n==0)
				{
					return 0;
				}
				n=n->m_next;
			}
			return n;
		}
		_NODE* Get(char* key)
		{
			NODE* n=m_child;
			while(n)
			{
				if(n->m_key==key)
				{
					return n;
				}
				n=n->m_next;
			}
			return 0;
		}
		_NODE* Append(TYPE type,char* key,char* sVal,long nVal)
		{
			NODE *node=new NODE;
			node->type=type;
			if(type==STRING)
			{
				node->m_key=key;
				node->m_strVal=sVal;
			}
			else if (type==LONG)
			{
				node->m_key=key;
				node->m_longVal=nVal;
			}
			else if(type==OBJECT)
			{
				node->m_key=key;
			}
			else if (type==ARRAY)
			{
				node->m_key=key;
			}
			else if(type==STRINGA)
			{
				node->m_strVal=sVal;
			}
			else if (type==LONGA)
			{
				node->m_longVal=nVal;
			}
			else if(type==OBJECTA)
			{

			}
			else if (type==ARRAYA)
			{

			}
			if(!m_child)
			{
				m_child=node;
				node->m_parent=this;
			}
			else
			{
				NODE* n=m_child;
				while (n->m_next)
				{
					n=n->m_next;
				}
				n->m_next=node;
				node->m_parent=this;
			}
			return node;
		}
		_NODE* Remove(_NODE* node)     //remove  child 
		{
			if(!node)
			{
				return 0;
			}
			NODE* nNext=node->m_next,*n=m_child;
			if(node==n)
			{
				delete[] m_child;
				m_child=0;
			}
			else
			{
				while(n->m_next!=node)
				{
					n=n->m_next;
				}
				n->m_next=node->m_next;
				delete node;
			}
			return nNext;
		}
		_NODE* Remove(int index)    //remove  array  child
		{
			if(index<0)
				return 0;
			NODE* n=m_child,*n1;
			if(index==0)
			{
				NODE* n=m_child;
				m_child=m_child->m_next;
				delete n;
				return m_child;
			}
			for(int i=0;i<index;i++)
			{
				n1=n;
				n=n->m_next;
			}
			n1->m_next=n->m_next;
			delete n;
			return n1->m_next;
		}
		_NODE* Remove(CJson* oCj)         //remove self
		{
			if(!oCj)
			{
				return 0;
			}
			NODE* nNext=m_next;
			if(!m_parent)
			{
				if(!oCj->m_root)
				{
					return 0;
				}
				if(oCj->m_root==this)
				{
					oCj->m_root=nNext;
					delete this;
				}
				else
				{
					NODE *n=oCj->m_root;
					while(n->m_next!=this)
					{
						n=n->m_next;
					}
					NODE* n1=n->m_next;
					n->m_next=n1->m_next;
					delete n1;
				}
			}
			else
			{
				if(!m_parent->m_child)
				{
					return 0;
				}
				if(m_parent->m_child==this)
				{
					m_parent->m_child=nNext;
					delete this;
				}
				else
				{
					NODE *n=m_parent->m_child;
					while(n->m_next!=this)
					{
						n=n->m_next;
					}
					NODE* n1=n->m_next;
					n->m_next=n1->m_next;
					delete n1;
				}
			}
			return nNext;
		}
		_NODE* Insert(_NODE* node,int index)
		{
			if(!node)
			{
				return 0;
			}
			if(!m_child)
			{
				m_child=node;
				return node;
			}
			NODE* n=m_child;
			for(int i=0;i<index-1;i++)
			{
				if(!n->m_next)
				{
					break;
				}
				n=n->m_next;
			}
			node->m_next=n->m_next;
			n->m_next=node;
			node->m_parent=this;
			return node;
		}
		_NODE* Copy()
		{
			_NODE* n=new _NODE;
			*n=*this;
			n->m_child=0;
			n->m_parent=0;
			n->m_child=0;
			return n;
		}
	private:
		_NODE *m_child;
		_NODE *m_next;
		_NODE *m_parent;
	}NODE;
	CJson();
	~CJson();
	friend _NODE;
	bool Load(char*);
	NODE* GetRoot();
	string GetJsonString();
	NODE* Get(char*);
	NODE* Append(TYPE,char*,char*,long);
	NODE* Remove(NODE*);         //return next node
	NODE* Insert(NODE*,int);
private:
	void Release(NODE*);
	void output(NODE *);
	inline string GetTab(int num){
		string tab;
		for(int i=0;i<num;i++)
		{
			tab+="\t";
		}
		return tab;
	}
	char* m_str;
	NODE *m_root;
	string m_strOutput;

};
typedef CJson::NODE JsonNode;


json.cpp

#include "json.h"
CJson::CJson()
{
	m_str=0;
	m_root=0;
}
CJson::~CJson()
{
	Release(m_root);
	if(m_str)
	{
		delete[] m_str;
		m_str=0;
	}
}
void CJson::Release(NODE* node)
{
	if(node)
	{
		Release(node->m_child);
		Release(node->m_next);
		delete node;
	}

}
JsonNode* CJson::GetRoot()
{
	return m_root;
}
bool CJson::Load(char* str)
{
	NODE* CurNode;
#define CHECKBLANK(ch) (ch==' ' || ch=='\t' || ch=='\r' || ch=='\n')
	if(str==0 || *str==0)
	{
		return false;
	}
	m_str=new char[strlen(str)+1];
	strcpy(m_str,str);
	int i=0;
	while(m_str[i]!='{')
	{
		i++;
	}
	i++;
	NODE *m_par=0,*m_cur=0;
	bool bInKey=true;
	while(m_str[i])
	{
		if(!CHECKBLANK(m_str[i]))
		{
			if(m_str[i]==',')
			{
				bInKey=true;
			}
			else if(m_str[i]==':')
			{
				bInKey=false;
			}
			else if(m_str[i]=='[')
			{
				if(!bInKey)
				{

					m_cur->type=ARRAY;
					m_par=m_cur;
					bInKey=true;

				}
				else
				{
					NODE *node=new NODE;
					memset(node,0,sizeof(NODE));
					node->type=ARRAYA;
					node->m_parent=m_par;
					m_cur=node;
					if(m_par->m_child==0)
					{
						m_par->m_child=node;
					}
					else
					{
						NODE *n=m_par->m_child;
						while(n->m_next)
						{
							n=n->m_next;
						}
						n->m_next=node;
					}
					m_par=node;
				}

			}
			else if(m_str[i]==']')
			{
				if(m_par)
				{
					m_par=m_par->m_parent;
				}
				bInKey=true;
			}
			else if(m_str[i]=='{')
			{
				if(!bInKey)
				{

					m_cur->type=OBJECT;
					m_par=m_cur;
					bInKey=true;

				}
				else
				{
					NODE *node=new NODE;
					memset(node,0,sizeof(NODE));
					node->type=OBJECTA;
					node->m_parent=m_par;
					m_cur=node;
					if(m_par->m_child==0)
					{
						m_par->m_child=node;
					}
					else
					{
						NODE *n=m_par->m_child;
						while(n->m_next)
						{
							n=n->m_next;
						}
						n->m_next=node;
					}
					m_par=node;
				}
			}
			else if(m_str[i]=='}')
			{
				if(m_par)
				{
					m_par=m_par->m_parent;
				}
				bInKey=true;
			}
			else if(m_str[i]=='\"')
			{
				if(!bInKey)
				{
					i++;
					m_cur->type=STRING;
					while(m_str[i]!='\"' ||(m_str[i]=='\"' && m_str[i-1]=='\\'))
					{
						m_cur->m_strVal+=m_str[i];
						i++;
					}
					while(m_str[i]!=','&& m_str[i]!=']' && m_str[i]!='}')
					{
						i++;
					}
					i--;
				}
				else
				{
					i++;
					NODE *node=new NODE;
					memset(node,0,sizeof(NODE));
					while(m_str[i]!='\"' ||(m_str[i]=='\"' && m_str[i-1]=='\\'))
					{					
						node->m_key+=m_str[i];		
						i++;
					}
					if(m_par && (m_par->type==ARRAY || m_par->type==ARRAYA))
					{
						node->m_strVal=node->m_key;
						node->type=STRINGA;
						while(m_str[i]!=',' && m_str[i]!=']')
						{
							i++;
						}
						i--;
					}
					else
					{
						while(m_str[i]!=':')
						{
							i++;
						}
						i--;
					}

					if(m_root==0)
					{
						m_root=node;
						m_cur=node;
					}
					else
					{
						m_cur=node;
						node->m_parent=m_par;
						if(m_par)
						{
							if(m_par->m_child==0)
							{
								m_par->m_child=node;
							}
							else
							{
								NODE *n=m_par->m_child;
								while(n->m_next)
								{
									n=n->m_next;
								}
								n->m_next=node;
							}
						}
						else
						{
							NODE *n=m_root;
							while(n->m_next)
							{
								n=n->m_next;
							}
							n->m_next=node;
						}

					}
				}
			}
			else if(m_str[i]>='1' && m_str[i]<='9')
			{
				if(m_par && (m_par->type==ARRAY || m_par->type==ARRAYA))
				{
					NODE *node=new NODE;
					memset(node,0,sizeof(NODE));
					node->type=LONGA;
					node->m_parent=m_par;
					m_cur=node;
					if(m_par->m_child==0)
					{
						m_par->m_child=node;
					}
					else
					{
						NODE *n=m_par->m_child;
						while(n->m_next)
						{
							n=n->m_next;
						}
						n->m_next=node;
					}
					if(m_str[i-1]=='-')
					{
						node->m_strVal+=m_str[i-1];
					}
					while(m_str[i]!=','&& m_str[i]!=']')
					{	
						if(!CHECKBLANK(m_str[i]))
						{
							node->m_strVal+=m_str[i];
						}
						node->m_longVal=atoi(node->m_strVal.data());
						i++;
					}
					i--;

				}
				else
				{
					m_cur->type=LONG;
					if(m_str[i-1]=='-')
					{
						m_cur->m_strVal+=m_str[i-1];
					}
					while(m_str[i]!=','&& m_str[i]!=']' && m_str[i]!='}')
					{	
						if(!CHECKBLANK(m_str[i]))
						{
							m_cur->m_strVal+=m_str[i];
						}
						m_cur->m_longVal=atoi(m_cur->m_strVal.data());
						i++;
					}
					i--;

				}

			}
			else if((m_str[i]>='a' && m_str[i]<='z') || (m_str[i]>='A' && m_str[i]<='Z'))
			{
				if(m_par && (m_par->type==ARRAY || m_par->type==ARRAYA))
				{
					NODE *node=new NODE;
					memset(node,0,sizeof(NODE));
					node->m_parent=m_par;
					m_cur=node;
					if(m_par->m_child==0)
					{
						m_par->m_child=node;
					}
					else
					{
						NODE *n=m_par->m_child;
						while(n->m_next)
						{
							n=n->m_next;
						}
						n->m_next=node;
					}
					bool bInQ=false;
					while(bInQ ||(m_str[i]!=','&& m_str[i]!=']'))
					{	
						if(!CHECKBLANK(m_str[i]))
						{
							if(m_str[i]=='\"' || m_str[i]=='\'')
							{
								bInQ=!bInQ;
							}
							node->m_objVal+=m_str[i];
						}
						i++;
					}
					i--;
					if(m_cur->m_objVal=="true"  || m_cur->m_objVal=="false")
					{
						node->type=BOOLA;
					}
					else
					{
						node->type=NAMEDOBGA;
					}
				}
				else
				{
					bool bInQ=false;
					while(1)
					{
						if(m_str[i]=='\"' || m_str[i]=='\'')
						{
							bInQ=!bInQ;
							m_cur->m_objVal+=m_str[i];
						}
						else if(CHECKBLANK(m_str[i]))
						{
							i++;
							continue;
						}
						else if(!bInQ && (m_str[i]==',' || m_str[i]==']' ||m_str[i]=='}'))
						{
							i--;
							break;
						}
						else
						{
							m_cur->m_objVal+=m_str[i];
						}
						i++;
					}
					if(m_cur->m_objVal=="true"  || m_cur->m_objVal=="false")
					{
						m_cur->type=BOOL;
					}
					else
					{
						m_cur->type=NAMEDOBG;
					}
				}
			}

		}
		i++;
	}
	return true;
}
string CJson::GetJsonString()
{
	m_strOutput="";
	output(m_root);
	m_strOutput="{\n"+m_strOutput+"\n}";
	return m_strOutput;
}
void CJson::output(NODE *n)
{
	static int nTab=1;
	if(n)
	{
		if(n->m_parent)
		{
			if(n!=n->m_parent->m_child)
			{
				m_strOutput+=",\n";
			}
		}
		else
		{
			if(n!=m_root)
			{
				m_strOutput+=",\n";
			}
		}
		if(n->type==ARRAY)
		{
			m_strOutput=m_strOutput+GetTab(nTab)+"\""+n->m_key+"\":";
			m_strOutput+="\n"+GetTab(nTab)+"[\n";
			nTab++;
			output(n->m_child);
			nTab--;
			m_strOutput+="\n"+GetTab(nTab)+"]";
		}
		else if(n->type==OBJECT)
		{

			m_strOutput=m_strOutput+GetTab(nTab)+"\""+n->m_key+"\":";
			m_strOutput+="\n"+GetTab(nTab)+"{\n";
			nTab++;
			output(n->m_child);
			nTab--;
			m_strOutput+="\n"+GetTab(nTab)+"}";
		}
		else if(n->type==OBJECTA)
		{

			m_strOutput+=GetTab(nTab)+"{\n";
			nTab++;
			output(n->m_child);
			nTab--;
			m_strOutput+="\n"+GetTab(nTab)+"}";
		}
		else if(n->type==ARRAYA)
		{

			m_strOutput+=GetTab(nTab)+"[\n";
			nTab++;
			output(n->m_child);
			nTab--;
			m_strOutput+="\n"+GetTab(nTab)+"]";
		}
		else if(n->type==STRINGA)
		{
			m_strOutput+=GetTab(nTab)+"\""+n->m_strVal+"\"";
		}
		else if(n->type==LONGA)
		{
			if(atoi(n->m_strVal.data())!=n->m_longVal)
			{
				char str[100]={0};
				itoa(n->m_longVal,str,10);
				n->m_strVal=str;
			}
			m_strOutput+=GetTab(nTab)+n->m_strVal;
		}
		else if(n->type==LONG)
		{
			char str[100]={0};
			itoa(n->m_longVal,str,10);
			n->m_strVal=str;
			m_strOutput=m_strOutput+GetTab(nTab)+"\""+n->m_key+"\":";
			m_strOutput=m_strOutput+n->m_strVal;
		}
		else if(n->type==STRING)
		{
			m_strOutput=m_strOutput+GetTab(nTab)+"\""+n->m_key+"\":";
			m_strOutput=m_strOutput+"\""+n->m_strVal+"\"";
		}
		else if(n->type==BOOL || n->type==NAMEDOBG)
		{
			m_strOutput=m_strOutput+GetTab(nTab)+"\""+n->m_key+"\":";
			m_strOutput=m_strOutput+n->m_objVal;
		}
		else if(n->type==BOOLA || n->type==NAMEDOBGA)
		{
			m_strOutput+=GetTab(nTab)+n->m_objVal;
		}
		output(n->m_next);
	}
}
JsonNode* CJson::Get(char* key)
{
	if(m_root)
	{
		NODE* n=m_root;
		while(n)
		{
			if(n->m_key==key)
			{
				return n;
			}
			n=n->m_next;
		}
	}

	return 0;

}
JsonNode* CJson::Append(TYPE type,char* key,char* sVal,long nVal)
{
	NODE *node=new NODE;
	node->type=type;
	if(type==STRING)
	{
		node->m_key=key;
		node->m_strVal=sVal;
	}
	else if (type==LONG)
	{
		node->m_key=key;
		node->m_longVal=nVal;
	}
	else if(type==OBJECT)
	{
		node->m_key=key;
	}
	else if (type==ARRAY)
	{
		node->m_key=key;
	}
	else if(type==STRINGA)
	{
		node->m_strVal=sVal;
	}
	else if (type==LONGA)
	{
		node->m_longVal=nVal;
	}
	else if(type==OBJECTA)
	{

	}
	else if (type==ARRAYA)
	{

	}
	if(!m_root)
	{
		m_root=node;
	}
	else
	{
		NODE* n=m_root;
		while (n->m_next)
		{
			n=n->m_next;
		}
		n->m_next=node;
	}
	return node;
}
JsonNode* CJson::Insert(NODE* node,int index)
{
	if(!node)
	{
		return 0;
	}
	if(!m_root)
	{
		m_root=node;
		return node;
	}
	NODE* n=m_root;
	for(int i=0;i<index-1;i++)
	{
		if(!n->m_next)
		{
			break;
		}
		n=n->m_next;
	}
	node->m_next=n->m_next;
	n->m_next=node;
	node->m_parent=0;
	return node;
}
JsonNode* CJson::Remove(NODE* node)
{
	if(!node)
	{
		return 0;
	}
	NODE* nNext=node->m_next,*n=m_root;
	if(node==n)
	{
		delete[] m_root;
		m_root=0;
	}
	else
	{
		while(n->m_next!=node)
		{
			n=n->m_next;
		}
		n->m_next=node->m_next;
		delete node;
	}
	return nNext;
}
int main()
{
	FILE *f=fopen("d:\\json.txt","rb");
	fseek(f,0,SEEK_END);
	long n=ftell(f);
	fseek(f,0,SEEK_SET);
	char *b=new char[n+1];
	b[n]=0;
	fread(b,1,n,f);
	fclose(f);
	CJson j;
	j.Load(b);
	//JsonNode* nn=j.Get("a")->Get(2)->Get(0);
	//	JsonNode* nnn=nn->Copy();
	//j.Append(CJson::STRING,"qq","123",0);
	//j.Append(CJson::ARRAY,"qq1",0,0)->Append(CJson::ARRAYA,0,0,0)->Append(CJson::OBJECTA,0,0,0)->Append(CJson::STRING,"2","23",0);
	//nn->Remove(&j);
	//j.Get("a")->Insert(nnn,1);
	//j.Get("a")->Remove(0);
	cout<<j.GetJsonString()<<endl;
	delete[] b;
}


        这个解析类的数据结构是二叉树，左子树是节点的兄弟节点的nextnode，右子树是节点的子节点的firstchild。

      文章不足之处还望大家多多指正。

 

sx1989827
关注
  • 1
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++解析json字符串
02-17
C++作为一款强大的系统编程语言，虽然原生并不支持JSON解析，但有多种库可以用来处理JSON字符串。本主题将深入探讨如何在C++中解析JSON字符串，主要涉及以下几个知识点： 1. **JSON基本结构**：JSON数据由键值对...
c++读取解析Json字符串内容
03-22
JSON是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。本篇文章将深入探讨如何在C++中读取并解析JSON字符串内容。 首先，你需要一个C++库来帮助解析JSON。虽然C++标准库并不直接支持JSON...
c++实现json解析器
qq_65150735的博客
07-22 2321
用c++实现的简易版json解析器
面向C/C++的json解析和合成的第三方库cJson
星羽空间
02-03 1589
我们在项目中经常要用到json格式数据进行通讯，特别是还要做ARM开发板上实现，处理JSON，自己手撕数据处理是件麻烦的事情，不过现在我们有第三方库了！那就是cJson！
2024年JSON解析（C++）_c+，2024年最新讲的真透彻
最新发布
2401_84975937的博客
05-13 497
从上述结果能够看到，我们成功地解析了字符串中的 json 数据。
cjson中取得bool类型的值
yiwang103的博客
11-24 853
在cjson中获取bool类型的值时突然发现不能直接使用item->value来获取bool值，最后解决了，留个纪念。
Json解析bool型数据
weixin_42608318的博客
02-11 1850
在 JSON 中，布尔型数据通常以 "true" 或 "false" 的字符串形式表示。解析时，通常使用编程语言提供的 JSON 解析库，将其转换为对应语言的布尔类型。例如，在 Python 中，可以使用内置的 json 模块进行解析，代码如下： import json json_string = '{"is_enabled": true}' data = json.loads(json_str...
C++ 两行代码实现json与类对象互转
Yaronzz
10-02 5925
背景与需求 之前写C#的时候，解析json字符串一般使用的是开源的类库Newtonsoft.Json，方法十分简洁，比如： class Project { public string Input { get; set; } public string Output { get; set; } } JavaScriptSerializer serializer = new JavaScriptSerializer(); Project test = serializer.Deserialize
C++解析json数据
qq_38616559的博客
08-23 1万+
Json::Value fcgiRetData; ...//获取到fcgiRetData数据 Json::StyledWriter styledWriter; string response = styledWriter.write(fcgiRetData);//将fcgiRetData的json数据格式化 转载：C++解析JSON格式数据 1：封装JSON数据为string std::string DataToJson() { Json::FastWriter writerinfo; J
C++ 操作 （读写）json 文件及jsoncpp的配置
hml111666的博客
10-09 1万+
为什么要用json文件呢？我们最常使用的存储数据的方式有很多，比如利用txt文件存，利用xml存，利用word存，利用Excel存，如果我们要求比较高，还可以使用数据库存。相对于txt，word来说，json格式更加明确，获取重要信息非常方便。相对于xml来说，json格式更加简洁，存储同样的文件，花费的内存更小。相对于Excel来说，json更适合存储字符类文件。Excel相当于比较简单的数据库了。相对于数据库来说，json更加方便，数据库我们还需要做一些设置，安装一些软件。
C++解析json/socket通讯
01-12
以nlohmann/json为例，这个库提供了简洁的API，使得JSON解析变得简单： ```cpp #include <nlohmann/json.hpp> using json = nlohmann::json; // 解析JSON字符串 std::string jsonString = R"({"name": "John", ...
json字符串转换c++类对象
05-09
json 字符串转成c++类对象,json 字符串转成c++类对象
c/c++ 解析JSON数据
05-05
用C语言解析和组装JSON数据（string或从文件读取）： ，并且能取某个item值 。 我在vs2010上运行成功，附件为整个工程 。 （注：如果工程有编译上的error之类的，像fopen、fprintf： 可以修改： 选项Project | Configuration Properties | C/C++ | Preprocessor | Preprocessor Definitions 添加_CRT_SECURE_NO_DEPRECATE和_SCL_SECURE_NO_DEPRECATE ）
C++解析 json 示例
12-19
文档是自己整理，讲述如何使用C++用 JsonCpp 解析json
C++解析Json数据
04-04
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。本篇文章将深入探讨如何在Visual Studio 2017环境下，使用C++来解析包含Unicode编码的JSON数据。 ...
cjson数据格式使用详解
nihaocaofei的博客
10-06 1万+
一.JSON格式简述 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写，同时也易于机器解析和生成。它基于JavaScript（Standard ECMA-262 3rd Edition - December 1999）的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, J...
开源项目cJSON具体实现1（NULL 与 Boolean的解析）
it_is_me_a的博客
09-09 1386
先给项目网站cJSON download 参考文章：知乎 cJSON是什么？An ultra-lightweight, portable, single-file, simple-as-can-be ANSI-C compliant JSON parser.说白了就是一个超轻量级的json解析器。 那么问题又来了，什么是json？ 更多详细信息点击：json.cn 说简单点 json 采用完全独立...
JSON传递bool类型数据的处理方式
热门推荐
来老师的专栏
05-03 4万+
ajax中使用json传递数据时，其它数据类型都不是问题，但是如果服务器端生成的JSON中有bool类型的数据时，到客户端解析时出现了小小的问题，总结如下： 服务器返回的JSON为： {"TypeID":[1037],"Title":"河北软件职业技术学院","Intro":"","IsLink":"false","LinkUrl":"http://www.hbsi.edu.cn"
C++编写Json数据解析的代码
05-10
以下是一个简单的C++ JSON解析器的示例代码： ```c++ #include <iostream> #include <string> #include <vector> #include <map> using namespace std; enum JsonValueType { JSON_NULL, JSON_BOOLEAN, JSON_NUMBER, JSON_STRING, JSON_ARRAY, JSON_OBJECT }; class JsonValue { public: JsonValueType type; JsonValue() : type(JSON_NULL) {} virtual ~JsonValue() {} virtual void print(int depth = 0) const = 0; }; class JsonNull : public JsonValue { public: JsonNull() { type = JSON_NULL; } void print(int depth = 0) const override { cout << "null"; } }; class JsonBoolean : public JsonValue { public: bool value; JsonBoolean(bool v) : value(v) { type = JSON_BOOLEAN; } void print(int depth = 0) const override { cout << (value ? "true" : "false"); } }; class JsonNumber : public JsonValue { public: double value; JsonNumber(double v) : value(v) { type = JSON_NUMBER; } void print(int depth = 0) const override { cout << value; } }; class JsonString : public JsonValue { public: string value; JsonString(const string &v) : value(v) { type = JSON_STRING; } void print(int depth = 0) const override { cout << "\"" << value << "\""; } }; class JsonArray : public JsonValue { public: vector<JsonValue *> elements; JsonArray() { type = JSON_ARRAY; } ~JsonArray() { for (auto &element : elements) { delete element; } } void print(int depth = 0) const override { cout << "[" << endl; for (auto &element : elements) { for (int i = 0; i < depth + 1; i++) { cout << " "; } element->print(depth + 1); if (element != elements.back()) { cout << ","; } cout << endl; } for (int i = 0; i < depth; i++) { cout << " "; } cout << "]"; } }; class JsonObject : public JsonValue { public: map<string, JsonValue *> members; JsonObject() { type = JSON_OBJECT; } ~JsonObject() { for (auto &member : members) { delete member.second; } } void print(int depth = 0) const override { cout << "{" << endl; for (auto &member : members) { for (int i = 0; i < depth + 1; i++) { cout << " "; } cout << "\"" << member.first << "\": "; member.second->print(depth + 1); if (&member != &members.back()) { cout << ","; } cout << endl; } for (int i = 0; i < depth; i++) { cout << " "; } cout << "}"; } }; class JsonParser { public: string json; JsonParser(const string &json) : json(json) {} JsonValue *parse() { skipWhitespace(); if (json.empty()) { return nullptr; } char c = json[0]; switch (c) { case '{': return parseObject(); case '[': return parseArray(); case '\"': return parseString(); case 't': { string expect = "true"; if (json.substr(0, expect.size()) == expect) { json = json.substr(expect.size()); return new JsonBoolean(true); } break; } case 'f': { string expect = "false"; if (json.substr(0, expect.size()) == expect) { json = json.substr(expect.size()); return new JsonBoolean(false); } break; } case 'n': { string expect = "null"; if (json.substr(0, expect.size()) == expect) { json = json.substr(expect.size()); return new JsonNull(); } break; } default: { if (c == '-' || (c >= '0' && c <= '9')) { return parseNumber(); } break; } } throw runtime_error("Parse error"); } private: void skipWhitespace() { while (!json.empty() && isspace(json[0])) { json = json.substr(1); } } JsonValue *parseObject() { JsonObject *object = new JsonObject(); json = json.substr(1); skipWhitespace(); while (json[0] != '}') { if (json[0] != '\"') { throw runtime_error("Parse error: Expected \""); } string key = parseString()->value; skipWhitespace(); if (json[0] != ':') { throw runtime_error("Parse error: Expected :"); } json = json.substr(1); skipWhitespace(); JsonValue *value = parse(); object->members[key] = value; skipWhitespace(); if (json[0] == ',') { json = json.substr(1); skipWhitespace(); } else if (json[0] != '}') { throw runtime_error("Parse error: Expected , or }"); } } json = json.substr(1); return object; } JsonValue *parseArray() { JsonArray *array = new JsonArray(); json = json.substr(1); skipWhitespace(); while (json[0] != ']') { JsonValue *value = parse(); array->elements.push_back(value); skipWhitespace(); if (json[0] == ',') { json = json.substr(1); skipWhitespace(); } else if (json[0] != ']') { throw runtime_error("Parse error: Expected , or ]"); } } json = json.substr(1); return array; } JsonValue *parseString() { string value; json = json.substr(1); while (true) { if (json.empty()) { throw runtime_error("Parse error: Expected \""); } char c = json[0]; json = json.substr(1); if (c == '\"') { return new JsonString(value); } else if (c == '\\') { if (json.empty()) { throw runtime_error("Parse error: Expected escaped character"); } char escape = json[0]; json = json.substr(1); switch (escape) { case '\"': case '\\': case '/': value += escape; break; case 'b': value += '\b'; break; case 'f': value += '\f'; break; case 'n': value += '\n'; break; case 'r': value += '\r'; break; case 't': value += '\t'; break; case 'u': { if (json.size() < 4) { throw runtime_error("Parse error: Expected four hexadecimal digits"); } string hex = json.substr(0, 4); json = json.substr(4); for (int i = 0; i < hex.size(); i++) { if (!isxdigit(hex[i])) { throw runtime_error("Parse error: Expected hexadecimal digit"); } } int codepoint = stoi(hex, nullptr, 16); if (codepoint < 0 || codepoint > 0x10ffff || (codepoint >= 0xd800 && codepoint <= 0xdfff)) { throw runtime_error("Parse error: Invalid Unicode code point"); } if (codepoint < 0x80) { value += static_cast<char>(codepoint); } else if (codepoint < 0x800) { value += static_cast<char>((codepoint >> 6) | 0xc0); value += static_cast<char>((codepoint & 0x3f) | 0x80); } else if (codepoint < 0x10000) { value += static_cast<char>((codepoint >> 12) | 0xe0); value += static_cast<char>(((codepoint >> 6) & 0x3f) | 0x80); value += static_cast<char>((codepoint & 0x3f) | 0x80); } else { value += static_cast<char>((codepoint >> 18) | 0xf0); value += static_cast<char>(((codepoint >> 12) & 0x3f) | 0x80); value += static_cast<char>(((codepoint >> 6) & 0x3f) | 0x80); value += static_cast<char>((codepoint & 0x3f) | 0x80); } break; } default: throw runtime_error("Parse error: Invalid escape character"); } } else { value += c; } } } JsonValue *parseNumber() { bool negative = false; if (json[0] == '-') { negative = true; json = json.substr(1); } if (json.empty() || !isdigit(json[0])) { throw runtime_error("Parse error: Expected digit"); } double value = 0; while (!json.empty() && isdigit(json[0])) { value = value * 10 + (json[0] - '0'); json = json.substr(1); } if (!json.empty() && json[0] == '.') { json = json.substr(1); double fraction = 0.1; while (!json.empty() && isdigit(json[0])) { value += fraction * (json[0] - '0'); fraction *= 0.1; json = json.substr(1); } } if (!json.empty() && (json[0] == 'e' || json[0] == 'E')) { json = json.substr(1); bool exponent_negative = false; if (json[0] == '-') { exponent_negative = true; json = json.substr(1); } else if (json[0] == '+') { json = json.substr(1); } if (json.empty() || !isdigit(json[0])) { throw runtime_error("Parse error: Expected digit"); } int exponent = 0; while (!json.empty() && isdigit(json[0])) { exponent = exponent * 10 + (json[0] - '0'); json = json.substr(1); } if (exponent_negative) { exponent = -exponent; } value *= pow(10, exponent); } if (negative) { value = -value; } return new JsonNumber(value); } }; int main() { string json = "{\"name\": \"John Smith\", \"age\": 42, \"isMale\": true, \"children\": [{\"name\": \"Alice\", \"age\": 10}, {\"name\": \"Bob\", \"age\": 8}]}"; JsonParser parser(json); JsonValue *value = parser.parse(); value->print(); delete value; return 0; } ``` 这个解析器支持JSON中的null、布尔值、数值、字符串、数组和对象等各种类型，可以递归地打印JSON对象。您可以通过修改类的定义来实现自己的行为。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值