ini 文件读写

最新推荐文章于 2022-07-06 10:03:21 发布
最新推荐文章于 2022-07-06 10:03:21 发布
阅读量741 收藏
点赞数
分类专栏： c/c++ 文章标签： ini null fp file delete struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kusey/article/details/6588445
版权

        自己写的一个 ini 文件读写的 dll，c 语言写的，适合于小型 ini 文件的操作。做了简单的测试，估计还有 bug，如果想用的话最好自己先进行测试、修改，然后再使用。以下是代码。

头文件：

#ifndef __ini_h__
#define __ini_h__

#ifdef	DLLEXPORT
#define	DLLAPI	__declspec(dllexport)
#else
#define	DLLAPI	__declspec(dllimport)
#endif

#ifdef	__cplusplus
extern "C" {
#endif

	int		DLLAPI	ini_create_file		( const char *filename );
	int		DLLAPI	ini_open_file		( const char *filename );
	int		DLLAPI	ini_add_section		( const char *sectionname );
	int		DLLAPI	ini_add_key			( const char *sectionname, const char *keyname, const char *keyvalue );
	int		DLLAPI	ini_modify_section	( const char *sectionname, const char *section_newname );
	int		DLLAPI	ini_modify_key_name	( const char *sectionname, const char *keyname, const char *key_newname );
	int		DLLAPI	ini_modify_key_value( const char *sectionname, const char *keyname, const char *key_newvalue );
	int		DLLAPI	ini_delete_section	( const char *sectionname );
	int		DLLAPI	ini_delete_key		( const char *sectionname, const char *keyname );
	int		DLLAPI	ini_get_sections	( char *sections, unsigned int maxlen );
	int		DLLAPI	ini_get_keys		( const char *sectionname, char *keys, unsigned int maxlen );
	int		DLLAPI	ini_get_key_value	( const char *sectionname, const char *keyname, char *value, unsigned int maxlen );
	int		DLLAPI	ini_save_file		();
	void	DLLAPI	ini_clear_content	();
	void	DLLAPI	ini_free_file		();

#ifdef	__cplusplus
}
#endif

#endif // __ini_h__


源文件：

#define DLLEXPORT
#include "ini.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#pragma warning( disable:4996 )

//

//
//	Key
//
typedef struct _ini_key {
	char				*_name;
	char				*_value;
	struct _ini_key		*_next;
} INIKEY, *PINIKEY;

//
//	Section
//
typedef struct _ini_section {
	char				*_name;
	PINIKEY				_key;
	struct _ini_section	*_next;
} INISECTION, *PINISECTION;

//
//	File
//
typedef struct _ini_file {
	char				*_name;
	PINISECTION			_section;
} INIFILE, *PINIFILE;


PINIFILE	g_inifile	= NULL;

//

void ini_parse_content( const char *buf )
{
	static char section_name[256]	= { 0 };
	char		name[1024]			= { 0 };
	char		value[1024]			= { 0 };
	int			len					= 0;
	int			i					= 0;

	if( NULL == buf || 3 > strlen(buf) )
		return;

	// section
	if( '[' == *buf ) {
		strcpy_s( name, 1024, buf + 1 );
		len = strlen( name );
		for( i = 0; i < len, ']' != name[i]; i++ );
		if( i == len )
			return;
		name[i] = '\0';
		ini_add_section( name );

		memset( section_name, 0, sizeof(char) * 256 );
		strcpy_s( section_name, 256, name );
	}
	// key
	else {
		// name
		strcpy_s( name, 1024, buf );
		len = strlen( name );
		for( i = 0; i < len, '=' != name[i]; i++ );
		if( i == len )
			return;
		name[i] = '\0';

		// value
		len = strlen( buf );
		for( i = 0; i < len, '=' != buf[i]; i++ );
		if( i == len )
			return;
		strcpy_s( value, 1024, buf + i + 1 );

		ini_add_key( section_name, name, value );
	}
}

//

int DLLAPI ini_create_file( const char *filename )
{
	if( NULL == filename )
		return 0;

	if( NULL != g_inifile )
		ini_free_file();

	// create a new "inifile" and set its name
	g_inifile = (PINIFILE)malloc( sizeof(INIFILE) );
	g_inifile->_name = (char*)malloc( sizeof(char) * (strlen(filename) + 1) );
	strcpy( g_inifile->_name, filename );
	g_inifile->_section = NULL;

	return 1;
}

