Essential C++ 第四章习题

已于 2023-01-23 21:17:38 修改
阅读量122 收藏 2
点赞数 2
分类专栏： Essential C++ C++ 文章标签： c++ 开发语言
于 2023-01-20 19:17:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/godfishhh/article/details/128708308
版权

目录

4.1

4.2

4.3

4.4

4.5

4.1

C++代码：

//Stack.h

#pragma once

// #ifndef #define #endif 可以防止重复定义
#ifndef _STACK_H_
#define _STACK_H_

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

class Stack
{
public:
	Stack(vector<string>vec);
	bool push(const string&);
	bool pop(string& elem);
	bool peek(string& elem);
	bool empty();
	bool full();

	int size()
	{
		return _stack.size();
	}
private:
	vector<string>_stack;
};

#endif

//Stack.cpp

#include"Stack.h"
#include<iostream>

Stack::Stack(vector<string>vec)
{
	_stack = vec;
}

bool Stack::push(const string& s1)
{
	if (full())
	{
		return false;
		cout << "容器已满，无法继续push" << endl;
	}
	else
	{
		_stack.push_back(s1);
		return true;
	}
}

bool Stack::pop(string& elem)
{
	if (empty())
	{
		cout << "容器为空，无法pop" << endl;
		return false;
	}
	else
	{
		elem = _stack.back();//将要移出的元素赋给参数( vector成员函数 .back() 返回容器的最后一个元素)
		_stack.pop_back();
		return true;
	}
}

bool Stack::peek(string& elem)
{
	if (empty())
	{
		cout << "容器为空" << endl;
		return false;
	}
	else
	{
		elem = _stack.back();
		return true;
	}
}

bool Stack::empty()
{
	if (_stack.empty())
	{
		return true;
	}
	return false;
}

bool Stack::full()
{
	// vector成员函数 .max_size() 返回容器最大能储存的元素个数 ( .max_element返回容器范围内的最大元素)
	if (_stack.size() == _stack.max_size())
	{
		return true;
	}
	return false;
}

//main.cpp

#include"Stack.h"
#include<iostream>


int main()
{
	vector<string> vec(10, "GodFishhh");
	Stack St1(vec);

	int size = St1.size();
	cout << "此时容器的大小为：" << size << endl;

	string temp_st3 = "AFish";
	St1.push(temp_st3);
	cout << "向容器中push的元素为：" << temp_st3 << endl;

	size = St1.size();
	cout << "此时容器的大小为：" << size << endl;

	string temp_st1;
	St1.pop(temp_st1);
	cout << "从容器中pop出的元素为：" << temp_st1 << endl;

	string temp_st2;
	St1.peek(temp_st2);
	cout << "此时容器中最后一个元素为：" << temp_st2 << endl;


	system("pause");
	return 0;
}

程序运行结果：

4.2

C++代码：

//Stack.h

#pragma once

// #ifndef #define #endif 可以防止重复定义
#ifndef _STACK_H_
#define _STACK_H_

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

class Stack
{
public:
	Stack(vector<string>vec);
	bool push(const string&);
	bool pop(string& elem);
	bool peek(string& elem);
	bool empty();
	bool full();

	bool find(const string elem);
	int count(const string elem);

	int size()
	{
		return _stack.size();
	}
private:
	vector<string>_stack;
};

#endif

//Stack.cpp

#include"Stack.h"
#include<iostream>
//#include<algorithm> 可以使用 find(.begin(),.end(),value)来寻找，如果范围内有则返回指向这个地址的iterator，没有则返回 end() )

Stack::Stack(vector<string>vec)
{
	_stack = vec;
}

bool Stack::push(const string& s1)
{
	if (full())
	{
		return false;
		cout << "容器已满，无法继续push" << endl;
	}
	else
	{
		_stack.push_back(s1);
		return true;
	}
}

bool Stack::pop(string& elem)
{
	if (empty())
	{
		cout << "容器为空，无法pop" << endl;
		return false;
	}
	else
	{
		elem = _stack.back();//将要移出的元素赋给参数( vector成员函数 .back() 返回容器的最后一个元素)
		_stack.pop_back();
		return true;
	}
}

bool Stack::peek(string& elem)
{
	if (empty())
	{
		cout << "容器为空" << endl;
		return false;
	}
	else
	{
		elem = _stack.back();
		return true;
	}
}

