C++学习笔记13--模板

最新推荐文章于 2024-01-24 14:58:57 发布
最新推荐文章于 2024-01-24 14:58:57 发布
阅读量158 收藏
点赞数
分类专栏： C/C++ 文章标签： 模板 函数 类 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40618919/article/details/119008013
版权

模板

1.1 模板的概念

模板就是建立通用的模具，大大提高复用性

模板的特点：

  • 模板不可以直接使用，它只是一个框架
  • 模板的通用并不是万能的

1.2 函数模板

  • C++另一种编程思想称为泛型编程，主要利用的技术就是模板
  • C++提供两种模板机制： 函数模板和类模板

1.2.1 函数模板语法

函数模板作用：

  • 建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法：

template<typename T>
函数声明或定义

解释

  • template — 声明创建模板
  • typename — 表示其后面的符号是一种数据类型，可以用 class 代替
  • T — 通用的数据类型，名称可以替换，通常为大写字母

举例
普通写法

//两个整型交换函数
void swapInt(int &a, int &b)
{
	int temp = a;
	a = b; 
	b = temp;
}

//交换两个浮点型函数
void swapDouble(double &a, double &b)
{
	double temp = a;
	a = b;
	b = temp;
}

函数模板写法

template<typename T> //声明一个模板，告诉编译器后面代码中紧跟着的 T 不要报错，
					//T 是一个通用数据类型
void mySwap(T &a, T &b)
{
	T  temp = a;
	a = b;
	b = temp;
} 

void test01()
{
	int a = 10;
	int b = 20;

	//利用函数模板交换
	//两种方式使用函数模板

	//1、自动类型推导
	mySwap(a, b);

	//2、显示指定类型
	mySwap<int>(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

1.2.2 函数模板注意事项

注意事项：

  • 自动类型推导，必须推导出一致的数据类型 T，才可以使用
  • 模板必须要确定出 T 的数据类型，才可以使用
template<class T> //typename可以替换成class
void mySwap(T&a, T&b)
{
	T temp = a;
	a = b;
	b = temp;
}

//1、自动类型推导，必须推导出一致的数据类型 T 才可以使用
void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	//mySwap(a, b); //正确！
	//mySwap(a, c); //错误！推导不出一致的T类型
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

//2、模板必须要确定出 T 的数据类型，才可以使用
template<class T>
void func()
{
	cout << "func 调用" << endl;
}
void test02()
{
	//func();   //错误，未指定 T 
	func<int>();
}

1.2.3 函数模板案例

案例描述：

  • 利用函数模板封装一个排序的函数， 可以对不同数据类型数组进行排序
  • 排序规则从大到小，排序算法为选择排序
  • 分别利用 char 数组和 int 数组进行测试
//交换函数模板
template<class T>
void mySwap(T&a, T&b)
{
	T temp = a;
	a = b;
	b = temp;
}

//排序算法
template<class T>
void mySort( T arr[] , int len)
{
	for (int i = 0; i < len; i++)
	{
		int max = i; // 认定最大值的下标
		for (int j = i + 1; j < len; j++)
		{
			//认定的最大值 比 遍历出的数值 要下，说明 j下标的元素才是真正的最大值
			if (arr[max] < arr[j])
			{
				max = j;//更新最大值下标
			}
		}
		if (max != i)
		{
			//交换max和i元素
			mySwap(arr[max], arr[i]);
		}
	}
}
//提供打印数组模板
template<class T>
void printArray(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}

void test01()
{
	//测试char数组
	char charArr[] = "badcfe";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);
}

void test02()
{
	//测试int数组
	int intArr[] = { 7,5,1,3,9,2,4,6,8 };
	int num = sizeof(intArr) / sizeof(int);
	mySort(intArr, num);
	printArray(intArr, num);
}

1.2.4 普通函数和函数模板的区别

普通函数与函数模板区别：

  • 普通函数调用时可以发生自动类型转换(隐式类型转换)
  • 函数模板调用时，如果利用 自动类型推导 ，不会发生隐式类型转换
  • 如果利用 显示指定类型 的方式，可以发生隐式类型转换
//普通函数
int myAdd01(int a , int b)
{
	return a + b;
}

//函数模板
template<class T>
T myAdd02(T a , T b)
{
	return a + b;
}

void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c'; // a - 97   c - 99
	cout << myAdd01(a, c) << endl;   // 隐式类型转换：把字符型 c 转换为整型的ASCII码 99

	//自动类型推导  不会发生隐式类型转换
	//cout << myAdd02(a, c) << endl;

	//显示指定类型  会发生隐式类型转换
	cout << myAdd02<int>(a, c) << endl;
}