int DLLAPI ini_open_file( const char *filename )
{
	FILE		*fp			= NULL;
	PINISECTION	section		= NULL;
	PINIKEY		key			= NULL;
	char		buf[1024]	= { 0 };

	if( NULL == filename )
		return 0;

	if( NULL != g_inifile ) {
		ini_save_file();
		ini_free_file();
	}

	fp = fopen( filename, "rt" );
	if( NULL == fp )
		return 0;

	// create a new "inifile" and set its name
	g_inifile = (PINIFILE)malloc( sizeof(INIFILE) );
	g_inifile->_name = (char*)malloc( sizeof(char) * (strlen(filename) + 1) );
	strcpy( g_inifile->_name, filename );
	g_inifile->_section = NULL;

	while( fgets(buf, 1024, fp) ) {
		ini_parse_content( buf );
		memset( buf, 0, sizeof(char) * 1024 );
	}

	fclose( fp );
	return 1;
}

int DLLAPI ini_add_section( const char *sectionname )
{
	PINISECTION	section		= NULL;
	PINISECTION	sectionnew	= NULL;

	if( NULL == g_inifile || NULL == sectionname )
		return 0;

	// create a new section
	sectionnew = (PINISECTION)malloc( sizeof(INISECTION) );
	sectionnew->_name = (char*)malloc( sizeof(char) * (strlen(sectionname) + 1) );
	strcpy( sectionnew->_name, sectionname );
	sectionnew->_key = NULL;
	sectionnew->_next = NULL;

	// the first section ?
	if( NULL == g_inifile->_section )
		g_inifile->_section = sectionnew;
	else {
		section = g_inifile->_section;
		while( NULL != section->_next ) {
			if( 0 == strcmp(section->_name, sectionname) )
				break;
			section = section->_next;
		}

		// if the section has been existed, free the new section and return zero
		if( NULL != section->_next || 0 == strcmp(section->_name, sectionname) ) {
			free( sectionnew->_name );
			free( sectionnew );
			return 0;
		}

		// add the new section to the end
		section->_next = sectionnew;
	}

	return 1;
}

int DLLAPI ini_add_key( const char *sectionname, const char *keyname, const char *keyvalue )
{
	PINIKEY		key		= NULL;
	PINIKEY		keynew	= NULL;
	PINISECTION	section	= NULL;

	if( NULL == g_inifile || NULL == sectionname || NULL == keyname )
		return 0;

	// find the section
	section = g_inifile->_section;
	while( NULL != section ) {
		if( 0 == strcmp(section->_name, sectionname) )
			break;
		section = section->_next;
	}

	if( NULL == section )
		return 0;

	// create a new key
	keynew = (PINIKEY)malloc( sizeof(INIKEY) );
	keynew->_name = (char*)malloc( sizeof(char) * (strlen(keyname) + 1) );
	strcpy( keynew->_name, keyname );
	if( NULL == keyvalue )
		keynew->_value = NULL;
	else {
		keynew->_value = (char*)malloc( sizeof(char) * (strlen(keyvalue) + 1) );
		strcpy( keynew->_value, keyvalue );
	}
	keynew->_next = NULL;

	// the first key ?
	if( NULL == section->_key )
		section->_key = keynew;
	else {
		key = section->_key;
		while( NULL != key->_next ) {
			if( 0 == strcmp(key->_name, keyname) )
				break;
			key = key->_next;
		}

		// the key has been existed ?
		if( NULL != key->_next || 0 == strcmp(key->_name, keyname) ) {
			free( keynew->_name );
			free( keynew->_value );
			free( keynew );
			return 0;
		}

		// add the key to the end
		key->_next = keynew;
	}

	return 1;
}

