【第12节 C++模板】

于 2021-12-12 21:57:34 发布
阅读量342 收藏
点赞数
分类专栏： c++ 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24409999/article/details/121894496
版权

函数模板

什么是模板： 把类型当做未知量，可以忽略类型影响

#include<iostream>
using namespace std;
int Max(int a, int b)
{
	return a > b ? a : b;
}
string Max(string a, string b)
{
	return a > b ? a : b;
}
//引入模板这个东西
template <typename _Ty>//告诉编译器 下面代码用到一个位置类型叫做_Ty

_Ty Max(_Ty a, _Ty b)
{
	return a > b ? a : b;
}

int main()
{
	return 0;
}

声明模板的语法

//单个未知类型
template <typename _Ty>//告诉编译器 下面代码用到一个位置类型叫做_Ty    _Ty 随便改 ，就是类型代号
Ty Max(_Ty a, _Ty b)
{
	return a > b ? a : b;
}
//可以多个未知类型
template <typename _Ty1,typename _Ty2>
void print(_Ty1 one ,_Ty2 two)
{
    cout<<one<<endl;
    cout<<two<<endl;
}
//typename 可以换成class
template <class T>
void print(T a)
{
    cout<<a<<endl;
}

调用函数模板

  • ​ 隐式调用 : 正常的函数传参即可调用

    #include<iostream>
using namespace std;
int Max(int a, int b)
{
	return a > b ? a : b;
}
string Max(string a, string b)
{
	return a > b ? a : b;
}
//引入模板这个东西
template <typename _Ty>//告诉编译器 下面代码用到一个位置类型叫做_Ty    _Ty 随便改 ，就是类型代号
_Ty Max(_Ty a, _Ty b)
{
	return a > b ? a : b;
}