1.2.5 普通函数和函数模板的调用规则

调用规则如下：

  1. 如果函数模板和普通函数都可以实现，优先调用普通函数
  2. 可以通过空模板参数列表来强制调用函数模板
  3. 函数模板也可以发生重载
  4. 如果函数模板可以产生更好的匹配优先调用函数模板

代码举例

void myPrint(int a, int b)
{
	cout << "调用的普通函数" << endl << endl;
}

template<class T>
void myPrint(T a, T b)
{
	cout << "调用的模板" << endl << endl;
}

//函数重载
template<class T>
void myPrint(T a, T b, T c)
{
	cout << "调用重载的模板" << endl << endl;
}

void test01()
{
	int a = 10;
	int b = 20;

	myPrint(a, b);  // 如果函数模板和普通函数都可以调用，优先调用普通函数
	
	myPrint<>(a, b); //通过空模板参数列表，强制调用函数模板

	myPrint(a, b, 100);  // 函数模板可以发生重载

	// 如果函数模板产生更好的匹配，优先调用函数模板
	char c1 = 'a';
	char c2 = 'b';	
	myPrint(c1, c2);
}

在这里插入图片描述

1.2.6 模板的局限性

局限性：

  • 模板的通用性并不是万能的

例如：

template <class T>
void f(T a, T b)
{
	a = b;
}
在上述代码中提供的赋值操作,如果传入的a和b是一个数组，就无法实现了

template <class T>
void f(T a, T b)
{
	if(a > b) {...}
}
在上述代码中，如果 T 的数据类型传入的是像 Person 这样的自定义数据类型，也无法正常运行

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	//姓名
	string m_Name;
	//年龄
	int m_Age;
};

//对比两个数据是否相等函数
template<class T>
bool myCompare(T &a, T &b)
{
	if (a == b)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//利用具体化Person的版本实现代码，具体化优先调用
template<> bool myCompare(Person &p1, Person &p2)
{
	if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void test01()
{
	int a = 10;
	int b = 20;

	bool ret = myCompare(a, b);

	if (ret)
	{
		cout << "a == b" << endl;
	}
	else
	{
		cout << "a != b" << endl;
	}
}

void test02()
{
	Person p1("Tom", 10);
	Person p2("Tom", 11);

	bool ret = myCompare(p1, p2);
	if (ret)
	{
		cout << "p1 == p2" << endl;
	}
	else
	{
		cout << "p1 != p2" << endl;
	}
}

1.3 类模板

1.3.1 类模板语法

类模板作用：

  • 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。

语法：
template<typename T>
类

解释

  • template — 声明创建模板
  • typename — 表示其后面的符号是一种数据类型，可以用 class 代替
  • T — 通用的数据类型，名称可以替换，通常为大写字母
template<class NameType, class AgeType>
class Person
{
public:
	Person(NameType name,AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};
void test01()
{
	Person<string, int> p1("孙悟空", 999);
	p1.showPerson();
}

1.3.2 类模板和函数模板的区别

类模板与函数模板区别主要有两点：

1. 类模板没有自动类型推导的使用方式

template<class NameType,class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "name: " << this->m_Name << " age = " << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};
//1、类模板没有自动类型推导使用方式
void test01()
{
	//Person p("孙悟空", 1000); 错误，无法用自动类型推导
	Person<string, int>p("孙悟空", 1000); //正确，只能用显示指定类型
	p.showPerson();
	
}

2. 类模板在模板参数列表中可以有默认参数

template<class NameType,class AgeType = int>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "name: " << this->m_Name << " age = " << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};
void test02()
{
	Person<string>p("猪八戒", 999);
	p.showPerson();
}

1.3.3 类模板成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的：

  • 普通类中的成员函数一开始就可以创建
  • 类模板中的成员函数在调用时才创建
class Person1
{
public:
	void showPerson1()
	{
		cout << "Person1 show" << endl;
	}
};
class Person2
{
public:
	void showPerson2()
	{
		cout << "Person2 show" << endl;
	}
};

template<class T>
class MyClass
{
public:
	T obj; //创建一个数据类型不确定的成员

	//类模板中的成员函数
	void func1()
	{
		obj.showPerson1();
	}
	void func2() // func1 和 func2 在未调用时不会创建，
				//因为系统不确定 obj 是什么数据类型
	{
		obj.showPerson2();
	}
};
void test01()
{
	MyClass<Person2>m;
	//m.func1();
	m.func2();
}

1.3.4 类模板对象做函数参数

学习目标：

  • 类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：

  1. 指定传入的类型：直接显示对象的数据类型
  2. 参数模板化：将对象中的参数变为模板进行传递
  3. 整个类模板化：将这个对象类型模板化进行传递
template<class T1,class T2>
class Person
{
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
	}
	T1 m_Name;
	T2 m_Age;
};