bool Stack::empty()
{
	if (_stack.empty())
	{
		return true;
	}
	return false;
}

bool Stack::full()
{
	// vector成员函数 .max_size() 返回容器最大能储存的元素个数 ( .max_element返回容器范围内的最大元素)
	if (_stack.size() == _stack.max_size())
	{
		return true;
	}
	return false;
}

bool Stack::find(const string elem)
{
	vector<string>::const_iterator it = _stack.end(); //类成员函数可以访问private中的私有数据，其他位置若向访问private中的私有数据必须通过类成员函数
	for (; it != _stack.end(); it++)
	{
		if (elem == *it)
		{
			return true;
		}
	}
	return false;
}

int Stack::count(const string elem)
{
	vector<string>::const_iterator it = _stack.begin();
	int counts = 0;
	for (; it != _stack.end(); it++)
	{
		if (elem == *it)
		{
			counts++;
		}
	}

	return counts;
}

//main.cpp

#include"Stack.h"
#include<iostream>


int main()
{
	vector<string> vec(10, "GodFishhh");
	Stack St1(vec);

	int size = St1.size();
	cout << "此时容器的大小为：" << size << endl;

	string temp_st3 = "AFish";
	St1.push(temp_st3);
	cout << "向容器中push的元素为：" << temp_st3 << endl;

	size = St1.size();
	cout << "此时容器的大小为：" << size << endl;

	string temp_st1;
	St1.pop(temp_st1);
	cout << "从容器中pop出的元素为：" << temp_st1 << endl;

	string temp_st2;
	St1.peek(temp_st2);
	cout << "此时容器中最后一个元素为：" << temp_st2 << endl;

	//find()
	string temp_st4;
	cout << "输入想要在类成员St1中寻找的元素：";
	cin >> temp_st4;
	if (St1.find(temp_st4))
	{
		cout << "找到了！" << endl;
	}
	else
	{
		cout << "没找到" << endl;
	}

	//count()
	string temp_st5;
	cout << "输入某个字符串：";
	cin >> temp_st5;
	int counts = St1.count(temp_st5);
	cout << temp_st5 << " 在类成员St1中出现了" << counts << "次" << endl;


	system("pause");
	return 0;
}

程序运行结果：

4.3

C++代码：

//4.3

#include<iostream>
using std::string;

class globalWrapper
{
private:
	static string _program_name;
	static string _version_stamp;
	static int _version_number;
	static int _tests_run;
	static int _tests_passed;
public:
	globalWrapper(string p_n, string v_s, int v_n, int t_r, int t_p)
	{
		_program_name = p_n;
		_version_stamp = v_s;
		_version_number = v_n;
		_tests_run = t_r;
		_tests_passed = t_p;
	}
	static int tests_passed() { return _tests_passed; }
	static int tests_run() { return _tests_run; };
	static int version_number() { return _version_number; };
	static string version_stamp() { return _version_stamp; };
	static string program_name() { return _program_name; };
};

将全局变量声明为static member（保证全局对象都仅有一份），并且将它们的访问函数声明为static。

4.4

C++代码：

//UserProfile.h

//通过一个静态变量static来保证同名的多个用户有自己独有的登录对话(在构造函数中定义，每次调用构造函数都使这个static变量发生相应的变化以表示不同的用户）

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

#ifndef _USERPROFILE_H_
#define _USERPROFILE_H_

class UserProfile
{
private:
	string _login; //用于区分同名的用户
	string _name;
	string _level;  //Rookie, Intermediate, Advance, Pro
	int _login_times;
	int _guess_times;
	int _correct_times;
public:
	//构造函数(默认参数的设置应当从右往左）
	UserProfile(string name = "guest", string level = "Rookie");
	//重新设置各种数据
	void set_name(string name) { _name = name; };
	void set_level(string level) { _level = level; };
	void set_login_times(int login_times) { _login_times = login_times; };
	void set_guess_times(int guess_times) { _guess_times = guess_times; };
	void set_correct_times(int correct_times) { _correct_times = correct_times; };
	//读取各种数据
	string _return_login() { return _login; };
	string _return_name() { return _name; };
	string _return_level() { return _level; }
	int _return_login_times() { return _login_times; };
	int _return_guess_times() { return _guess_times; };
	int _return_correct_times() { return _correct_times; };
	//猜测的命中率
	double average_guess();
	//重载运算符
	bool operator==(const UserProfile User);
	
