【C++】智能指针

最新推荐文章于 2024-06-15 15:08:31 发布
最新推荐文章于 2024-06-15 15:08:31 发布
阅读量575 收藏 21
点赞数 23
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58963318/article/details/138742738
版权

目录

前言

智能指针的使用与原理

RAII

智能指针的原理

 智能指针的拷贝

 std::auto_ptr

auto_ptr的模拟实现

std::unique_ptr

unique_ptr的模拟实现

std::shared_ptr

shared_ptr的模拟实现

赋值运算符重载

shared_ptr的循环引用

std::weak_ptr

前言

上文提及如下程序是一个不安全的程序，因为当第二次以及第二次以后开辟空间失败，程序抛出异常时，原先开辟的资源没有被释放，从而导致内存泄漏，上文给出C++98的解决方案，在此不再过多赘述；

void Func()
{
	int* p1 = new int[10];
	int* p2 = new int[20];
	int* p3 = new int[30];

	delete[] p1;
	delete[] p2;
	delete[] p3;
}
int main()
{
	try
	{
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "unknow exception" << endl;
	}
	return 0;
}

C++11解决上述问题的思想是无论函数是正常结束或者抛异常结束，每层函数栈帧空间都是正常结束，可以利用对象的生命周期来控制程序资源，即创建对象时，自动调用构造函数，因此借助构造函数保存资源，当对象的生命周期结束时，自动调用析构函数，因此可以借助析构函数释放资源；

template<class T>
class SmartPtr
{
public:
	//借助构造函数保存资源
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}
	//借助析构函数释放资源
	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;
		delete[] _ptr;
	}
private:
	T* _ptr;
};

void Func()
{
	SmartPtr<int> sp1 = new int[10];
	SmartPtr<int> sp2 = new int[20];
	SmartPtr<int> sp3 = new int[30];
}

int main()
{
	try
	{
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "unknow exception" << endl;
	}
	return 0;
}

运行结果：

  • 当第一次开辟空间失败时，对象sp1未构造（传递给构造函数的参数ptr没有传递）；
  • 当第二次开辟空间失败时，对象sp2未构造，但是对象sp1会在Func函数的函数栈帧结束时调用析构函数，释放空间；
  • 当第三次开辟空间失败时，对象sp3未构造，但是对象sp1、sp2会在Func函数的函数栈帧结束时调用析构函数，释放空间；

智能指针的使用与原理

RAII

RAII是一种利用对象生命周期来控制程序资源的简单技术；

首先在对象构造时获取资源，其次在对象的生命周期内始终可以访问资源，最后在对象析构的时候释放资源；因此实际上把管理一份资源的责任托管给一个对象；   这种处理方式存在两大好处：

  • 不需要显式地释放资源；

  • 采用此方式，对象所需的资源在其生命期内始终保持有效；

template<class T>
class SmartPtr
{
public:
	//借助构造函数保存资源
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}
	//借助析构函数释放资源
	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;
		delete _ptr;
	}
private:
	T* _ptr;
};

智能指针的原理

上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为；指针可以解引用，也可以通过->去访问所指空间中的内容，因此：SmartPtr模板类中还需要将 * 、->重载，才可让其像指针一样去使用；

template<class T>
class SmartPtr
{
public:
	
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;
		delete _ptr;
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};

int main()
{
	SmartPtr<int> sp1(new int(0));
	SmartPtr<int> sp2(new int(0));
	*sp1 = 10;//测试operator*()

	SmartPtr<pair<string, int>> sp3(new pair<string, int>);
	sp3->first = "apple";// <====> sp3.operator->()->first = "apple";
	sp3->second = 1;//<====> sp3.operator->()->second = 1;
	return 0;
}

运行结果：

 智能指针原理总结：

  •      具有RAII特性；
  •     重载operator * 与operator ->，具有指针一样的行为；

 智能指针的拷贝

template<class T>
class SmartPtr
{
public:
	//借助构造函数保存资源
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}
	//借助析构函数释放资源
	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;
		delete _ptr;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};

int main()
{
	SmartPtr<int> sp1(new int(10));
	SmartPtr<int> sp2(sp1);
	return 0;
}

运行结果：

对象sp1拷贝构造sp2，调用拷贝构造函数，对于内置类型成员进行浅拷贝即值拷贝，对象sp1与对象sp2成员变量_ptr指向同一块空间，对象sp1与对象sp2销毁时，调用析构函数，导致同一块空间二次释放，造成系统崩溃；

若想解决浅拷贝造成的二次析构问题，就要实现深拷贝的拷贝构造函数与拷贝赋值函数吗？

	vector<int> v1 = { 1, 2, 3, 4, 5 };
	vector<int> v2(v1);

	SmartPtr<int> sp1(new int(10));
	SmartPtr<int> sp2(sp1);

 std::auto_ptr