//1、指定传入类型
void printPerson1(Person<string, int>&p)
{
	p.showPerson();
}
void test01()
{
	Person<string, int>p("孙悟空", 100);
	printPerson1(p);
}

//2、参数模板化
template<class T1,class T2>
void printPerson2(Person<T1, T2>&p)
{
	p.showPerson();
	cout << "T1 的类型为： " << typeid(T1).name() << endl;
	// 此方法可以看出编译器怎么推出来 T 是什么数据类型
	cout << "T2 的类型为： " << typeid(T2).name() << endl; 
}
void test02()
{
	Person<string, int>p("猪八戒", 90);
	printPerson2(p);
}

//3、整个类模板化
template<class T>
void printPerson3( T &p)
{
	p.showPerson();
	cout << "T的数据类型为： " << typeid(T).name() << endl;
}
void test03()
{
	Person<string, int>p("唐僧", 30);
	printPerson3(p);
}

1.3.5 类模板与继承

当类模板碰到继承时，需要注意一下几点：

  • 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中 T 的类型
  • 如果不指定，编译器无法给子类分配内存
  • 如果想灵活指定出父类中 T 的类型，子类也需变为类模板
template<class T>
class Base
{
	T m;
};

//class Son :public Base //错误，必须要知道父类中的T类型，才能继承给子类
class Son:public Base<int>
{

};

//如果想灵活指定父类中T类型，子类也需要变类模板
template<class T1,class T2>
class Son2 :public Base<T2>
{
public:
	Son2()
	{
		cout << "T1的类型为： " << typeid(T1).name() << endl;
		cout << "T2的类型为： " << typeid(T2).name() << endl;
	}
	T1 obj;
};

1.3.6 类模板成员函数的类外实现

template<class T1,class T2>
class Person
{
public:
	Person(T1 name, T2 age);
	//{
	//	this->m_Name = name;
	//	this->m_Age = age;
	//}

	void showPerson();
	//{
	//	cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
	//}

	T1 m_Name;
	T2 m_Age;
};
//构造函数类外实现
template<class T1,class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}

//成员函数类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
}

1.3.7 类模板的分文件编写

问题：

  • 类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：

  • 解决方式1：直接包含 .cpp 源文件
  • 解决方式2：将声明和实现写到同一个文件中，并更改后缀名为 .hpp , hpp是约定的名称，并不是强制

主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为 .hpp

.hpp文件

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

#include <string>
template<class T1, class T2>
class Person
{
public:
	Person(T1 name, T2 age);

	void showPerson();

	T1 m_Name;
	T2 m_Age;
};

template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}

template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
}

main函数文件

#include<iostream>
using namespace std;
#include "person.hpp"

void test01()
{
	Person <string, int>p("Jerry", 18);
	p.showPerson();
}
int main() 
{
	test01();
	system("pause");
	return 0;
}

1.3.8 类模板和友元

全局函数类内实现：直接在类内声明友元即可
全局函数类外实现：需要提前让编译器知道全局函数的存在

全局函数在类内实现

