C++模板

最新推荐文章于 2022-09-06 21:35:14 发布
最新推荐文章于 2022-09-06 21:35:14 发布
阅读量96 收藏
点赞数
分类专栏： C++二次整理 文章标签： c++ 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38684512/article/details/112276125
版权
本文深入探讨C++中的模板，包括函数模板、类模板、非类型参数，以及模板的实例化、实参推演和特例化。通过示例解释模板在多文件工程中的应用，强调模板代码需放在头文件中。此外，讲解了简易C++STL向量容器的实现，以及空间配置器allocator的概念，展示了如何使用空间配置器管理内存和对象生命周期。
摘要由CSDN通过智能技术生成

C++模板

理解函数模板

#include<iostream>
using namespace std;

/*
	C++函数模板（开发库用，类型参数化）
	优点：只用写一套代码实现逻辑即可，编译器没有减少工作，用户减少了工作

	模板的意义：对类型也可以进行参数化
	int sum(int a,int b){return a+b;} 仅仅对实参的值进行了参数化

	函数模板				出现关键字template模板参数列表，函数模板不进行编译，不知道类型
	模板的实例化			在调用点，根据用户指定的类型或者模板类型参数的推演推导出来需要	什么类型实例化，
	模板函数				实例化后出现的需要编译器编译的函数

	模板类型参数			typename/class
	模板非类型参数			

	模板的实参推演			可以根据用户传入的实参的类型，来推导出模板类型参数的具体类型
	模板的特例化（特化）	特殊的实例化，不是编译器提供的，而是用户提供
	函数模板、模板的特例化、非模板函数的重载关系 非模板函数 == 普通函数
*/

/*
	多文件工程
	连接错误，找不到模板，能找到普通函数和特例化函数
	模板的编译阶段实在调用时才会编译，*UND*
	模板代码必须放在头文件中，在源文件中直接进行include包含

	也可以使用template bool compare<int>(int,int)
	告诉编译器进行指定类型的模板实例化
	不用看到调用点，直接使用用户给定的类型实例化
*/

template<typename T>	//定义一个模板参数列表,定义了两个类型参数，分别用来接受一个类型
bool com(T a, T b)
{
	cout << "template compare" << endl;
	return a > b;
}
//针对com函数模板，提供const char*类型的特例化版本
template<>
bool com(const char* a, const char* b)
{
	cout << "compare <const char*> " << endl;
	return strcmp(a,b)>0;
}

template<typename T, typename E>	//定义一个模板参数列表,定义了两个类型参数，分别用来接受一个类型
bool compare(T a, T b)
{
	cout << "template compare" << endl;
	return a > b;
}
int main()
{
	//compare是一个函数模板的名称，不能直接调用compare(10, 20);
	
	//模板名加一个参数列表，才能变成一个函数名
	//函数调用点，编译器用用户指定类型，从原模版实例化一份函数代码出来
	/*
		模板函数
		从模板，用指定的类型，实例化出来的需要编译的函数
		bool compare<int,int>(int a, int b){return a > b; }
	*/
	compare<int,int>(10, 20);
	compare<double, int>(10, 20.0);

	//模板的实参推演，不会再生成一个int类型的函数，不然会导致重定义问题
	com(10, 20);

	//com(10,20.5)  无法推导出模板类型参数

	/*
		规定模板类型为int 将double等其他参数类型强制转化为int
	*/
	com<double>(10, 23.5);

	/*
		bool compare<const char*>(const char* a, const char* b)
		{
			return a > b; //仅仅是在比较地址,如何比较ASCII码顺序
						  // strcmp(a,b)>0
		}
	*/

	//对于某些类型来说，依赖编译器默认实例化的模板代码，代码处理逻辑是有错误的（字符串类型）
	//优先按照非模板函数处理
	com("aaa", "bbb");
	//发现尖括号处理成模板，先准备实例化模板，发现特例化模板，使用特例化模板
	com<const char*>("aaa", "bbb");
	return 0;
}

非类型参数

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