#include <memory>
int main()
{
	std::auto_ptr<int> ap1(new int(10));
	std::auto_ptr<int> ap2(ap1);
	return 0;
}

 监视窗口：

C++标准库中的auto_ptr的本质为将管理权转移，即被拷贝对象ap1将资源管理权转移给拷贝对象ap2，但是导致了被拷贝对象ap1悬空，当使用一个对象拷贝构造另一个对象时，拷贝结束时，被拷贝对象不可被访问，若使用被拷贝对象，易造成系统崩溃；

#include <memory>
int main()
{
	std::auto_ptr<int> ap1(new int(10));
	std::auto_ptr<int> ap2(ap1);

	*ap1 = 20;//对象ap1管理的空间数值修改为20

	return 0;
}

运行结果：

auto_ptr的模拟实现
namespace SmartPtr
{
	template<class T>
	class auto_ptr
	{
	public:

		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}
		
		~auto_ptr()
		{
			cout << "delete:" << _ptr << endl;
			delete _ptr;
		}
		//ap2(ap1)
		auto_ptr(auto_ptr<T>& ap)
		{
			_ptr = ap._ptr;
			ap._ptr = nullptr;
		}
		//ap2=ap1
		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			//检测是否为自己给自己赋值
			if (this != &ap)
			{
				//释放当前对象中的资源
				if (_ptr)
				{
					delete _ptr;
				}
				//转移ap中的资源到当前对象中
				_ptr = ap._ptr;
				ap._ptr = nullptr;
			}

			return *this;
		}

		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
}

结论：auto_ptr是一个失败的设计，也是C++标准库中的耻辱，巨坑无比，因此许多公司明确禁止使用auto_ptr；

std::unique_ptr

#include <memory>
int main()
{
	std::unique_ptr<int> ap1(new int(10));
	std::unique_ptr<int> ap2(ap1);// err: unique_ptr类的拷贝构造函数已删除
	return 0;
}

C++标准库中的unqiue_ptr的本质为禁止拷贝，实现方式有两种，C++98中，拷贝构造函数只声明不实现并且将其置于私有；C++11中，拷贝构造函数声明=delete；

unique_ptr的模拟实现
namespace SmartPtr
{
	template<class T>
	class unique_ptr
	{
	public:

		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

		~unique_ptr()
		{
			cout << "delete:" << _ptr << endl;
			delete _ptr;
		}
		
		//禁用拷贝构造函数
		unique_ptr(const unique_ptr<T>& ap) = delete;
		
		//禁用拷贝赋值函数
		unique_ptr<T>& operator=(const unique_ptr<T>& ap) = delete;
		
		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
}

需要注意的是必须禁用赋值运算符重载函数，若不禁用，由于赋值运算符为默认成员函数，编译器自动生成，对于内置类型成员为值拷贝，浅拷贝会导致同一块空间重复释放；

std::shared_ptr

shared_ptr的原理：通过引用计数的方式来实现多个shared_ptr对象之间共享资源

#include <memory>
int main()
{
	std::shared_ptr<int> sp1(new int(1));//std::shared_ptr::use_count
	cout << sp1.use_count() << endl;//use_count()查看多少对象管理此资源

	std::shared_ptr<int> sp2(sp1);
	cout << sp1.use_count() << endl;

	*sp1 += 10;
	*sp2 += 10;

	return 0;
}

运行结果：

shared_ptr的模拟实现
//设计方案一:每个对象各自有各自的计数
template<class T>
class shared_ptr
{
public:
	//...
private:
	T* _ptr;
	size_t _count;//_count记录多少对象管理_ptr指向的空间
};

上述实现方案是否可行？（绝对不可行）

shared_ptr<int> sp1;
shared_ptr<int> sp2(sp1);

对象析构时，先析构sp2再析构sp1，销毁对象sp2时，引用计数减一，释放空间，但是对象sp1的引用计数仍为1，当销毁对象sp1时，仍然释放已经释放的空间；

//设计方案二:采用整个类专属的静态成员变量完成计数
template<class T>
class shared_ptr
{
public:
	//...
private:
	T* _ptr;
	static size_t _count;//静态成员变量_count记录多少对象管理此资源
};
//静态成员变量初始化
template<class T>//类外需要模版参数,类外声明模版参数
size_t shared_ptr<T>::_count = 0;

上述实现方案是否可行？

shared_ptr<int> sp1;
shared_ptr<int> sp2(sp1);
shared_ptr<int> sp3(new int(5));