	bool operator!=(const UserProfile User);
	//输入
	friend istream& operator>>(istream& is, UserProfile& User);
	//输出
	friend ostream& operator<<(ostream& os, UserProfile& User);
};


#endif


//UserProfile.cpp

#pragma warning(disable:4996)


#include"UserProfile.h"



UserProfile::UserProfile(string name, string level) :_login(name)
{
	//为每个用户设置独一无二的标识符
	static int id = 0;
	char buffer[16];
	_itoa(id++, buffer, 10);
	_login += buffer;

	_name = name;
	_level = level;
	_login_times = 0;
	_guess_times = 0;
	_correct_times = 0;
}


double UserProfile::average_guess()
{
	//_correct_times和_guess_times的类型均为int,而此函数的返回值是double类型，所以需要对变量进行类型转换再运算
	return ((double)_correct_times / (double)_guess_times * 100);
}


bool UserProfile::operator==(const UserProfile User)
{
	if (_login == User._login && _name == User._name)
	{
		return true;
	}
	return false;
}

bool UserProfile::operator!=(const UserProfile User)
{
	return !(*this == User);
}

//友元函数利用作用域解析运算符声明
istream& operator>>(istream& is, UserProfile& User)
{
	cout << "分别输入用户的login_times,guess_times,correct_times: ";
	is >>User._login_times >> User._guess_times >> User._correct_times;
	return is;
}

ostream& operator<<(ostream& os, UserProfile& User)
{
	os <<User._login << " " << User._level << " " << User._login_times << " " << User._guess_times << " " << User._correct_times<<" "<<User.average_guess()<<"%";
	os<<endl;
	return os;
}


     //main.cpp

#include"UserProfile.h"
#include<vector>



int main()
{
	//level_rank
	vector<string>vec(4);
	vec[0] = "Rookie";
	vec[1] = "Intermediata";
	vec[2] = "Advance";
	vec[3] = "Pro";

	UserProfile User1;
	User1.set_login_times(1);
	User1.set_guess_times(10);
	User1.set_correct_times(4);
	cout << User1;

	UserProfile User2;
	User2.set_login_times(2);
	User2.set_guess_times(30);
	User2.set_correct_times(18);
	cout << User2;

	UserProfile User3("AFish", vec[1]);
	User3.set_login_times(1);
	User3.set_guess_times(100);
	User3.set_correct_times(40);
	cout << User3;

	User3.set_level(vec[2]);
	User3.set_login_times(2);
	User3.set_guess_times(200);
	User3.set_correct_times(160);
	cout << User3;

	UserProfile User4("GodFishhh", vec[3]);
	cin >> User4;
	cout << User4;



	system("pause");
	return 0;
}

程序运行结果：

1.通过一个静态变量static来保证同名的多个用户有自己独有的登录对话(在构造函数中定义，每次调用构造函数都使这个static变量发生相应的变化以表示不同的用户）(静态变量只定义一次，后续调用不会重复定义）

具体实现：

UserProfile::UserProfile(string name, string level) :_login(name)
{
	//为每个用户设置独一无二的标识符
	static int id = 0;
	char buffer[16];
	_itoa(id++, buffer, 10);
	_login += buffer;
}

构造完成后，输出过程只需要输出_login，其中包括 name 和特殊标识符 buffer。

(成员名的最终形式应当为：name+buffer)

2.调用函数 _itoa()，将整数转换为对应的ASCII字符串形式

static int id = 0;
char buffer[16];
_itoa(id++, buffer, 10);

原型为：char* _itoa(int value,char*stirng,int radix) 

参数为：value -- 想要转换的数据 string -- 目标字符串的地址 radix -- 转换后的进制数

4.5

C++代码：

//Matrix.h

#pragma once

#include<iostream>
using namespace std;

#ifndef _MARTRIX_H_
#define _MARTRIX_H_

class Matrix
{
private:
	int Matr[4][4]; //4x4的矩阵
public:
    //构造函数:
	
	//constructor
	Matrix(int arr[][4]);

	//default constructor
	Matrix(int a11,int a12,int a13,int a14,int a21,int a22,int a23,int a24,int a31,int a32,int a33,int a34,int a41,int a42,int a43,int a44);

	//矩阵加法：
	friend Matrix operator+(Matrix& M1,Matrix&M2);
	//矩阵乘法：
	friend Matrix operator*(Matrix& M1,Matrix&M2);
	//打印矩阵内容函数print()
	void print();
	//复合运算符+=
	void operator+=(Matrix M1);
	//function call运算符（返回参数对应位置矩阵的元素值)
	int& operator()(int row, int column)
	{
		return Matr[row][column];
	}

	int operator()(int row, int column) const
	{
		return Matr[row][column];
	}

	//输出
	friend ostream& operator<<(ostream&os,const Matrix M1);
};



#endif


//Matrix.cpp

#include"Matrix.h"


//构造函数:

//constructor
Matrix::Matrix(int arr[][4])
{
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			Matr[i][j] = arr[i][j];
		}
	}
}