int main()
{  
	//隐式调用
	cout << Max(1, 2) << endl;
	cout << Max("string", "string")<<endl;
	cout << Max(1.1, 2.3 << endl;
	return 0;
}

  • ​ 显示调用: 函数名<类型名>(参数)

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

int Max(int a, int b)
{
	return a > b ? a : b;
}
string Max(string a, string b)
{
	return a > b ? a : b;
}
//引入模板这个东西
template <typename _Ty>//告诉编译器 下面代码用到一个位置类型叫做_Ty    _Ty 随便改 ，就是类型代号
_Ty Max(_Ty a, _Ty b)
{
	return a > b ? a : b;
}
//_Ty =string a="abc" b="abc"

template <class _Ty1, class _Ty2> 
void print(_Ty1 one ,_Ty2 two)
{
	cout << one << endl;
	cout << two << endl;
}
int main()
{  
	//隐式调用
	cout << Max(1, 2) << endl;
	cout << Max("string", "string")<<endl;
	cout << Max(1.1, 2.3) << endl;

	//显示调用
	cout << Max<string>("abc", "abd") << endl;
	print<string, string>("string1", "string2");
	print<string, int>("string1", 123);
	return 0;
}

函数模板的两种形态

  • ​ 普通函数当做函数模板

  • ​ 类的成员函数是函数模板

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

int Max(int a, int b)
{
	return a > b ? a : b;
}
string Max(string a, string b)
{
	return a > b ? a : b;
}
//引入模板这个东西
template <typename _Ty>//告诉编译器 下面代码用到一个位置类型叫做_Ty    _Ty 随便改 ，就是类型代号
_Ty Max(_Ty a, _Ty b)
{
	return a > b ? a : b;
}
//_Ty =string a="abc" b="abc"

template <class _Ty1, class _Ty2> 
void print(_Ty1 one ,_Ty2 two)
{
	cout << one << endl;
	cout << two << endl;
}
class MM
{
public:
	template <class _Ty>
	void print(_Ty data)
	{
		cout << data << endl;
	}
	template <class _Ty>
	void printData(_Ty data);
protected:
	string name;
	int age;
};
//在类外实现的时候不能省略template这一块
template <class _Ty>
void MM::printData(_Ty data)
{
	cout << data << endl;
}
int main()
{  
	//隐式调用
	cout << Max(1, 2) << endl;
	cout << Max("string", "string")<<endl;
	cout << Max(1.1, 2.3) << endl;

	//显示调用
	cout << Max<string>("abc", "abd") << endl;
	print<string, string>("string1", "string2");
	print<string, int>("string1", 123);

	//类照曝光额成员函数是函数模板
	MM mm;
	mm.print(123);
	mm.print<string>("ILoveyou");
	mm.printData(12345);
	return 0;
}

函数模板特殊的写法

  • ​ 缺省写法

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

int Max(int a, int b)
{
	return a > b ? a : b;
}
string Max(string a, string b)
{
	return a > b ? a : b;
}
//引入模板这个东西
template <typename _Ty>//告诉编译器 下面代码用到一个位置类型叫做_Ty    _Ty 随便改 ，就是类型代号
_Ty Max(_Ty a, _Ty b)
{
	return a > b ? a : b;
}
//_Ty =string a="abc" b="abc"

template <class _Ty1, class _Ty2> 
void print(_Ty1 one ,_Ty2 two)
{
	cout << one << endl;
	cout << two << endl;
}
class MM
{
public:
	template <class _Ty>
	void print(_Ty data)
	{
		cout << data << endl;
	}
	template <class _Ty>
	void printData(_Ty data);
protected:
	string name;
	int age;
};
//在类外实现的时候不能省略template这一块
template <class _Ty1>
void MM::printData(_Ty data)
{
	cout << data << endl;
}

template <class _Ty1, class _Ty2 = int>
void printData(_Ty1 one, _Ty2 two)
{
	cout << one << "\t" << two << endl;
}

void testFunc()
{
	printData("string", 1234);
	//函数模板的缺省，显示调用，可以不用传类型，但是参数是不能少的
	printData<string>("ILoveyou", 1234);
}
int main()
{  
	//隐式调用
	cout << Max(1, 2) << endl;
	cout << Max("string", "string")<<endl;
	cout << Max(1.1, 2.3) << endl;

	//显示调用
	cout << Max<string>("abc", "abd") << endl;
	print<string, string>("string1", "string2");
	print<string, int>("string1", 123);

	//类照曝光额成员函数是函数模板
	MM mm;
	mm.print(123);
	mm.print<string>("ILoveyou");
	mm.printData(12345);

	//模板函数可不可缺省
	return 0;
}

  • ​ 存在常量类型

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

int Max(int a, int b)
{
	return a > b ? a : b;
}
string Max(string a, string b)
{
	return a > b ? a : b;
}
//引入模板这个东西
template <typename _Ty>//告诉编译器 下面代码用到一个位置类型叫做_Ty    _Ty 随便改 ，就是类型代号
_Ty Max(_Ty a, _Ty b)
{
	return a > b ? a : b;
}
//_Ty =string a="abc" b="abc"

template <class _Ty1, class _Ty2> 
void print(_Ty1 one ,_Ty2 two)
{
	cout << one << endl;
	cout << two << endl;
}
class MM
{
public:
	template <class _Ty>
	void print(_Ty data)
	{
		cout << data << endl;
	}
	template <class _Ty>
	void printData(_Ty data);
protected:
	string name;
	int age;
};
//在类外实现的时候不能省略template这一块
template <class _Ty1>
void MM::printData(_Ty data)
{
	cout << data << endl;
}

template <class _Ty1, class _Ty2 = int>
void printData(_Ty1 one, _Ty2 two)
{
	cout << one << "\t" << two << endl;
}
//存在传常量写法
//size_t:unsigned int 的别名
template <class _Ty1,size_t size=3>
void printArray(_Ty1 array)//_Ty1 = int* size=3
{
	for (int i = 0; i < size; i++)
	{
		cout << array[i];
	}
	cout << endl;
}

void testFunc()
{
	printData("string", 1234);
	//函数模板的缺省，显示调用，可以不用传类型，但是参数是不能少的
	printData<string>("ILoveyou", 1234);
	int array[3] = { 1, 2, 3 };
	//没有做缺省必须显示调用
	printArray<int*,3>(array);
	//做了缺省可以隐式调用
	printArray(array);

	//不能传入变量，只能传入常量，函数模板如果存在变量的情况下
	/*int size = 3;
	printArray<int*, size>(array);*/
}
int main()
{  
	//隐式调用
	cout << Max(1, 2) << endl;
	cout << Max("string", "string")<<endl;
	cout << Max(1.1, 2.3) << endl;

	//显示调用
	cout << Max<string>("abc", "abd") << endl;
	print<string, string>("string1", "string2");
	print<string, int>("string1", 123);

	//类照曝光额成员函数是函数模板
	MM mm;
	mm.print(123);
	mm.print<string>("ILoveyou");
	mm.printData(12345);

	//模板函数可不可缺省
	return 0;
}

类模板

如何生成一个类模板

template<class _Ty>
class MM
{
   public:
   protected:
}
//只要被template修饰就是一个模板类，用没用未知类型没有关系

类模板调用

  • 必须采用显式调用

    #include <iostream>
using namespace std;
//template <>
//class Data
//{
//
//};
template <class _Ty>
class MM
{
public:
protected:
};

int main()
{
	//必须采用显示调用
	MM<int> mm;
	MM<string> mm2;
	MM<double> mm3;
	//MM mm;错误的！
	return 0;
}

  • 类模板不是一个实际类型，所以所有用到类名的地方都需要使用: 类名<未知类型> 方式使用

    #include <iostream>
using namespace std;
//template <>
//class Data
//{
//
//};

template <class _Ty>
class MM
{
public:
	MM(){};
	MM(string name):name(name){}
	void print();
protected:
	string name;
};
//在类外实现
template <class _Ty>
void MM<_Ty>::print()
{
	cout << "类模板" << endl;
}

template <class _Ty>
class Girl :public MM<_Ty>
{
public:
	Girl(string name) :MM<_Ty>(name)
	{

	}
protected:
};
int main()
{
	//必须采用显示调用
	MM<int> mm;
	MM<string> mm2;
	MM<double> mm3;
	//MM mm;错误的！
	Girl<int> girl("Loveyou");
	girl.print();

	return 0;
}

  • 多文件中，类模板 中的声明和实现一定在一起的，不能分开写。

    #include <iostream>
using namespace std;
//template <>
//class Data
//{
//
//};

template <class _Ty>
class MM
{
public:
	MM(){};
	MM(string name):name(name){}
	void print();
protected:
	string name;
};
//在类外实现
template <class _Ty>
void MM<_Ty>::print()
{
	cout << "类模板" << endl;
}

template <class _Ty>
class Girl :public MM<_Ty>
{
public:
	Girl(string name) :MM<_Ty>(name)
	{

	}
protected:
};
template <class _Ty1,class _Ty2>
class Data
{
public:
	Data(_Ty1 one, _Ty2 two) :one(one), two(two){}
	void print();
protected:
	_Ty1 one;
	_Ty2 two;
};

template <class _Ty1, class _Ty2>
void Data<_Ty1, _Ty2>::print()
{
	cout << one << endl;
	cout << two << endl;
}

int main()
{
	//必须采用显示调用
	MM<int> mm;
	MM<string> mm2;
	MM<double> mm3;
	//MM mm;错误的！
	Girl<int> girl("Loveyou");
	girl.print();

	Data<string, int> mmInfo("小芳",19);
	mmInfo.print();
	Data<int, int> data(12, 10);
	data.print();
	return 0;
}

自定义类型当做模板参数

基本自定义类型

自定义类型也是一个模板

模板传入自定义类型，关键点就在于重载运算符

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

class MM
{
public:
	MM(string name, int age) :name(name), age(age){}
	friend ostream& operator<<(ostream& out, MM& mm)
	{
		out << mm.name << " " << mm.age;
		return out;
	}
	bool operator>(MM& mm) const
	{
		return this->age > mm.age;
	}
protected:
	string name;
	int age;
};


template <class _Ty>
void print(_Ty one)
{
	//错误	1	error C2679: 二进制“<<”: 没有找到接受“std::string”类型的右操作数的运算符(或没有可接受的转换)	c:\users\administrator\desktop\mycjiajiapro\consoleapplication11\consoleapplication11\源.cpp	17	1	ConsoleApplication11

	cout << one << endl;
}


template <class _Ty>
_Ty Max(_Ty a, _Ty b)
{
	//错误	5	error C2784: “bool std::operator >(const std::reverse_iterator<_RanIt> &,const std::reverse_iterator<_RanIt2> &)”: 未能从“MM”为“const std::reverse_iterator<_RanIt> &”推导 模板 参数	c:\users\administrator\desktop\mycjiajiapro\consoleapplication11\consoleapplication11\源.cpp	37	1	ConsoleApplication11

	return a > b ? a : b;
}

int main()
{
	//函数模板传入自定义类型
	print(12);
	print<string>("string");
	print(MM("mm", 19));

	MM xiaoF("小芳", 18);
	MM xiaoL("小丽", 28);

	MM result = Max<MM>(xiaoF, xiaoL);
	//MM result = Max(xiaoF, xiaoL);函数模板可以隐式调用
	cout << result << endl;
	return 0;
}

#include <iostream>
using namespace std;

class MM
{
public:
	MM(string name, int age) :name(name), age(age) {}
	friend ostream& operator<<(ostream& out, const MM& mm)
	{
		out << mm.name << " " << mm.age;
		return out;
	}
	bool operator>(MM& mm) const 
	{
		return this->age > mm.age;
	}
protected:
	string name;
	int age;
};
template <class _Ty>
void print(_Ty one) 
{
	//error C2679: 二进制“<<”: 没有找到接受“_Ty”类型的右操作数的运算符(或没有可接受的转换)
	cout << one << endl;
}
template <class _Ty>
_Ty Max(_Ty a, _Ty b) 
{
	//rror C2676: 二进制“>”:“_Ty”不定义该运算符或到预定义运算符可接收的类型的转换
	return a > b ? a : b;
}

template <class _Ty>
class Node
{
public:
	Node(_Ty data, Node<_Ty>* next) :data(data), next(next) {}
	_Ty getData() 
	{
		return data;
	}
	Node<_Ty>* getNext()
	{
		return next;
	}
protected:
	_Ty data;
	Node<_Ty>* next;
	//正常写法:Node* next;
};
template <class _Ty>
class List 
{
public:
	List() 
	{
		headNode = nullptr;
	}
	void insertList(_Ty data) 
	{
		headNode = new Node<_Ty>(data, headNode);
	}
	void printList()
	{
		Node<_Ty>* pmove = headNode;
		while (pmove != nullptr) 
		{
			//error C2679: 二进制“<<”: 没有找到接受“_Ty”类型的右操作数的运算符(或没有可接受的转换)
			cout << pmove->getData() << endl;
			pmove = pmove->getNext();
		}
		cout << endl;
	}
protected:
	Node<_Ty>* headNode;
};
void testList() 
{
	List<int> list;
	list.insertList(1);
	list.insertList(2);
	list.insertList(3);
	list.printList();
	List<MM> mmList;
	mmList.insertList(MM("小芳", 18));
	mmList.insertList(MM("小丽", 28));
	mmList.insertList(MM("小美", 38));
	mmList.printList();
}

int main() 
{
	//函数模板传入自定义类型
	print(12);
	print<string>("string");
	print(MM("mm", 19));

	MM xiaoF("小芳", 18);
	MM xiaoL("小丽", 28);
	MM result = Max<MM>(xiaoF, xiaoL);
	//MM result = Max(xiaoF, xiaoL);  函数模板可以隐式调用
	cout << result << endl;
	testList();


	return 0;
}

模板嵌套

明白类型是什么即可，适当可以借用using语法起别名 简化代码

#include <iostream>
using namespace std;
template <class _Ty1, class _Ty2>
class MM
{
public:
	MM(_Ty1 one, _Ty2 two) :one(one), two(two) {}
	friend ostream& operator<<(ostream& out, const MM& mm)
	{
		out << mm.one << " " << mm.two;
		return out;
	}
protected:
	_Ty1 one;
	_Ty2 two;
};

template <class _Ty1, class _Ty2>
class Data
{
public:
	Data(_Ty1 one, _Ty2 two) :one(one), two(two) {}
	void print()
	{
		cout << one << " " << two << endl;
	}
protected:
	_Ty1 one;
	_Ty2 two;
};
void testFunc()
{
	//_Ty1类型是:MM<string,int>
	//_Ty2类型是:MM<double,double>
	Data<MM<string, int>, MM<double, double>>
		data(MM<string, int>("小芳", 18), MM<double, double>(89, 56));
	data.print();
	//上面两行 等效下面四行代码
	MM<string, int> mmData("小芳", 18);
	MM<double, double> mmScore(89, 56);
	Data<MM<string, int>, MM<double, double>> mData(mmData, mmScore);
	mData.print();
}


template <class _Ty>
void print(_Ty data)
{
	cout << data << endl;
}
int main()
{
	//隐式调用
	print(MM<string, int>("小芳", 32));
	//显示调用
	//类型：MM<string, int>
	print<MM<string, int>>(MM<string, int>("小美", 238));
	//起别名简化代码
	using MMType = MM<string, int>;
	print<MMType>(MMType("小美", 238));

	testFunc();
	return 0;
}

函数模板重载

模板和普通函数 ，调用函数函数类型一致情况 优先调用普通函数

两个模板同时成立，优先调用类型相似度高的那个

类模板特化

局部特化

完全特化

qq_24409999
关注
专栏目录
第四十节 C++ 宏和模板详解
菜鸟博客
04-25 1026
宏定义是在预编译时，将宏在引用出展开，所以使用宏定义时，一定要结合小阔号一起使用。宏的用法： 1 使用宏定义常量： #define NAME_NUM 60; #define NAME "tom" ;                 2 使用宏定义函数（注意结合括号）                 3 使用宏避免多次包含头文件                 #ifndef _HUMAN_H_ #...
C++ 模板类与智能指针
weixin_48882021的博客
11-17 2270
一、实验内容 一、模板函数（compare） 1.一般模板函数 2.特化模板函数 二、类模板Queue 1.类模板（Queue） 2.成员模板函数 3.模板特化：模板函数特化、模板成员函数特化、模板类特化 三、模板类AutoPtr 1.构造函数 2.析构函数 3.拷贝构造函数 4.等号、->、*等运算符重载 5.6主函数调用AutoPtr ...
c++ string类的基本构造函数以及对象初始化实例
hua7765321的专栏
01-08 702
string类是由头文件string支持的，其中包含了大量的方法，其中包括了若干的构造函数，用于将字符串赋值给变量，合并字符串，比较字符串和访问各个元素的重载运算符以及用于在字符串中查找字符和子字符串的工具 常用构造字符串：     string(const char * s) 将string对象初始化为s指向的字符串 string(int n, c
错误 C2679 二进制“=”: 没有找到接受“const _Ty”类型的右操作数的运算符(或没有可接受的转换）的一种情况发生的错误
xxmy7的博客
05-21 1万+
错误 C2679 二进制“=”: 没有找到接受“const _Ty”类型的右操作数的运算符(或没有可接受的转换 记录一下自己写代码出现的错误。 问题 写关于复数的模板类时出现了这样的报错 错误 C2679 二进制“=”: 没有找到接受“const _Ty”类型的右操作数的运算符(或没有可接受的转换） 开始的代码如下： #include<iostream> #include<vector> #include<iterator> #include<algorith
二进制“<<”: 没有找到接受“std::string”类型的右操作数的运算符(或没有可接受的转换)...
数据库天地
03-12 2778
将 #include &lt;string.h&gt; 改为 #include &lt;string&gt; using namespace std;
错误C2679二进制“＜＜”: 没有找到接受“std::string”类型的右操作数的运算符(或没有可接受的转换)
weixin_42258743的博客
08-14 8065
严重性 代码 说明 项目 文件 行 禁止显示状态 错误 C2679 二进制“<<”: 没有找到接受“std::string”类型的右操作数的运算符(或没有可接受的转换) ConsoleApplication1 c:\users\administrator\desktop\新建文件夹\consoleapplication1\consoleapplication1\源.cpp 10 原因：未包含#include<string> ...
2021年第十二届蓝桥杯决赛 C++大学A组 真题.zip
06-05
《2021年第十二届蓝桥杯决赛 C++大学A组 真题解析》 蓝桥杯作为中国极具影响力的编程竞赛之一，每年都吸引了众多高校学子参与，旨在提升大学生的编程技能和算法理解能力。2021年的第十二届蓝桥杯决赛在6月5日举行，...
很多人觉得C++模板很难学习和适应，不值得浪费时间，今天它的白痴指南来了（第一部分）
linuxguitu的博客
01-12 3253
文章背景 大多数C ++程序员由于其困惑的性质而远离C ++模板。 反对模板的借口： 很难学习和适应。 编译器错误是模糊的，而且很长。 不值得的努力。 承认模板很难学习，理解和适应。 然而，我们从使用模板中获得的好处将超过负面影响。 有 比可以围绕模板包装的泛型函数或类要多得多。 我会说明他们。 从技术上讲，C ++模板和STL（标准模板库）是同级的。 在本文中，我只会介绍核心级别的模板。 本系列的下一部分将围绕模板介绍更高级和有趣的内容，以及有关STL的一些专门知识。 目录 语法句 功能
c++第8单元第12课C++-Test-8-12.rar
最新发布
06-23
在本课程"C++第8单元第12课C++-Test-8-12"中，我们将深入探讨C++编程语言的关键概念和技术。这个压缩包文件包含了一个名为"Test-8-12"的子文件夹，很可能包含了相关的源代码、练习题、测试用例或者教学资料。由于...
二进制:没有找到接受“const _Ty”类型的左操作数的运算符(或没有可接受的转换)
doujianyoutiao的博客
03-31 4962
我遇到的问题是“二进制“<”: 没有找到接受“const _Ty”类型的左操作数的运算符(或没有可接受的转换) ”。双击错误信息后，到了xstddef文件的struct less的()操作符重载那。遇到这种直接跑到模板下面的情况，通常都是用了某个模板类等模板相关的类型、函数，而我是自己定义了一个结构体，然后用了set容器，由于set容器是会自己排序的，而我的结构体又没有写<的操作符重载...
报错：错误 C2678 二进制“＜”: 没有找到接受“const _Ty”类型的左操作数的运算符(或没有可接受的转换)
CoolHongCSDN的博客
03-14 2046
1 报错原因分析 报错处如下// 代码 //处： template<typename Comparable> const Comparable& findMax(const vector<Comparable>& a) { int maxIndex = 0; for (int i = 0; i < a.size(); ++i) /**/ if (a[maxIndex] < a[i])/**/ maxIndex = i; return a
C2679 二进制 没有找到接受 std::string 类型的右操作数的运算符(或没有可接受的转换)
热门推荐
肥宅Sean
03-24 2万+
在VS上打代码，结果出现了上面这个错误 很奇怪，以前在其他IDE上这么写都没有问题，不知道为什么在VS写就出现了这个错误，我一开始以为是我的代码的问题。可是怎么想都没有想通。 甚至，我自己在main函数中又写了一遍之后，还是报一样的错误。 #include &lt;iostream&gt; using namespace std; int main(){ string s; ...
错误 1 error C2679: 二进制“<<”: 没有找到接受“void”类型的右操作数的运算符(或没有可接受的转换)
Vincentlmeng的博客
03-20 1万+
void Get(const Key & k) { for (size_t i = 0; i < currentSize; ++i) { if (arr[i].key == k) return arr[i].value; } return Value(); }在主程序
C++学习笔记——常见数据类型
wu01jian01的博客
07-03 596
在变量的赋值、运算等过程中，如果代码写的不规范，常常会出现各种warning，通常对程序的运行没有太大的影响，但是这种隐性炸弹总会让人不安。 这里做个笔记，遇到了就来更新。 1、“T_y"和"T_p” warning C4244: “=”: 从“_Ty”转换到“_Tp”，可能丢失数据 其中_Ty=int，_Tp=float如果将两者相互赋值肯定是会损失精度的。 ...
C++模板元编程：导入范例与 Fibonacci 计算
在`main`函数中，通过`Fib<10>::Result`即可得到斐波那契数列的第十项。 模板元编程的主要思想是利用模板的实例化过程来执行计算，这些计算是在编译期间完成的，而不是在运行时。由于编译期计算无需消耗运行时资源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值