 引用计数是每个资源配备一份引用计数，当开辟新空间时，应该给新开辟的空间配备一份新的引用计数，但是静态成员变量属于整个类，属于这个类的所有对象，即新开辟空间的引用计数只有原先的静态计数_count而且将_count改为1，所以上述方案也不可行；

namespace SmartPtr
{
	template<class T>
	class shared_ptr
	{
	public:
		// RAII
		// 创建对象时才需要开辟计数空间并且将引用计数的值置为1
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		~shared_ptr()
		{
			// 析构时，--计数，计数减到0，
			// 说明最后一个管理对象销毁则可以释放资源
			if (--(*_pcount) == 0)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pcount;
			}
		}

		// 拷贝构造 sp2(sp1)
		shared_ptr(const shared_ptr<T>& sp)
		{
			_ptr = sp._ptr;
			_pcount = sp._pcount;

			// 拷贝时++计数
			++(*_pcount);
		}

		// 行为类似指针
		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

		//获取原生指针
		T* get() const
		{
			return _ptr;
		}
		//获取引用计数
		int use_count()
		{
			return *_pcount;
		}
	private:
		T* _ptr;
		int* _pcount;
	};
}
赋值运算符重载

//sp1=sp2
//this-->赋值对象   sp-->被赋值对象
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
    //防止case3的出现，无论自身给自身赋值或者不同的对象管理同一份资源均不发生任何变化
	if (_ptr != sp._ptr)
	{
		//首先赋值对象的引用计数自减1，若减到0即case2,若没有减到0即case1;
		if (--(*_pcount) == 0)
		{
			cout << "delete:" << _ptr << endl;
			delete _ptr;
			delete _pcount;
		}
		_ptr = sp._ptr;
		_pcount = sp._pcount;

		// 拷贝时++计数
		++(*_pcount);
	}
	return *this;
}
shared_ptr的循环引用

shared_ptr的致命缺陷 —— 循环引用

  • 循环引用： 两个或多个对象中shared_ptr成员变量指向对方（即对象之间相互持有彼此的引用计数）造成循环引用，导致对象的引用计数无法归0，从而无法释放对象所占用的内存；
struct ListNode
{
	int _val;

	SmartPtr::shared_ptr<ListNode> _next;
	SmartPtr::shared_ptr<ListNode> _prev;

	ListNode(int val=0)
		:_val(val)
	{}

	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};
int main()
{
	SmartPtr::shared_ptr<ListNode> n1(new ListNode(10));
	SmartPtr::shared_ptr<ListNode> n2(new ListNode(20));

	n1->_next = n2;
	n2->_prev = n1;

	return 0;
}

 解决方案：C++标准库引入了weak_ptr配合shared_ptr解决循环引用，weak_ptr(弱引用智能指针)可以指向shared_ptr持有的对象并且不会增加对象的引用计数；通过weak_ptr可以打破循环引用使得对象的引用计数正确下降为0，从而触发析构函数的调用；

std::weak_ptr

注意：weak_ptr<T>模版类没有重载operator * 与operator ->，因此weak_ptr类型指针只能访问某一shared_ptr指针指向的堆内存空间，无法对其进行修改；

//简化版本weak_ptr的模拟实现
namespace SmartPtr
{
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}

		// 拷贝构造 
		weak_ptr(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
		}
		weak_ptr(const weak_ptr<T>& wp)
		{
			_ptr = wp._ptr;
		}

		//operator=
		weak_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}
		weak_ptr<T>& operator=(const weak_ptr<T>& wp)
		{
			_ptr = wp._ptr;
			return *this;
		}

	private:
		T* _ptr;
	};
}

使用weak_ptr解决shared_ptr的循环引用问题，解决方案如下：

struct ListNode
{
	int _val;

	SmartPtr::weak_ptr<ListNode> _next;
	SmartPtr::weak_ptr<ListNode> _prev;

	ListNode(int val=0)
		:_val(val)
	{}

	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};
int main()
{
	SmartPtr::shared_ptr<ListNode> n1(new ListNode(10));
	SmartPtr::shared_ptr<ListNode> n2(new ListNode(20));

	n1->_next = n2;
	n2->_prev = n1;
	return 0;
}

运行结果：

欢迎大家批评指正，博主会持续输出优质内容，谢谢各位观众老爷观看，码字画图不易，希望大家给个一键三连支持~ 你的支持是我创作的不竭动力~