/*
	函数模板

	模板的非类型参数，必须是整数类型，整数和地址都可以
	冒泡排序的第二个SIZE参数,都是常量，只能使用不能修改



	类模板

*/
template<typename T,int SIZE>	//SIZE非类型参数
void sort(T* arr)
{
	for (int i = 0; i < SIZE - 1; ++i)
	{
		for (int j = 0; j < SIZE - 1 - i; ++j)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

int main()
{
	int arr[] = { 12,23,14,25,34,67,10,2 };
	//const 编译的时候就确定了  使用常变量就不符合规则
	const int size = sizeof(arr) / sizeof(arr[0]);
	sort<int,size>(arr);
	for (int val : arr)
	{
		cout << val << " "<< endl;
	}
}

类模板

#include<iostream>
using namespace std;

/*
	类模板
	类模板=> 实例化 => 模板类

	类模板的选择性实例化，不是所有都实例化，
	运行的时候，调用一个成员函数实例化一个函数
*/

template<typename T = int>//类型参数默认值
class SeqStack	//模板名称
{
public:
	//构造和析构函数名不用加<T>,其他出现模板的地方都加上类型参数列表
	SeqStack<T>(int size = 10)
		:_pstack(new T[size])
		,_top(-1)
		,_size(size)
	{

	}
	~SeqStack<T>()
	{
		delete[] _pstack;
		_pstack = nullptr;
	}
	SeqStack<T>(const SeqStack<T>& stack)
		:_top(stack._top)
		,_size(stack._size)
	{
		_pstack = new T[_size];
		for (int i = 0; i < top; ++i)
		{
			_pstack[i] = stack._pstack[i];
		}
	}
	SeqStack<T>& operator=(const SeqStack<T>& stack)
	{
		//防止自赋值
		if (this == &stack)
		{
			return *this;
		}

		delete[] _pstack;

		_top = stack._top;
		_size = stack._size;
		_pstack = new T[_size];

		for (int i = 0; i < top; ++i)
		{
			_pstack[i] = stack._pstack[i];
		}
	}
	void push(const T& val)
	{
		if (full())
		{
			expand();
		}
		_pstack[top++] = val;
	}
	void pop()
	{
		if (empty())
		{
			return;
		}
		--top;
	}
	T top()const
	{
		if (empty())
		{
			//抛出异常也代表函数逻辑结束返回,不需要保持类型一致
			throw "stack is empty!";
		}
		return _pstack[_top - 1];
	}
	bool full()const
	{
		return _top == _size;
	}
	bool empty()const
	{
		return _top == 0;
	}
private:
	T* _pstack;
	int _top;
	int _size;

	//顺序栈底层数组按2倍的方式扩容
	void expand()
	{
		//new 可以调用malloc构造函数 但是malloc只能开辟内存
		T* ptmp = new T[2 * _size];
		for (int i = 0; i < top; ++i)
		{
			_pstack[i] = stack._pstack[i];
		}
		delete[] _pstack;
		_pstack = ptmp;
		_size = _size * 2;
	}
};

//在模板类外定义模板函数
template<typename T>
void SeqStack<T>::push(const T& val)
{
	if (full())
	{
		expand();
	}
	_pstack[_top++] = val;
}
int main()
{



	return 0;
}

实现简易C++ STL向量容器Vector

#include<iostream>

using namespace std;

/*
	实现C++ STL里面的一个顺序容器vector 向量容器

	容器：
*/

template<typename T>
class vector
{
public:
	vector(int size = 10)
	{
		_first = new T[size];
		_last = _first;
		_end = _first + size;
	}

	~vector()
	{
		cout <<" 析构对象是" <<this->name << endl;
		delete[] _first;
		//_first = _last = _end = nullptr;
	}

	vector(const vector<T>& src)
	{
		int len = src._last - src._first;
		_first = new T[src._end - src._first];
		for (int i = 0; i < len; ++i)
		{
			_first[i] = src._first[i];
		}
		_last = _first + len;
		_end = _first + size;
	}

	vector<T>& operator= (const vector<T>& src)
	{
		if (this == &src)
		{
			return *this;
		}
		delete[] _first;
		int len = src._last - src._first;
		_first = new T[src._end - src._first];
		for (int i = 0; i < len; ++i)
		{
			_first[i] = src._first[i];
		}
		_last = _first + len;
		_end = _first + size;
		return *this;
	}

	//向容器末尾 添加元素
	void push_back(const T &val)
	{
		if (full())
			expand();
		*_last++ = val;
	}
	//从容器末尾删除元素
	void pop_back()
	{
		if (empty())
		{
			return;
		}
		//last本质是指向最后元素的后继位置，first和last之间存在的就是所有的元素
		_last--;
	}
	//返回容器末尾的函数值
	T back() const
	{
		//last存放的是最后一个元素的后继位置，-1之后再会变成最后一个元素
		//不能给last直接解引用，因为last所在的位置并不是有效的元素位置
		return *(_last - 1);
	}
	void show() { cout << "This is" <<name<< endl; }
	bool full() const { return _last == _end; }
	bool empty() const { return _last == _first; }
	int size() const{ return _last - _first; }
	int name;
private:
	T* _first;	//指向数组起始位置
	T* _last;	//指向数组中有效元素的后继位置
	T* _end;	//指向数组空间的后继位置


	//容器的二倍扩容
	void expand()
	{
		int size = _end - _first;
		T* ptmp = new T[2 * size];
		for (int i = 0; i < size; ++i)
		{
			ptmp[i] = _first[i];
		}
		_first = ptmp;
		_last = _first + size;
		_end = _first + 2 * size;
	}
};
int main()
{
	vector<int>vec;
	vec.name = 0;
	for (int i = 0; i < 20; ++i)
	{
		vec.push_back(rand() % 100);
	}

	while (!vec.empty())
	{
		cout << vec.back() << endl;
		vec.pop_back();
	}
	
	return 0;

}

空间配置器

#include<iostream>
using namespace std;

/*
	空间配置器 allocator
	template<class _Ty,class _Alloc=allocator<_Ty>>
	1.内存开辟
	2.内存释放
	3.对象构造
	4.对象析构
*/

//定义容器的空间配置器，和C++标准库的allocator实现一样
template <typename T>
class Allocator
{
public:
	Allocator()
	{

	}
	~Allocator()
	{

	}
	//负责内存开辟
	T* allocate(size_t size)
	{
		return (T*)malloc(sizeof(T) * size);
	}
	//负责内存释放
	void deallocate(void* p)
	{
		free(p);
	}
	//负责对象构造,再开辟好的内存上构造一个值为val的对象
	void construct(T* p, const T& val)
	{
		//定位new	new(buffer)typename[size]
		//指定的内存上，构建一个值为val的对象，会调用T类型的一个拷贝构造
		new(p)T[val];
	}
	//负责对象析构
	void destroy(T* p)
	{
		//调用了p指向的对象的析构函数
		p->~T();
	}

};


template<typename T,typename Alloc = Allocator<T>>
class vector
{
public:
	vector(int size = 10,const Alloc &alloc = Allocator<T>())
		:_allocator(alloc)
	{
		//只开辟有效元素，但是new会全部开辟
		//需要把内存开辟对象构造分开处理

		//不需要new构建无效的对象，所以放弃使用new,使用空间配置器来管理内存
		//_first = new T[size];

		_first = _allocator.allocate(size);
		_last = _first;
		_end = _first + size;
	}

	~vector()
	{
		//只析构有效元素，然后释放_first指针指向的堆内存
		//delete[] _first;
		
		//析构
		for (T* p = _first; p != _last; ++p)
		{
			//把_first指针指向的数组的有效元素进行析构操作
			_allocator.destroy(p);
		}
		//释放堆上的数组内存
		_allocator.deallocate(_first);
		_first = _last = _end = nullptr;
	}

	vector(const vector<T>& src)
	{
		int len = src._last - src._first;
		int size = src._end - src._first;
		//首先开辟空间，然后构造对象，都使用空间配置器完成
		//不能使用new来开辟空间，因为new会自动生成新对象
		//first = new T[src._end - src._first];
		
		//1.开辟空间
		_first = _allocator.allocate(size);
		for (int i = 0; i < size; ++i)
		{
			//_first[i] = src._first[i];
			//在已有的内存上构造对象
			_allocator.construct(_first + i, src._first[i]);
		}
		_last = _first + len;
		_end = _first + size;
	}

	vector<T>& operator= (const vector<T>& src)
	{
		if (this == &src)
		{
			return *this;
		}
		
		//delete[] _first;
		int len = src._last - src._first;
		//_first = new T[src._end - src._first];
		for (T* p = _first; p != _last; ++p)
		{
			//把_first指针指向的数组的有效元素进行析构操作
			_allocator.destory(p);
		}
		_allocator.deallocate(_first);

		int len = src._last - src._first;
		int size = src._end - src._first;
		//首先开辟空间，然后构造对象，都使用空间配置器完成
		//不能使用new来开辟空间，因为new会自动生成新对象
		//first = new T[src._end - src._first];

		_first = _allocator.allocate(size);
		for (int i = 0; i < size; ++i)
		{
			_allocator.construct(_first + i, src._first[i]);
		}
		_last = _first + len;
		_end = _first + size;
		return *this;
	}

	//向容器末尾 添加元素
	void push_back(const T& val)
	{
		if (full())
			expand();
		_allocator.construct(_last, val);
		_last++;
	}
	//从容器末尾删除元素
	void pop_back()
	{
		if (empty())
		{
			return;
		}
		//last本质是指向最后元素的后继位置，first和last之间存在的就是所有的元素
		_last--;
		_allocator.destroy(_last);
	}
	//返回容器末尾的函数值
	T back() const
	{
		//last存放的是最后一个元素的后继位置，-1之后再会变成最后一个元素
		//不能给last直接解引用，因为last所在的位置并不是有效的元素位置
		return *(_last - 1);
	}
	void show() { cout << "This is" << name << endl; }
	bool full() const { return _last == _end; }
	bool empty() const { return _last == _first; }
	int size() const { return _last - _first; }
	int name;
private:
	T* _first;			//指向数组起始位置
	T* _last;			//指向数组中有效元素的后继位置
	T* _end;			//指向数组空间的后继位置
	Alloc _allocator;	//容器的空间配置器对象

	//容器的二倍扩容
	void expand()
	{
		int size = _end - _first;
		//T* ptmp = new T[2 * size];
		
		T* ptmp = _allocator.allocate(2 * size);
		for (int i = 0; i < size; ++i)
		{
			//ptmp[i] = _first[i];
			_allocator.construct(ptmp + i, _first[i]);
		}
		//delete[] _first 会调用所有成员的析构，不管是否有效
		for (T* p = _first; p != _last; ++p)
		{
			_allocator.destroy(p);
		}
		_allocator.deallocate(_first);
		_first = ptmp;
		_last = _first + size;
		_end = _first + 2 * size;
	}
};

class Test
{
public:
	Test() { cout << "Test()" << endl; }
	~Test() { cout << "~Test()" << endl; }
	Test(const Test&) { cout << "Test(const Test&)" << endl; }
private:
};
int main()
{
	//new 不仅仅开辟空间，还会构造对象。
	vector<Test>vec;
	Test T1, T2, T3;

	cout << "_________________________" << endl;
	vec.push_back(T1);
	vec.push_back(T2);
	vec.push_back(T3);
	cout << "_________________________" << endl;
	//如果Test指向了外部资源，pop_back没有释放外部资源，只是使得指针回退，再次添加元素覆盖，无法释放开辟堆内存找不到指针，内存碎片
	//只需要析构对象，然后释放_first指针指向的堆内存。
	//将对象的析构和内存释放分离开
	vec.pop_back();
	cout << "_________________________" << endl;
}
他们说快写一首情歌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《 C++模板》和《C++模板元编程》两本
03-20
C++模板是C++语言中的一个强大特性，它允许程序员创建泛型代码，即能够处理多种数据类型的代码。模板在C++中分为两种主要类型：函数模板和类模板。函数模板用于定义可以接受不同类型参数的函数，而类模板用于创建...
C++模板与STL库介绍
03-18
C++模板和STL库是C++编程语言中的两个核心特性，它们极大地提高了代码的复用性和效率。本文将深入探讨这两个主题，并提供丰富的实践应用示例。 首先，我们来理解C++模板。模板是C++的一个强大工具，它允许程序员...
c++ 模板
weixin_40026739的博客
06-16 1万+
模板是c++的一种特性，允许函数或者类（对象）通过泛型（generic types）的形式表现或者运行模板可以使得函数或类在对应不同的类型（types）的时候正常工作，而无需为每一种类型分别写一份代码。1：函数模板（function tempalte）：使用泛型参数的函数（function with generic parameters）2：类模板（class template）：使用泛型参数的类（class with generic parameters）模板的声明（declaration）其实并未给出一
C++ 模板
weixin_44235615的博客
03-19 1753
基本概念：模板就是建立通用的模具，大大提高代码的复用性。 特点： 模板不可以直接使用，只是一个框架 模板的通用并不是万能的 泛型编程主要利用的思想就是模板 模板分为函数模板和类模板 总结： 函数模板利用关键字template 使用函数模板有两种方式：自动类型推导、显示指定类型 模板的目的是为了提高复用性，将类型参数化 注意事项： 自动类型推导，必须推导出一致的数据类型T，才可以使用 模板必须要确定出T的数据类型，才可以使用 普通函数与函数模板的区别： 普通函数调用时可以发生自动类型转换
c++模板函数
weixin_48984572的博客
09-06 2584
c++函数模板概念，重载，调用
C++模板——template
热门推荐
原来45的博客
06-11 3万+
目录1. 模板2. 函数模板2.1 函数模板概念2.2 函数模板格式2.3 函数模板原理2.4 函数模板的实例化2.5 模板参数的匹配原则2.6 声明定义分离3. 类模板3.1 类模板格式3.2 类模板的实例化3.3 类模板中函数放在类外进行定义时4. 模板分离编译4.1 什么是分离编译4.2 模板的分离编译5. 缺省值，返回值6. 总结...
C++模板(函数模板/类模板)
DR5200的博客
10-05 5273
文章目录一.泛型编程二.函数模板 一.泛型编程 在引入泛型编程之前,我们先来看这样一个问题,怎么做到实现一个通用的交换函数呢? 在C语言阶段我们可能会像下面这样写,需要分别实现不同类型的交换函数,又由于C语言不允许出现同名函数,所以函数名也需要不一样,写起来很繁琐 void Swapi(int* e1, int* e2) { int tmp = *e1; *e1 = *e2; *e2 = tmp; } void Swapd(double* e1, double* e2) { double tmp =
C++模板特化
习惯有你
12-24 1467
模板特化 在学习模板的时候我们用模板来解决了一个add模板函数，实现不同类型的传参相加，实践证明，模板函数比普通函数好用。那么现在如果我们要新增一个需求，就是如果传入的是两个string类型的参数，我们不要简单的拼接，我们要在两个字符串之间添加一个空格，显然模板函数已经无法满足我们的要求，解决方法就是使用模板特化，简单说就是模板的一个特殊化，当传参为两个string类型的时候，不调用模板函数，而是调用特化模板函数，传入其它类型的时候，仍然使用模板函数，如下示例： template &l...
C++模板函数
weixin_45738899的博客
12-06 2万+
模板函数与类模板1.模板函数1.模板函数的声明与定义2.模板函数的调用显式类型调用自动推导3.模板函数的底层实现 1.模板函数 1.模板函数的声明与定义 C++提供了模板(template)编程的概念。所谓模板，实际上是建立一个通用函数或类，其类内部的类型和函数的形参类型不具体指定，用一个虚拟的类型来代表。这种通用的方式称为模板。模板是泛型编程的基础,泛型编程即以一种独立于任何特定类型的方式编写代码。 简单来说，就是我们提供一个抽象的函数，并不具体指定其中数据的类型，而是某个虚拟类型代替。只提供基本的功
C++ 模板函数
01-07
C++模板的使用可以提升代码的通用性、可移植性。方便通用库的开发。 与模板有关的关键字有两个： template 定义模板所用到的关键字。 typename 类型的名字，比如int，double，可以使用类类型，struck类型等。也可以...
C++ 裸指针和智能指针
qq_38684512的博客
12-07 7373
C++ 裸指针和智能指针裸指针的缺陷及实例演示忘记释放指针指向的资源代码逻辑过早结束 导致释放资源的代码执行不到代码运行过程中，代码发生异常了，直接出当前函数栈帧了通过裸指针，访问对象时，无法判断对象是否存活，还是已经析构掉了多个指针指向同一块内存释放导致的失效指针的问题智能指针的优势不带引用计数的智能指针auto_ptr 裸指针的缺陷及实例演示 忘记释放指针指向的资源 class Menory ...
C/C++ 函数符号生成规则
qq_38684512的博客
12-07 902
C/C++ 函数符号生成规则C编译器函数名修饰规则_cdecl调用约定(C标准调用约定)_stdcall约定调用(windows标准调用约定)fastcall调用约定（快速调用约定）C++编译器函数名修饰规则_cdecl调用约定_stdcall调用约定fastcall调用约定_thiscall调用约定(类成员方法的约定)参数表类型代号类参数白开始标志 函数符号是编译器在编译期间创建的一个字符串 用...
C++虚拟地址空间和编译过程
qq_38684512的博客
11-18 617
三块核心内容进程的虚拟地址空间内存划分和布局虚拟地址空间虚拟内存地址布局函数调用堆栈详细过程程序编译链接原理深入了解计算机系统程序员的自我修养 进程的虚拟地址空间内存划分和布局 虚拟地址空间 任何的编程语言 产生两种东西：指令和数据 产生在磁盘上的可执行文件 将程序从磁盘上加载到内存当中 不可能直接加载到物理内存 X86 32位 Linux环境下的 加载到内存 Linux系统会给当前进程分配一个2^32次方大小的空间4G （虚拟地址空间） 它存在，你能看得见，他是物理的 它存在，你看不见，他是透明的
C和C++的区别
qq_38684512的博客
11-18 484
C/C++异同同同为本地编译型语言同为强类型语言异面向过程和面向对象C++支持带默认值参数的函数C++函数支持重载动态内存管理 同 同为本地编译型语言 编译型语言： 直接编译成本地机器码 运行效率快 Go 脚本语言 脚本解释器运行在本地操作系统上 Python Java PHP 同为强类型语言 强/静态类型语言：C/C++/Java 变量定义必须指定类型，定义后类型不能改变 弱/动态类型语言：Py...
C++创建一个类的注意事项
qq_38684512的博客
12-11 439
C++面向对象内存对齐.和->的区别类和对象、this指针构造函数和析构函数深拷贝和浅拷贝 内存对齐 节省CPU在IO上的访问次数 从理论上讲，对任何变量的访问都可以从任何地址开始， 但是实际的计算机系统对基本类型数据在内存中的存放有限制， 他们会要求这个元素首地址的值是4/8的倍数， 大部分处理器并不是按字节块来存取内存的. 它一般会以双字节,四字节,8字节,16字节甚至32字节为单位来存取内存，我们将上述这些存取单位称为内存存取粒度， 如果没有内存对齐机制，数据可以任意存放，一个int变量存
继承与多态
qq_38684512的博客
01-10 370
继承和多态综述继承的本质和原理 综述 1.继承的本质和原理 2.派生类的构造过程 3.重载，覆盖，隐藏 4.静态绑定和动态绑定 5.多态vfptr和vftable 6.抽象类的设计原理 7.多重继承及问题 8.虚基类vbptr和vbtable 9.RTTI 10.C++四种类型强转 继承的本质和原理 #include<iostream> using namespace std; /* 继承的本质和原理 本质：代码的复用， 类和类之间的关系，组合和继承 组合：
C++11中的bind绑定器和function函数对象
qq_38684512的博客
02-12 279
绑定器和函数对象bind1st/bind2nd简单用法bind1st/bind2nd底层实现 bind1st/bind2nd简单用法 #include <iostream> #include <vector> #include <algorithm> #include<functional> #include <ctime> using namespace std; /* 绑定器和函数对象（对象有小括号运算符重载函数） 1.C++ STL中
C++模板元编程深度探索
"C++模板元编程相关学习资料" C++模板元编程是一种在编译时进行计算和代码生成的技术，它是C++语言的一个强大特性，允许程序员利用模板机制来实现泛型编程的更高层次抽象。模板元编程通常涉及到类型级别的计算，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值