c++编写json解析类

最新推荐文章于 2025-06-23 14:43:13 发布
最新推荐文章于 2025-06-23 14:43:13 发布
阅读量3.6k 收藏 15
点赞数 1
CC 4.0 BY-SA版权
分类专栏： c++ 文章标签： c++ json string output delete insert
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/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。

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

 

JSON for Modern C++ 解析 JSON（五）
风一流世的专栏
04-01 1335
JSON for Modern C++（简称 nlohmann/json）是一个以现代 C++ 风格编写的 JSON 库，旨在提供简单、易用、且符合现代 C++ 编程习惯的 API。其设计理念围绕 类型安全 和 零依赖性，并且支持 C++11 及以上版本。该库采用了一些 C++11 引入的功能，如智能指针、范围for循环、auto 关键字、lambda 表达式等，使得代码更加简洁、可读且类型安全。
C++解析JSON数据
11-17
VC++要使用JSON来解析数据，这个源码工程进行编译链接就可以得到一个静态链接库json.lib，只需要将这个lib文件拷贝到你的工程目录下，并将\include\json复制到工程目录下，然后将这些头文件加到工程中去就可以了。 #pragma comment(lib, "json_mtd.lib") #include "json/json.h"
json的c++类
04-08
json的组包与解包c++实现类，jsoncpp，实现简单容易集成。
简述C++ nlohmann/json 库
最新发布
ikkkkkkkl的博客
06-23 890
JSON(JavaScrip Object Notation)是一种轻量级、跨语言的数据交换格式。它基于 ECMAScript 子集，以独立于编程语言的文本格式存储和表示数据，简洁清晰的结构使其成为理想的数据交换语言，易读、易写且便于机器解析生成，能提升网络传输效率。Json中主要有两种数据格式：Json数组和Json对象，并且这两种格式可以交叉嵌套使用。Json数组使用 [] 表示，[]里边是元素，元素和元素之间使用逗号间隔。
一个简单易用的 c++ json 类
12-06
一个简单易用的 c++ json 类，单个头文件，直接放到项目中即可。不再需要引用第三方大库了。文件极小但功能不弱，完全能使用一般的场合。可以跨平台使用，C++11标准即可。
c++解析json类库
03-20
c++解析json开源类，适合广大学习json解析的学员，0.5版本
JSON解析库,C/C++实现，很强大
06-12
C/C++解析JSON Exjson**是一款高性能的基于Flex & Bison的 **JSON** 解析器，**Xserver**引擎自带 **Exjson** 解析器，其他需要使用的只需要引入几个头文件和源文件即可
C++解析json字符串
02-17
C++作为一款强大的系统编程语言，虽然原生并不支持JSON解析，但有多种库可以用来处理JSON字符串。本主题将深入探讨如何在C++中解析JSON字符串，主要涉及以下几个知识点： 1. **JSON基本结构**：JSON数据由键值对...
易懂的C++语言Json解析器.zip
11-28
JSON解析器的编写需要深入理解JSON格式的语法规则，包括但不限于对象(object)、数组(array)、字符串(string)、数字(number)、布尔值(boolean)以及null类型。一个优秀的解析器会提供清晰的API接口，使得用户无需关心...
c++读取解析Json字符串内容
03-22
JSON是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。本篇文章将深入探讨如何在C++中读取并解析JSON字符串内容。 首先，你需要一个C++库来帮助解析JSON。虽然C++标准库并不直接支持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++ JSON读写
08-08
经常会遇到需要将数据保存成JSON格式或者需要从已有的JSON格式中读取信息的情况，首先需要添加一个自定义的JSON库，然后用相应的函数进行操作。
C++读写json文件
12-09
https://github.com/nlohmann/json 最好用的C++读写json库
C++简单使用Jsoncpp_读写Json文件
07-27
C++简单使用Jsoncpp_读写Json文件, 亲测可用， 主要备份一下，以便以后使用
xml c++解析类
03-28
非常棒的xml解析类，带使用示例类，代码简洁，使用相当方便
C++————解析“类与对象”
Akun_H的博客
02-24 1021
类的六个默认成员 一个类中如果没有成员，我们称之为“空类”。 但空类中并不是真的什么都没有，任何一个类在我们不写的情况下都会自动生成六个默认成员函数 #mermaid-svg-jNFeiswL9bnDM47W {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-jNFeiswL9bnDM47W .error-icon{fill:#552222;}#mermaid-svg-jNF
C++实现JSon文件解析类
qq_32579021的博客
12-11 1419
不是很清楚
C++中Json解析技术深入解析
jsoncpp是一个用C++编写的开源JSON解析器和生成器库，它允许C++程序以流的方式读写JSON数据。该库不依赖于任何外部库，能够灵活地集成到各种项目中，从大型企业级应用到小型的脚本程序。jsoncpp提供了对JSON数据的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值