小呆瓜历险记
关注
  • 23
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++智能指针
05-24
C++ 中推出了强大的智能指针smart_ptr ，本文具体说说 shared_ptr 和 weak_ptr ，特别是 enable_shared_from_this 和 shared_from_this
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
c++智能指针
08-15
c++ weak_ptr在解决shared ptr中出现的循环引用的左右
C++智能指针测试代码
04-15
C++ 7种智能指针测试代码
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1007
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 144
BCSP-X 11题 C++代码详解
【c++进阶(三)】STL之vector的介绍和使用
weixin_62196764的博客
06-15 688
1.vector表示的是可变序列大小的容器2、vector就像数组一样，也采用的连续空间来存储元素，这也意味着可以采用下标对vector的元素进行访问。3、vector与普通数组不同的是，vector的大小是可以动态改变的。4、当vector需要重新分配大小时，其做法是，分配一个新的数组，然后将全部元素移到这个数组当中，并释放原来的数组空间。---这就表明原来指向该位置的迭代器已经失效了，所以在插入和删除数据的时候要返回一个合法的迭代器的位置。
LeetCode 算法：轮转数组c++
小金牛来了
06-09 680
LeetCode 算法：轮转数组c++
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 753
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 319
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 289
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
【C++】 基础复习 ｜ 数据类型，输入，输出流 scanf printf
专注于人工智能的算法与应用
06-11 826
是 C 语言中两个非常重要的标准输入输出函数，它们分别用于从标准输入（通常是键盘）读取数据和向标准输出（通常是屏幕）打印数据。在这种情况下如果想控制输出，即满足一定格式输出，比如保留几位小数什么的，就要用manipulator了。需要变量的地址 ，即前面需要加一个&。函数用于从标准输入读取数据，并根据格式字符串解析这些数据。存储内存地址的变量。用户定义的复合数据类型，用于将不同类型的数据组合在一起。称做流式输入输出，
c++【入门】买文具2
LYK_0910的博客
06-11 132
花花去文具店买了1支笔和1块橡皮，已知笔x元/支，橡皮y元/块，花花付给了老板n元，请问老板应该找给花花多少钱？三个整数x、y、n，分别代表了笔的单价、橡皮的单价和花花付给老板的钱（已知花花付给老板的钱n>=x+y）。一个整数，代表老板应该找给花花的钱。内存限制 : 128 MB。时间限制 : 1 秒。
深度搜索算法3（c++）
mmz1207的博客
06-08 385
农夫约翰总是想要一个农场的地图，所以他拍摄了一张N行M列的卫星照片。一部分的照片看起来像这样： 他认为每个联通块都是一个谷仓或一头奶牛。农夫约翰认为一个联通块是谷仓，当且仅当它是一个完整的矩形，否则该联通块是一头奶牛。在下面的照片中，有三个谷仓（大小分别为2x1,2x5和1x1）和两头奶牛。计算他的卫星照片中谷仓和奶牛的数量。行2..N + 1：行i + 1表示照片的行i包含M个字 符（且不含空格）。行1：两个空格分隔的整数：N和M。行1：照片中的谷仓数量。行2：照片中的奶牛数量。
C++回溯算法
Yigeputongren的博客
06-11 96
【代码】C++回溯算法。
C++ 字符串处理5-手机号邮箱如何脱敏处理
最新发布
阳光日志
06-15 249
**关键词：** C++ 字符串处理 分割字符串 连接字符串 跨平台 **应用场景：** 有些重要信息需要保密，比如手机号、邮箱等，如何在不影响用户阅读的情况下，将这些信息脱敏处理，以保障用户的隐私安全。
C++ Easyx案例实战：Cookie Maker工作室1.0V
快乐星空Maker的博客
06-09 723
有彩蛋！
C++:SLT容器--＞queue
坚持不懈的大白的博客
06-11 228
C++:SLT容器-->queue
C++智能指针最佳实践
05-02
C++智能指针是一种用于管理动态分配的内存的工具，它可以自动释放内存，避免内存泄漏和悬挂指针的问题。以下是C++智能指针的最佳实践： 1. 使用unique_ptr：unique_ptr是C++11引入的一种独占式智能指针，它确保只有一个指针可以访问给定的资源。在使用动态分配的对象时，应该优先考虑使用unique_ptr。例如： ```cpp std::unique_ptr<int> ptr(new int(10)); ``` 2. 使用shared_ptr：shared_ptr是C++11引入的一种共享式智能指针，它可以被多个指针共享，并且会自动释放资源。当多个指针需要访问同一个资源时，应该使用shared_ptr。例如： ```cpp std::shared_ptr<int> ptr1 = std::make_shared<int>(10); std::shared_ptr<int> ptr2 = ptr1; ``` 3. 避免使用裸指针：尽量避免使用裸指针来管理动态分配的内存，因为容易出现内存泄漏和悬挂指针的问题。使用智能指针可以更安全地管理内存。 4. 使用reset()函数：当不再需要一个智能指针时，可以使用reset()函数将其置为空指针或重新指向其他对象。例如： ```cpp std::unique_ptr<int> ptr(new int(10)); ptr.reset(); // 将指针置为空指针 ``` 5. 避免循环引用：当使用shared_ptr时，要注意避免循环引用的问题，因为它可能导致内存泄漏。可以使用weak_ptr来解决循环引用的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小呆瓜历险记

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

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

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

打赏作者

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

抵扣说明：

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

余额充值