//default constructor
Matrix::Matrix(int a11, int a12, int a13, int a14, int a21, int a22, int a23, int a24, int a31, int a32, int a33, int a34, int a41, int a42, int a43, int a44)
{
	Matr[0][0] = a11;
	Matr[0][1] = a12;
	Matr[0][2] = a13;
	Matr[0][3] = a14;
	Matr[1][0] = a21;
	Matr[1][1] = a22;
	Matr[1][2] = a23;
	Matr[1][3] = a24;
	Matr[2][0] = a31;
	Matr[2][1] = a32;
	Matr[2][2] = a33;
	Matr[2][3] = a34;
	Matr[3][0] = a41;
	Matr[3][1] = a42;
	Matr[3][2] = a43;
	Matr[3][3] = a44;
}

//友元函数无需声明所属类
//友元函数可以直接访问类中的私有数据

//矩阵加法：
Matrix operator+(Matrix& M1, Matrix& M2)
{
	int temp_arr[4][4] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			temp_arr[i][j] = M1.Matr[i][j] + M2.Matr[i][j];
		}
	}
	return Matrix(temp_arr);
}

//矩阵乘法：
Matrix operator*(Matrix& M1, Matrix& M2)
{
	int temp_arr[4][4] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
	for (int i = 0; i < 4; i++)  //行遍历
	{
		for (int j = 0; j < 4; j++) //列遍历
		{
			for (int x = 0; x < 4; x++)
			{
				temp_arr[i][j] += M1.Matr[i][x] * M2.Matr[x][j]; //一行一行的元素计算
			}
		}
	}
	return Matrix(temp_arr);
}

//打印矩阵内容函数print()
void Matrix::print()
{
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			cout << Matr[i][j] << " ";
		}
		cout << endl;
	}
}

//复合运算符+=
void Matrix::operator+=(Matrix M1)
{
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			Matr[i][j] += M1.Matr[i][j];
		}
	}
}

//输出
ostream& operator<<(ostream& os, const Matrix M1)
{
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			cout << M1.Matr[i][j] << " ";
		}
		cout << endl;
	}
	return os;
}

//main.cpp

#include"Matrix.h"