int DLLAPI ini_modify_section( const char *sectionname, const char *section_newname )
{
	PINISECTION section = NULL;

	if( NULL == g_inifile || NULL == sectionname || NULL == section_newname )
		return 0;

	if( 0 == strcmp(sectionname, section_newname) )
		return 1;

	// find the section
	section = g_inifile->_section;
	while( NULL != section ) {
		if( 0 == strcmp(section->_name, sectionname) )
			break;
		section = section->_next;
	}

	if( NULL == section )
		return 0;
	
	// modify the section's name
	free( section->_name );
	section->_name = (char*)malloc( sizeof(char) * (strlen(section_newname) + 1) );
	strcpy( section->_name, section_newname );
	return 1;
}

int DLLAPI ini_modify_key_name( const char *sectionname, const char *keyname, const char *key_newname )
{
	PINISECTION	section	= NULL;
	PINIKEY		key		= NULL;

	if( NULL == g_inifile || NULL == sectionname || NULL == keyname || NULL == key_newname )
		return 0;

	// find the section
	section = g_inifile->_section;
	while( NULL != section ) {
		if( 0 == strcmp(section->_name, sectionname) )
			break;
		section = section->_next;
	}

	if( NULL == section )
		return 0;

	// find the key
	key = section->_key;
	while( NULL != key ) {
		if( 0 == strcmp(key->_name, keyname) )
			break;
		key = key->_next;
	}

	if( NULL == key )
		return 0;

	// modify the key's name
	free( key->_name );
	key->_name = (char*)malloc( sizeof(char) * (strlen(key_newname) + 1) );
	strcpy( key->_name, key_newname );

	return 1;
}

int DLLAPI ini_modify_key_value( const char *sectionname, const char *keyname, const char *key_newvalue )
{
	PINISECTION section	= NULL;
	PINIKEY		key		= NULL;

	if( NULL == g_inifile || NULL == sectionname || NULL == keyname )
		return 0;

	// find the section
	section = g_inifile->_section;
	while( NULL != section ) {
		if( 0 == strcmp(section->_name, sectionname) )
			break;
		section = section->_next;
	}

	if( NULL == section )
		return 0;

	// find the key
	key = section->_key;
	while( NULL != key ) {
		if( 0 == strcmp(key->_name, keyname) )
			break;
		key = key->_next;
	}

	if( NULL == key )
		return 0;

	// if the key's value equals to key_newvalue, return
	if( 0 == strcmp(key->_value, key_newvalue) )
		return 1;

	// modify the key's value
	free( key->_value );
	key->_value = NULL;
	if( NULL != key_newvalue ) {
		key->_value = (char*)malloc( sizeof(char) * (strlen(key_newvalue) + 1) );
		strcpy( key->_value, key_newvalue );
	}

	return 1;
}

int DLLAPI ini_delete_section( const char *sectionname )
{
	PINISECTION	section_cur	= NULL;
	PINISECTION	section_prv	= NULL;
	PINIKEY		key			= NULL;

	if( NULL == g_inifile || NULL == sectionname )
		return 0;

	// find the section to be deleted
	section_cur = g_inifile->_section;
	while( NULL != section_cur && 0 != strcmp(section_cur->_name, sectionname) ) {
		section_prv = section_cur;
		section_cur = section_cur->_next;
	}

	if( NULL == section_cur )
		return 0;

	// delete the section from the link
	if( NULL == section_prv )
		g_inifile->_section = section_cur->_next;
	else
		section_prv->_next = section_cur->_next;

	// free the section's keys
	while( NULL != section_cur->_key ) {
		key = section_cur->_key->_next;
		free( section_cur->_key->_name );
		free( section_cur->_key->_value );
		free( section_cur->_key );
		section_cur->_key = key;
	}

	// free the section's name
	free( section_cur->_name );

	// free the section
	free( section_cur );

	return 1;
}

int DLLAPI ini_delete_key( const char *sectionname, const char *keyname )
{
	PINISECTION	section	= NULL;
	PINIKEY		key_cur	= NULL;
	PINIKEY		key_prv	= NULL;

	if( NULL == g_inifile || NULL == sectionname || NULL == keyname )
		return 0;

	// find the section
	section = g_inifile->_section;
	while( NULL != section ) {
		section = g_inifile->_section;
		if( 0 == strcmp(section->_name, sectionname) )
			break;
		section = section->_next;
	}

	if( NULL == section )
		return 0;

	// find the key to be deleted
	key_cur = section->_key;
	while( NULL != key_cur && 0 != strcmp(key_cur->_name, keyname) ) {
		key_prv = key_cur;
		key_cur = key_cur->_next;
	}

	if( NULL == key_cur )
		return 0;

	// delete the key from the link
	if( NULL == key_prv )
		section->_key = key_cur->_next;
	else
		key_prv->_next = key_cur->_next;

	// free the key
	free( key_cur->_name );
	free( key_cur->_value );
	free( key_cur );

	return 1;
}