template<class T1,class T2>
class Person
{
	//全局函数 类内实现
	friend void printPerson(Person<T1,T2> p)
	{
		cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
	}
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
private:
	T1 m_Name;
	T2 m_Age;
};
void test01()
{
	Person<string, int>p("Tom", 20);
	printPerson(p);
}

全局函数在类外实现

//提前让编译器知道Person类存在
template<class T1, class T2>
class Person;

//类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2> p)
{
	cout << "类外实现 --- 姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
}

template<class T1,class T2>
class Person
{
	//全局函数 类外实现
	//加空模板参数列表
	//如果全局函数 是类外实现，需要让编译器提前知道这个函数的存在
	friend void printPerson2<>(Person<T1, T2> p);
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
private:
	T1 m_Name;
	T2 m_Age;
};
//2、全局函数在类外实现
void test02()
{
	Person<string, int>p("Jerry", 20);
	printPerson2(p);
}
一记绝尘
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++模板(1) - 模板基本概念
水草的专栏
05-27 1284
C++模板(1) - 模板基本概念
C++ 提高篇 1 之模板
weixin_51927215的博客
10-31 137
C++ 自学模板函数模板 本阶段主要针对 C++ 泛型编程和 STL 技术做详细讲解 模板 模板就是建立通用的模具，大大提高复用性 模板的特点 模板不能被直接使用，它只是一个框架 模板的通用并不是万能的 函数模板 C++ 另一种编程思想称为泛型编程，主要利用的技术就是模板 C++ 提供二种模板机制：函数模板和类模板 函数模板语法及其作用 》》函数模板语法 template<typename T> // 函数声明或定义 // 使用函数模板 // 函数名<具体的数据类型>(实参
c++ 《 模板 》 主要包含:《泛型编程》《函数模板》《类模板》
dpfxaca6的博客
04-03 243
首先，我们先由模板的类型说起。 一 。泛型编程 第一个问题，我们如何写一给通用的交换函数？ #include<iostream> using namespace std; void Swap(int& a, int& b) { int tmp = a; a = b; b = tmp; } void Swap(double& a, double&am...
函数模板和模板函数 类模板和模板类
m0_47135641的博客
06-14 70
函数模板和模板函数 类模板和模板类
c++之模板编程
hongge_smile的博客
02-10 789
模板编程，容器，多线程 一、模板编程 1.模板编程的必要性 在c++中，变量的声明必须指出它的类型，提高了编译运行效率，但是在某些场合下就有点缺陷。比如：需要定义计算两个数之和的函数，由于未来计算的数值有可能是整数、也有可能是浮点数，所以需要为这些类型准备对应的函数，但是这些函数的内部逻辑都是一样的，他们的唯一区别就是所接收的数据类型不同而已。那么有没有一种情况使得编码的时候暂时的忽略掉类型这个...
C++STL学习笔记.pdf
05-23
关于学习C++《STL模板库》以及学习《STL源码剖析》的学习笔记。
C++学习笔记、常见面试知识点.zip
08-04
C++学习笔记和常见面试知识点，C++11特性，包括多态、虚表、移动语义、友元函数、符号重载、完美转发、智能指针、const和static、数组指针和指针数组、struct内存对齐、enum和union关键字等等。帮助了解C++的特性，...
Cpp-Templates-2ed::books: C++ Templates 2ed 笔记：C++111417 模板技术
04-29
或是学习源码时遇到模板黑魔法不得其解，或是见他人轻松把玩模板心生羡慕，或是希望无限逼近精通 C++ 的状态，C++ 爱好者对模板求知若渴却又望而生畏。分享该笔记，希望帮助更多 C++ 爱好者掌握模板的使用。 相关...
c++学习笔记（个人学习时做的笔记）
11-27
该笔记是我在mooc上看C++程序设计时做的一些笔记，因为是突发学习C++，要什么就学习什么，现在已经学到“文件输入输出流”，因为现在的项目不需要用到模板的知识，所以暂时只学到这么多，之后肯定还得学的，这个老师...
C++学习笔记
01-18
C++学习笔记，基础知识和后边的高级部分，类，模板，异常等都有。
模板函数基础（函数模板）
最新发布
Mr_Wang30986的博客
01-24 475
明明大部分代码是一样的，写两遍并不是一个优秀程序员的做法，使用模板函数可以提高代码的重用性。
【模板函数的使用详解】
m0_57721815的博客
04-17 2379
文章目录1. 函数模板1.1 基本模板使用1.2 重载的模板1.3 模板局限性1.3.1 显式具体化(explicit specialization)1.3.2 实例化和具体化1.3.3 显式具体化和显式实例化的区别2 编译器选择使用哪个函数版本2.1 最佳匹配的选择原则2.2 通过编写合适的函数调用，引导编译器选择特定的函数3. 类型声明关键字decltype和后置返回类型3.1 decltype类型声明3.2 后置返回类型 1. 函数模板 需要对多个不同类型的数据使用相同的算法时，可使用模板 函数模板是
函数模板---清晰的例子，通俗易懂（超详细）
m0_52380556的博客
04-15 9629
C++的一种编程思想称为泛型编程，主要利用的技术就是模板 C++提供两种模板机制：函数模板和类模板 1.函数模板语法 函数模板作用： 建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表 语法： 1.template<typename T 2.函数的声明或定义 解释： template：声明创建模板 typename：表明其后面的符号是一种数据类型，可以用class代替 T：通用的数据类型，名称可以替换，通常为大写字母 示例 #include<iostream&
C++模板元编程
WHEgqing的专栏
11-18 9050
所谓的元编程就是编写直接生成或操纵程序的程序，C++模板为C++语言提供了元编程的能力。模板使 C++ 编程变得异常灵活，能实现很多高级动态语言才有的特性（语法上可能比较丑陋，一些历史原因见下文）。普通用户对 C++ 模板的使用可能不是很频繁，大致限于泛型编程，但一些系统级的代码，尤其是对通用性、性能要求极高的基础库（如 STL、Boost）几乎不可避免的都大量地使用 C++ 模板，一个稍有规模的大量使用模板的程序，不可避免的要涉及元编程（如类型计算）。本文就是要剖析 C++ 模板元编程的机制。
C++模板编程（3）---模板编程基本技巧Tricky Basics
追赶时代的博客
06-18 493
模板 基本技巧
C++模板编程和标准模板库（STL）
GeiGe123的博客
10-28 225
/ 使用class效果相同，// 为了不和类的定义发生歧义，尽量使用typedef// 也可以定义多个类型，但是定义了一定要用，否则报错。
C++ Template
weixin_34413802的博客
12-18 1002
引言 模板（Template）指C++程序设计设计语言中采用类型作为参数的程序设计，支持通用程序设计。C++ 的标准库提供许多有用的函数大多结合了模板的观念，如STL以及IO Stream。 函数模板 在c++入门中，很多人会接触swap(int&amp;, int&amp;)这样的函数类似代码如下: void swap(int&amp;a , int&amp; b) { int...
什么是函数模板？
dove1202ly的博客
10-22 2590
一、模板是什么？ 所谓模板(templates），就是针对“一个或者多个尚未明确的型别”所撰写的函数或者类别，使用模板时，可以显式地（explicitly）或隐式（implicitly）将型别当作参数来传递。下面是一个例子：template<class T>//T为任意类型 inline const T& max(const T& left,const T& right) //可以定义为内联函数，
函数模板
zys15195875600的博客
08-02 158
以前写一个通用函数一般是函数重载。缺点：代码复用率不高，新类型参数出现，得重写函数。它不能解决返回值不同的问题。而且重载的函数内部大致一样，一错全错。多态，也只是重载的的另外一种体现。为了解决上面的不足所以有了函数模板。 1.函数模板什么？ 答：严格来说函数模板并不是真正意义上的函数，它的类型不明确只有在调用的时候才知道。它是为了函数的通用而存在的。 2.函数模板怎么写？ 格式就是：tem...
侯捷c++笔记stl
08-13
你好！关于侯捷的C++笔记中的STL部分，我可以给你...如果你想深入学习STL，我推荐你阅读侯捷的C++笔记中关于STL的章节，同时也可以参考C++标准库的官方文档。希望这些信息对你有帮助！如果你有其他问题，请随时问我。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一记绝尘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值