int main()
{
	Matrix m(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
	cout << m << endl;

	int ar[4][4] =
	{
		1,0,0,0,
		0,1,0,0,
		0,0,1,0,
		0,0,0,1
	};

	Matrix identity(ar);
	cout << identity << endl;

	Matrix m2(identity);
	m = identity;
	cout << m2 << endl;
	cout << m << endl;

	int ar2[4][4] =
	{
		1,0,2,8,
		6,1,1,8,
		4,7,2,1,
		6,8,5,6
	};

	Matrix m3(ar2);
	m3.print();

	Matrix m4 = m3 * identity;
	cout << m4 << endl;

	Matrix m5 = m3 + m4;
	cout << m5 << endl;

	m3 += m4;
	cout << m3 << endl;

	system("pause");
	return 0;
}

程序运行结果：

GodFishhh
关注
专栏目录
【C++学习】【阶段一】Essential C++ 第一章习题答案
u014435475的专栏
12-12 1625
Essential C++ 第一章习题答案int askName1() //Exercise1.5-1 { char usr_name[200]=""; cout << "Please write your name : "; cin >> usr_name; if (strlen(usr_name) < 2) { cout << "Your
Essential c++ 第三章课后练习
顾清欢的博客
09-26 802
P75 find()函数处理array、vector、list的区别。 #include&amp;amp;amp;amp;amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;amp;amp;amp;amp;lt;string&amp;amp;amp;amp;amp;amp;amp;amp;gt; #include&amp;amp;amp;amp
Essential C++第三章练习题
qq_51599283的博客
08-29 284
记录essential C++的练习题，解题办法仅供参考，代码不够简洁，但是确实是按照要求完成了题目。 3章练习题3.13.23.33.4 3.1 #include <iostream> #include <fstream> #include <map> #include <string> #include <iterator> #include <set> using namespace std; int main() { i
Essential C++第二章习题
weixin_42346253的博客
04-01 146
调用函数 2-1（又有问题） while循环那里不能识别输入的char. #include <vector> #include <string> #include <iostream> #include <algorithm> using namespace std; bool fibon_elem(int pos, int &elem) { if(pos <= 0 || pos > 1024) {elem = 0; r
Essential c++ 第四章课后练习
顾清欢的博客
09-29 940
练习4.1-4.2 Stack.h 头文件 #include &amp;amp;lt;iostream&amp;amp;gt; #include &amp;amp;lt;algorithm&amp;amp;gt; #include &amp;amp;lt;string&amp;amp;gt; #include &amp;amp;lt;vector&amp;amp;gt; using namespace std; //class主体 class
C++代码编程学习：以template进行编程——习题6.1（Essential C++ 第六章）
weixin_42269028的博客
07-26 319
C++中以template进行编程的学习（Essential C++ 第六章），其中练习6.2论坛中有人记录了，说什么书中的代码没通过，实话说，还是需要细心点看啊，里面的三个声明函数在完整代码的前面，看仔细了，光抄不行啊，我也是这样的，太急躁了，学习代码还是需要自己用用脑子的，否则，抄也犯错，越错越烦，要不得呀。
C++代码编程学习：异常处理——完结篇（Essential C++ 第七章）
weixin_42269028的博客
07-27 318
C++中的异常处理学习，主要是内存溢出的情况吧，我自己写代码的时候也发现，数据真不能随便定义，必须监控好了，溢出的情况真的很让人头疼！！！
EssentialC++第六章总结+课后习题+踩雷清单
Bqv它不想做功的博客
06-03 302
总结 讲了模板类，这是在原基础上把对象类型抽离出来，变成template<typename 占位符>这种形式。 然后怎么定义模板类，模板成员函数，和定义一般模板函数大同小异，抽离出来类型就可以，注意别忘把类型抽离出来，然后注意不该改成模板类型的别改成模板类型（比如大小、长度，这只能是整数，名字，这只能是string型） 关于模板样式的形参，写这样的形式：const 模板类型名& 形参名，因为模板类型也许是内置类型也许是class类型，这样的格式避免复制所带来巨大的开销，使程序效率降低。
C++ STL中sort函数
weixin_43349440的博客
09-15 269
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
CF C. Nikita and LCM
qq_74190237的博客
09-13 270
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 526
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C++_map_set详解
最新发布
2302_77644537的博客
09-16 641
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 558
继续学习头文件的数学函数。
C++ 中 vector 的常用功能介绍
2202_75569688的博客
09-12 429
在 C++ 中，vector是一种常用的动态数组容器，提供了方便的自动扩展、内存管理以及各种便捷的操作方法。它是 C++ 标准模板库（STL）的一部分，适用于需要动态存储和管理大量元素的场景。在本文中，我们将简要介绍vector的常用功能，展示如何对其进行操作和排序。为了简洁起见，假设我们已经使用了。
【C++ && Qt day11】
wzj46的博客
09-11 274
2、头文件窗口文件。
CCF201903_1
m0_67663419的博客
09-14 207
【代码】CCF201903_1。
C++ Qt开发：运用QJSON模块解析数据
qq_35662333的博客
09-11 1068
转载Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用QJson组件的实现对JSON文本的灵活解析功能。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，也易于机器解析和生成。该格式是基于JavaScript语言的一个子集，但它是一种独立于语言的数据格式，因此可以在许多不同的编程语言中使用。
C++ lambda闭包消除类成员变量
随手写下笔记和感悟
09-11 451
消除了——通过将它们闭包到lambda表达式中，然后将这个lambda存起来重复使用。如果用引用捕获，栈变量会释放导致非法访存；可以借助函数式编程思想，来消除一些不必要的类成员变量。拿到一个类，一看成员变量好几十个，就问你怕不怕？在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。就无法修改值捕获的变量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值