int DLLAPI ini_get_sections( char *sections, unsigned int maxlen )
{
	int			rst		= 0;
	PINISECTION	section = NULL;

	if( NULL == g_inifile || NULL == g_inifile->_section || NULL == sections || 0 == maxlen )
		return 0;

	// the first section's name
	memset( sections, 0, sizeof(char) * maxlen );
	strcpy_s( sections, maxlen, g_inifile->_section->_name );
	rst++;

	section = g_inifile->_section->_next;
	while( NULL != section ) {
		strcat_s( sections, maxlen, "|" );
		strcat_s( sections, maxlen, section->_name );
		section = section->_next;
		rst++;
	}

	return rst;
}

int DLLAPI ini_get_keys( const char *sectionname, char *keys, unsigned int maxlen )
{
	int			rst		= 0;
	PINISECTION	section	= NULL;
	PINIKEY		key		= NULL;

	if( NULL == g_inifile || NULL == sectionname || NULL == keys || 0 == maxlen )
		return 0;

	// find the section
	section = g_inifile->_section;
	while( NULL != section ) {
		if( 0 == strcmp(section->_name, sectionname) )
			break;
		section = section->_next;
	}

	if( NULL == section )
		return 0;

	if( NULL == section->_key )
		return 0;

	// the first key's name
	strcpy_s( keys, maxlen, section->_key->_name );
	rst++;

	key = section->_key->_next;
	while( NULL != key ) {
		strcat_s( keys, maxlen, "|" );
		strcat_s( keys, maxlen, key->_name );
		key = key->_next;
		rst++;
	}

	return rst;
}

int DLLAPI ini_get_key_value( const char *sectionname, const char *keyname, char *value, unsigned int maxlen )
{
	PINISECTION	section	= NULL;
	PINIKEY		key		= NULL;

	if( NULL == g_inifile || NULL == sectionname || NULL == keyname || NULL == value || 0 == maxlen )
		return 0;

	// find the section
	section = g_inifile->_section;
	while( NULL != section ) {
		if( 0 == strcmp(section->_name, sectionname) )
			break;
		section = section->_next;
	}

	if( NULL == section )
		return 0;

	// find the key
	key = section->_key;
	while( NULL != key ) {
		if( 0 == strcmp(key->_name, keyname) )
			break;
		key = key->_next;
	}

	if( NULL == key )
		return 0;

	// get the key's value
	if( NULL == key->_value )
		strcpy( value, "" );
	else
		strcpy_s( value, maxlen, key->_value );

	return 1;
}

int DLLAPI ini_save_file()
{
	FILE		*fp		= NULL;
	PINISECTION	section	= NULL;
	PINIKEY		key		= NULL;

	if( NULL == g_inifile )
		return 0;

	fp = fopen( g_inifile->_name, "w+t" );
	if( NULL == fp )
		return 0;

	section = g_inifile->_section;
	while( NULL != section ) {
		fwrite( "[", sizeof(char), strlen("["), fp );
		fwrite( section->_name, sizeof(char), strlen(section->_name), fp );
		fwrite( "]\r\n", sizeof(char), strlen("]\r\n"), fp );
		fflush( fp );

		key = section->_key;
		while( NULL != key ) {
			fwrite( key->_name, sizeof(char), strlen(key->_name), fp );
			fwrite( "=", sizeof(char), strlen("="), fp );
			if( NULL != key->_value )
				fwrite( key->_value, sizeof(char), strlen(key->_value), fp );
			fwrite( "\r\n", sizeof(char), strlen("\r\n"), fp );
			fflush( fp );
			key = key->_next;
		}

		fwrite( "\r\n", sizeof(char), strlen("\r\n"), fp );
		fflush( fp );
		section = section->_next;
	}

	fclose( fp );
	return 1;
}

void DLLAPI ini_clear_content()
{
	PINISECTION	section	= NULL;
	PINIKEY		key		= NULL;

	if( NULL == g_inifile )
		return;

	section = g_inifile->_section;
	while( NULL != section ) {
		// get the next section
		section = section->_next;

		// free the section's name
		free( g_inifile->_section->_name );

		// free the section's keys
		key = g_inifile->_section->_key;
		while( NULL != key ) {
			key = key->_next;
			free( g_inifile->_section->_key->_name );
			free( g_inifile->_section->_key->_value );
			free( g_inifile->_section->_key );
			g_inifile->_section->_key = key;
		}

		// free the section
		free( g_inifile->_section );
		g_inifile->_section = section;
	}

	g_inifile->_section = NULL;
}

void DLLAPI ini_free_file()
{
	if( NULL == g_inifile )
		return;

	if( NULL != g_inifile->_section )
		ini_clear_content();

	// free the file's name
	free( g_inifile->_name );

	// free the file
	free( g_inifile );
	g_inifile = NULL;
}


<完>

Qt应用软件【文件篇】INI文件读写
小鱼酱的博客
02-24 657
Qt操作INI文件
c语言向ini文件写入数据,C语言实现 读取写入ini文件实现(转)
weixin_39767121的博客
05-25 367
#include #include/** 函数名： GetIniKeyString* 入口参数： title* 配置文件中一组数据的标识* key* 这组数据中要读出的值的标识* filename* ...
Linux C 读取ini格式（key&value）配置文件
elikang的博客
12-28 5225
在Windows下可以用GetPrivateProfileString或GetPrivateProfileInt方便读取.ini配置文件内容， 但是在Linux平台上就一筹莫展了。 为了解决该问题，打算用C来读取.ini，就可以不受平台的限制了。 配置文件Config.ini [test] name=elikang age=12 读取配置文件的程序： #include &lt;stdio.h&g...
linux c语言 ini文件,C语言读取ini文件
weixin_36124208的博客
04-28 812
这里就分享一下C语言读取ini文件的代码如下:/*ini.h*/#ifndef INI_H#define INI_H#include #include int GetIniKeyString(char *title,char *key,char *filename,char *buf);int PutIniKeyString(char *title,char *key,char *val,char...
ini文件读写类
积累点滴，保持自我
01-15 933
常用的一个ini文件读写类 IniFile.h： // IniFile.h #ifndef __INIFILE_H__ #define __INIFILE_H__ #pragma once class AFX_CLASS_EXPORT CIniFile { public: CIniFile(); CIniFile(LPCTSTR szFileName...
C# ini 文件读写
刘欢的博客
06-15 343
/// <summary> /// 得到权重配置信息 config.ini /// </summary> /// <returns></returns> public string[] getWeightIni() { try { string[] allTrain = new string[] ...
C# 读写Ini文件
爱技术、爱生活、爱健康
07-06 490
ini文件在Win95以前比较盛行，之后由于出册表等技术的出现，ini技术主键退居二线，不过对于一些小项目，读写ini文件还是很适用的。 Windows API提供了读写配置文件的操作，在C#程序中只要导入相应的API即可。例如GetPrivateProfileString（）方法，在MSDN查得原型如下： 由于C#和C++数据类型不同，在导入win32 API时需要做相应的转换，并且要导入相关的类。如下所示： 同理导入另一个函数 在main函数测试如下：...
深入Qt--ini文件读写
Venus的博客
08-02 1391
深入Qt–ini文件读写 INI文件是Initialization File的缩写，即初始化文件，主要用来保存程序经常用到的一些配置参数。在Qt中可以使用QSetting类来实现ini文件的读取和写入。 1.ini文件格式 ini文件主要有节(section)、键(key)、键值（value）部分组成。 节 (section) 用方括号括起来，单独占一行，例如： [section] 键(key)又名属性(property)，单独占一行用等号连接键名和键值，例如： name=value 2.对Qt QSett
c++ builder ini文件读写
weixin_39926429的博客
01-24 630
#include <inifiles.hpp> #include <iostream> using namespace std; int _tmain(int argc, _TCHAR* argv[]) { //TIniFile *pIniFile = new TIniFile(ExtractFilePath(Application->ExeName)+"myTest.ini");// TIniFile *pIni = new TIniFile("c:\\my...
C#ini文件读写操作
weixin_18649821372的博客
04-30 445
C#ini文件读写帮助类 背景 在很多软件实施过程中，当我们项目上线后，难免会有一些配方的切换或者其他的操作，且很多工业的电脑是没有联网的，于是就苦了我们这帮搞工业上位机软件的，我们只是幼儿园刚毕业十几年的孩子，为什么我们要承受这么多。当然上有政策，下有对策，就像我们数据库中的存储过程一样，当我们不想在软件的代码进行修改更新的时候，这个时候引入配置文件的重要性就凸显出来了，就像我们改动数据库的存储过程类似。 实现 需要引入 using System.Runtime.InteropServices; 新建一
不用API的ini文件读写.rar_.ini文件读写_ini_ini 文件_ini文件_ini读写
09-14
在提供的压缩包中，`www.pudn.com.txt`可能是介绍相关代码或示例的文本文件，而`ini文件读写库`可能包含了实现ini文件读写的源代码。通过阅读和理解这些代码，你可以学习如何在实际项目中实现ini文件的读写功能，...
带密码INI文件读写_ini文件_especiallyvsy_加密_读写ini文件_文件读取_
09-29
在标题中提到的“带密码INI文件读写”，是指在进行ini文件的读写操作时，引入了一种加密方法，以保护文件中的敏感信息。这通常是通过在读取或写入文件前，对数据进行加密和解密来实现的。加密过程可以使用各种加密...
ini文件读写
09-03
C#语言提供了丰富的类库来支持ini文件的处理，使得开发者能够方便地进行ini文件的读写操作。 1. **IniFile类** 在C#中，通常我们会自定义一个IniFile类来封装ini文件的操作。这个类通常包含以下方法： - `...
ini文件读写_ini文件读写_C#_读写ini文件_
09-29
在本篇文章中，我们将深入探讨如何使用C#实现ini文件的读写功能，并通过多个例程来展示其实现过程。 首先，要理解ini文件的基本结构。一个ini文件通常由三个主要部分组成：[Section]（节）、Key=Value对（键值对）...
Qt 正则表达式简单测
reaL's Blog
03-22 3408
对正则表达式以前没了解过，这次用到大概看了一下，感觉挺复杂的，没怎么太懂，所以对 QRegExp 也没完全理解，就直接贴代码了： regexp.h #ifndef REGEXP_H #define REGEXP_H #include #include #include #include #include #include #include class RegexpCo
环形缓冲区
reaL's Blog
04-25 2510
环形缓冲区。我的理解就是，开辟一块内存区域，然后会有操作不断地往里边存放数据，同时也会有操作从这块区域里边往外拿数据。主要用在网络编程中，数据接收线程接收客户端发送过来的数据，先存放到环形缓冲区中，然后数据处理线程再从里边逐条读取数据并处理。实现的重点有两点：1、保证存放数据的时候不会覆盖还未读取的数据、读取数据的时候不会重复读取已经读取过的数据；2、线程同步。         下面是我实现的一
Windows下字符编码转换
reaL's Blog
05-16 2408
// // get current time, yyyyMMddhhmmss // char* curtime( char *p, uint len ) { if( NULL != p ) { time_t tt; time( &tt ); tm* ptm = localtime( &tt ); memset( p, 0, sizeof(char) * len ); spr
编写 ATL ActiveX 控件
reaL's Blog
12-12 1653
一直想写一些ATL、ActiveX的东西，但是一直都没有下定决心去写，一来是自己对这方面的东西不太了解，写不出什么名堂；二来就是懒，懒得思考，懒得动手。这篇文章只是记录一下ATL ActiveX控件的一个大概写法跟使用方法，方便有这方面需求的同学快速上手。
C#实现ini文件读写操作详解
" ini文件读写操作代码通过C#实现，涉及DllImport、Kernel32.dll API调用，以及IniFiles类的构建与成员函数" 在Windows操作系统中，ini文件是一种简单的文本配置文件，常用于存储应用程序的设置。这篇内容主要讲解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值