【C++】vector介绍+模拟实现

最新推荐文章于 2024-06-11 23:13:49 发布
最新推荐文章于 2024-06-11 23:13:49 发布
阅读量1k 收藏 28
点赞数 22
文章标签： c++ vector
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79031646/article/details/138913346
版权

本章博客是对vector的介绍，有需要借鉴即可。

目录

vector详情链接：LINK

1.vector介绍

vector的嵌套定义

vector支持嵌套自定义类型使用，即一个vector里面每个元素也可以嵌套进另一个vector…当然也可以是其他类型

eg1:vector < string >
在这里插入图片描述
eg2:vector<vector>

在这里插入图片描述
具体来说，以示例2来举例，编译器先根据模板开辟出一个vector< int >，之后再根据这个vector< int >开一个vector<vector< int >>出来。

在这里插入图片描述

vector调用[][]与二维数组[][]的底层区别

在语法上，我们可以定义一个vector<vector< int >>和一个二维数组，如下：

#include<vector>

vector<vector<int>> vv;
int arr[5][10];

//调用：
vv[i][j];
arr[i][j];

那这两个调用方式有什么区别呢？

  • 在语法上看，形式是一致的
  • 在底层实现上，是不一致的
    • 二维数组是解引用指针来做到访问的
    • vector则是连续调用两个[]重载函数来实现访问的


可以通过做下面题目来进行体会：
杨辉三角:LINK
在这里插入图片描述

在这里插入图片描述

//参考题解：
class Solution {
public:
    vector<vector<int>> generate(int numRows) 
    {
        vector<vector<int>> ret;
        
        //开空间
        ret.resize(numRows);
        for(size_t i = 0; i < numRows; i++)
        {
            ret[i].resize(i+1);
        }

        //给值
        for(size_t i = 0; i < ret.size(); i++)
        {
            for(size_t j = 0; j <= i; j++)
            {
                if(j == 0 || j == i)
                {
                    ret[i][j] = 1;
                }
                else
                {
                    ret[i][j] = ret[i-1][j] + ret[i-1][j-1];
                }
            }
        }

        return ret;
    }
};

2.vector模拟

2.1vector模拟代码

从一些开源的vector源文件中可以了解到，vector是由迭代器进行维护的。所以下面整体的模拟实现逻辑是用到了三个简化的迭代器指针来对vector进行维护。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>

using namespace std;

namespace bit
{
	template<typename T>
	class vector
	{
	private:
		typedef T* iterator;
		typedef const T* const_iterator;

		iterator _start;
		iterator _finish;
		iterator _endofstorage;

	public:
		//构造函数
		//无参
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{}

		//拷贝构造
		// v2(v1)
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(v.capacity());
			for (auto& e : v)
			{
				push_back(e);
			}
		}
		//迭代器构造函数
		template<typename InputIterator>
		vector(InputIterator first, InputIterator last)//会根据传进来的参数自动推导类型,至于为什么不用T，因为写T一定是得传与类对象一致的参数，但是这样另改一个参数可以传其他的参数
		{
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}
		//用n个值初始化，构造函数
		vector(size_t n, const T& val= T())//注意：经典调用问题
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}
		vector(int n, const T& val= T())//注意：经典调用问题
		{
			reserve(n);
			for (int i = 0; i < n; i++)
			{
				push_back(val);
			}
		}
		//C++11新语法
		// vector<int> v1 = { 1,2,3,4,5,6,7,8,9,10 };
		vector(initializer_list<T> il)
		{
			reserve(il.size());
			for (auto& e : il)
			{
				push_back(e);
			}
		}

		//赋值运算符重载
		// v1 = v3
		void swap(vector<T>& v)
		{
			std::swap(this->_start, v._start);
			std::swap(this->_finish, v._finish);
			std::swap(this->_endofstorage, v._endofstorage);
		}

		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}

		//析构函数
		~vector()
		{
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}

		//迭代器
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

		bool empty()
		{
			return _finish == _start;
		}

		//size与capacity
		const size_t size() const
		{
			return _finish - _start;
		}

		const size_t capacity() const
		{
			return _endofstorage - _start;
		}

		//resize
		void resize(size_t n, const T& val = T())//内置类型有默认构造
		{
			if (n > capacity())
			{
				//扩容
				reserve(n);
				//填入数据
				while (_finish < _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
			else
			{
				//对其他视而不见
				_finish = _start + n;
			}
		}

		//开空间
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t old_size = size();
				//申请一块新空间
				iterator temp = new T[n];
				//把值原来的值拷贝过去
				//memcpy(temp, _start, sizeof(T) * size());//深拷贝大坑，如果里面仍然是一个需要深拷贝的类型的话，那么这个地方就会指向同一块空间，到时候析构就直接崩溃。
				for (size_t i = 0; i < old_size; i++)
				{
					temp[i] = _start[i];//这样就可以调用类对象的拷贝构造，而对应的类对象的拷贝构造是用深拷贝去做的。
				}
				//销毁原来的空间
				delete[] _start;
				//把新空间赋给类
				_start = temp;
				_finish = temp + old_size;//但是注意，这个size已经不是我们需要的size了，所以要在之前处理一下
				_endofstorage = temp + n;
			}
		}

		//尾插
		void push_back(const T& val)
		{
			insert(_finish, val);//直接复用insert
		}
		//任意插入
		void insert(iterator pos, const T& val)
		{
			//断言
			assert(pos <= _finish && pos >= _start);

			//扩容
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : 2 * capacity());
				// 如果扩容了要更新pos --> 迭代器失效！！！其实也可以在下面直接去更新pos指针
				pos = _start + len;
			}

			//移动数据
			iterator it = _finish - 1;//这个时候指向的是最后一个有效元素
			while (it >= pos)
			{
				*(it + 1) = *it;
				--it;
			}

			//插入数据
			*pos = val;
			//更新一下finish指针
			_finish++;
		}

		//删除
		//任意删除
		iterator erase(iterator pos)
		{
			//断言
			assert(pos < _finish && pos >= _start);

			//移动数据
			iterator it = pos + 1;
			while (it < _finish)
			{
				*(it - 1) = *it;
				it++;
			}

			_finish--;

			return pos;
		}

		//尾删
		void pop_back()
		{
			assert(!empty());

			--_finish;
		}

		//可读可写
		T& operator[](size_t pos)
		{
			assert(pos < size());

			return *(_start + pos);
		}
		//仅可读
		const T& operator[](size_t pos) const
		{
			assert(pos < size());

			return *(_start + pos);
		}


	};
}

int main()
{
	//bit::vector<int> v;
	/*v.insert(v.begin(), 5);
	v.insert(v.begin(), 4);
	v.insert(v.begin(), 3);
	v.insert(v.begin(), 2);
	v.insert(v.begin(), 1);*/

	//bit::vector<int> v2;
	//v2 = v;

	//std::string str("123456");

	/*bit::vector<int> v(10, 3);*/
	
	/*bit::vector<int> v = { 1,2,3,4,5,6 };
	for (size_t i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;*/

	bit::vector<string> vs;
	vs.push_back("hello");
	vs.push_back("hello");
	vs.push_back("hello");
	vs.push_back("hello");
	vs.push_back("hello");
	vs.push_back("hello");
	vs.push_back("hello");

	for (size_t i = 0; i < vs.size(); i++)
	{
		cout << vs[i] << " ";
	}
	cout << endl;

	//8：外面的迭代器有可能会因为扩容的缘故而失效，每次使用前应该再次更新迭代器而不是直接进行使用之前使用过的。
	//9：erase也有可能会因为迭代器问题失效而崩溃
	return 0;
}

2.2reserve扩容的细节

细节一：迭代器失效问题

错误代码示例：

//开空间
void reserve(size_t n)
{
	if (n > capacity())
	{
		//申请一块新空间
		iterator temp = new T[n];
		//把值原来的值拷贝过去
		//memcpy(temp, _start, sizeof(T) * size());//深拷贝大坑，如果里面仍然是一个需要深拷贝的类型的话，那么这个地方就会指向同一块空间，到时候析构就直接崩溃。
		for (size_t i = 0; i < old_size; i++)
		{
			temp[i] = _start[i];//这样就可以调用类对象的拷贝构造，而对应的类对象的拷贝构造是用深拷贝去做的。
		}
		//销毁原来的空间
		delete[] _start;
		//把新空间赋给类
		_start = temp;
		_finish = temp + size();//但是注意，这个size已经不是我们需要的size了，所以要在之前处理一下
		_endofstorage = temp + n;
	}
}

问题：这个主要是_finish看着是更新了，但是并没有更新的缘故，因为_finish更新的结果是错误的，这个_finish是之前空间的地址，所以这个地方是个坑。
那该怎么处理呢？
改正：算相对位置，在释放完原空间之后再根据相对位置old_size来推算_finish的指向。
改正代码示例：

//开空间
void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t old_size = size();
		//申请一块新空间
		iterator temp = new T[n];
		//把值原来的值拷贝过去
		//memcpy(temp, _start, sizeof(T) * size());//深拷贝大坑，如果里面仍然是一个需要深拷贝的类型的话，那么这个地方就会指向同一块空间，到时候析构就直接崩溃。
		for (size_t i = 0; i < old_size; i++)
		{
			temp[i] = _start[i];//这样就可以调用类对象的拷贝构造，而对应的类对象的拷贝构造是用深拷贝去做的。
		}
		//销毁原来的空间
		delete[] _start;
		//把新空间赋给类
		_start = temp;
		_finish = temp + old_size;//但是注意，这个size已经不是我们需要的size了，所以要在之前处理一下
		_endofstorage = temp + n;
	}
}

细节二：reserve的深层浅层拷贝问题
错误代码示例：

//开空间
void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t old_size = size();
		//申请一块新空间
		iterator temp = new T[n];
		//把值原来的值拷贝过去
		memcpy(temp, _start, sizeof(T) * size());//深拷贝大坑，如果里面仍然是一个需要深拷贝的类型的话，那么这个地方就会指向同一块空间，到时候析构就直接崩溃。
		
		//销毁原来的空间
		delete[] _start;
		//把新空间赋给类
		_start = temp;
		_finish = temp + old_size;//但是注意，这个size已经不是我们需要的size了，所以要在之前处理一下
		_endofstorage = temp + n;
	}
}

问题：这个问题主要是memcpy是进行按照字节进行浅层拷贝的一个库函数，如果拷贝的内容需要深层拷贝，用memcpy会直接崩溃，崩溃的原因在于两次析构同一块地址。
在这里插入图片描述
改正：出错的原因在于memcpy的浅拷贝问题，我们可以调用需要拷贝类的对应深层拷贝构造去处理。下面就是去调用对应的赋值函数，其赋值函数的实现逻辑是用深层拷贝实现的。

改正代码：

//开空间
void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t old_size = size();
		//申请一块新空间
		iterator temp = new T[n];
		//把值原来的值拷贝过去
		//memcpy(temp, _start, sizeof(T) * size());//深拷贝大坑，如果里面仍然是一个需要深拷贝的类型的话，那么这个地方就会指向同一块空间，到时候析构就直接崩溃。
		for (size_t i = 0; i < old_size; i++)
		{
			temp[i] = _start[i];//这样就可以调用类对象的拷贝构造，而对应的类对象的拷贝构造是用深拷贝去做的。
		}
		//销毁原来的空间
		delete[] _start;
		//把新空间赋给类
		_start = temp;
		_finish = temp + old_size;//但是注意，这个size已经不是我们需要的size了，所以要在之前处理一下
		_endofstorage = temp + n;
	}
}

在这里插入图片描述

2.3insert函数细节

问题：这个insert有一个点值得注意，就是在扩容之后，他就会重新开空间进行拷贝嘛，但是insert中要记得及时更新pos指针，不然这个pos指针还是指向原位置。

错误代码示例：
在这里插入图片描述

改正：这个简单，扩容之后及时更新一下pos指针就行了。

改正代码示例：
在这里插入图片描述

2.4构造函数细节

上面实现的那一堆构造函数其实有个坑
问题：当存在一个构造模板和一个构造函数时候，可能会出现编译器调用不符合我们期望的问题。
比如：vector v1(10, 1);这个地方关键是因为vector v1(10, 1)函数模板和函数构造都可以匹配，只不过说模板更好一些而已
错误示例：
在这里插入图片描述
改正：参考库源码的实现，直接对第二个函数进行int重载就行了。
改正示例：下面第三个函数就是直接重载实现的。

//迭代器构造函数
template<typename InputIterator>
vector(InputIterator first, InputIterator last)//会根据传进来的参数自动推导类型,至于为什么不用T，因为写T一定是得传与类对象一致的参数，但是这样另改一个参数可以传其他的参数
{
	while (first != last)
	{
		push_back(*first);
		first++;
	}
}
//用n个值初始化，构造函数
vector(size_t n, const T& val= T())//注意：经典调用问题
{
	reserve(n);
	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}
vector(int n, const T& val= T())//注意：经典调用问题
{
	reserve(n);
	for (int i = 0; i < n; i++)
	{
		push_back(val);
	}
}


\

思考：这个第一个构造函数为什么实现为模板的形式呢？
这个地方主要是为了兼容其他容器的迭代器。
比如：

string str("abcd");
		vector<int> v3(str.begin(), str.end());
		print_vector(v3);

2.5CPP11构造函数解释

从上面那一堆构造代码中，我们可以发现这样一个构造函数代码：

//C++11新语法
// vector<int> v1 = { 1,2,3,4,5,6,7,8,9,10 };
vector(initializer_list<T> il)
{
	reserve(il.size());
	for (auto& e : il)
	{
		push_back(e);
	}
}

解释：这个主要是为了实现CPP11的一个新语法，这个语法可以实现花括号整体构造的效果，vector库中是新实现了一个类进行实现的，当然我模拟实现的这个也是直接调用的库中实现的一个类。

具体用法如下：
在这里插入图片描述
底层：实际底层上，这个玩意就是通过两个指针进行维护的，一个指向花括号的第一个元素，第二个指针指向最后一个元素，因为空间上是连续进行存储的，所以说可以用迭代器挨个遍历就行了。

2.6单参数的构造函数支持隐式类型转换

比如下面：
在这里插入图片描述
解释：
一般来说，我们如果push进vector一个字符串，需要大概两个动作，一是把“”字符串先构造出一个string对象，然后再将其拷贝构造到push_back函数中作为形参。

但是呢，这个时候因为单参数构造函数支持隐式类型转换的缘故，所以直接把“”字符串隐式转换为string，然后直接进行调用构造函数。

这个隐式类型转换大大方便了我们写代码，这里简单一提。

2.7迭代器失效问题

我们模拟实现的整个victor底层都是用三个迭代器进行维护的，一旦迭代器出问题，那就很可能会挂。

结论1：外面的迭代器有可能会因为扩容的缘故而失效，每次使用前应该再次更新迭代器而不是直接进行使用之前使用过的。
比如说：
在这里插入图片描述
解释：这里的失效原因就是扩容时候新开了一块空间，虽然里面的迭代器及时进行更新了，但是外面的迭代器it没有及时进行更新，还摁着旧空间进行访问，自然会出问题了。

结论2：erase也有可能会因为迭代器问题失效而崩溃
比如说下面有例子：让你删除偶数并且打印出来
在这里插入图片描述
通过上面例子可以发现，三组例子出现了三个不同的结果。

原因：这个问题本质上就是迭代器失效问题。

怎么办改正呢？
改正：库函数给出了答案。每次删除元素之后返回最新的迭代器即可。
在这里插入图片描述
所以然后我们可以修改一下我们的模拟erase()的代码：

iterator erase(iterator pos)
{
	//断言
	assert(pos < _finish && pos >= _start);

	//移动数据
	iterator it = pos + 1;
	while (it < _finish)
	{
		*(it - 1) = *it;
		it++;
	}

	_finish--;

	return pos;
}

下次调用完erase之后更新一下调用的迭代器指针就行了哈。

3.总结

其实有一定基础的话写得出victor的简化模拟还可以凑合一下的，不过其中的一些细节需要把握一下。

EOF

睡觉待开机
关注
  • 22
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++之vector深度剖析
aaaaauaan的博客
11-03 2247
C++之vector深度剖析1.vector的介绍及使用1.1 vector的介绍1.2 vector的使用1.2.1 vector的定义1.2.2 vector iterator 的使用1.2.3 vector 空间增长问题1.2.3 vector 增删查改1.2.4 vector 迭代器失效问题2.vector深度剖析及模拟实现 1.vector的介绍及使用 1.1 vector的介绍 vector是表示可变大小数组的序列容器。 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可
【C++】vector笔记+模拟实现
iluo12的博客
07-01 3125
vector笔记和实现
C++ Vector用法详解
09-03
主要介绍了C++ Vector用法详解,vector是C++标准模版库(STL,Standard Template Library)中的部分内容,本文详细介绍了它的方方面面,需要的朋友可以参考下
c++ vector模拟实现代码
08-25
vector是C++ STL中一个非常重要的容器，了解 vector 的底层实现原理，可以很好的帮助我们更加熟练的使用vector。这篇文章通过实例代码给大家介绍c++ vector模拟实现，感兴趣的朋友跟随小编一起看看吧
C++ vector使用介绍以及模拟实现
凡事都是靠练习
07-30 815
本文介绍关于C++STL库中的vector容器，了解它的基本接口最后模拟实现vector容器以提高对其理解
C++入门之vector的模拟实现
cls的博客
03-26 1067
vector源代码的大致框架,vector本质就是一个模板类 vector的成员变量不再是我们熟悉的size，capacity，而是变成了功能一致的三个指针 namespace pxl { template<class T> class vector { public: typedef T* iterator; private: iterator _start; iterator _finish; iterator _endofstora.
C++模拟实现vector
03-07
C++模拟实现vector
模拟实现Vector的基本功能
05-26
用c++开发语言，模拟是下std标准库中的Vector基本的功能，复习下Vector标准库的相关知识，特留下此笔记
Vector各个接口模拟实现
08-27
Vector各个接口模拟实现
【C++】vector 模拟实现
m0_51064412的博客
08-05 1324
文章目录一.vector介绍二. vector的模拟实现1. private成员变量及迭代器2. 容量操作接口2.1 size和capacity2.2 reserve2.2 resize3. 默认成员函数3.1 构造函数3.2 拷贝构造3.3 赋值重载4. 修改操作接口4.1 insert4.2 erase 一.vector介绍 vector是表示可变大小数组的序列容器 就像数组一样，vector也采用连续的存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不
C++ vector模拟实现
Wzs040810的博客
01-10 3411
C++ STL vector模拟实现
【C++】vector的认识+模拟实现
Pursue quality, not quantity.
12-01 1488
vector万字详解，由浅到深，快进来看看吧！
C++ vector用法详解
热门推荐
wxy2020915的博客
09-08 9万+
C++ vector用法详解
C语言中指针的说明
ZWW_zhangww的博客
06-05 1078
在C语言当中，我们可以将指针理解为内存当中存储的地址，就像生活当中，一个小区里面，在小区里面有很单元，每一栋单元，单元内的房间有着不同的房间号，我们可以同过几栋几单元去寻找我们想要找到的房间，同样的，我们在C语言当中，指针就是我们寻找想要的房间的一种手段。
【C语言从入门到入土】第六章 指针(下)
v13111329954的博客
06-08 656
本文主要介绍了指针偏移，通过指针引用数组，指针数组，数组指针，函数指针，指针函数，二级指针
C++|哈希结构封装unordered_set和unordered_map
最新发布
weixin_68201503的博客
06-11 572
上一篇章，学习了unordered系列容器的使用，以及哈希结构，那么这一篇章将通过哈希结构来封装unordered系列容器，来进一步的学习他们的使用以及理解为何是如此使用。其实，哈希表的封装方式和红黑树的封装方式形式上是差不多的，如果有了红黑树的封装理解经验，我相信在理解哈希封装的过程会减少负担的。当然，在使用哈希结构中采用的是更具代表的哈希桶，接下来进行封装。
c++ - 模板(二)
2302_79539362的博客
06-05 954
TYPE是类型按道理来说没有问题，但是编译器在检查到这里是就会出现歧义，不知道TYPE是类型还是静态变量，所以就会报错。给模板初始值与给函数初始值类似，当需要给一部分缺省值时，参数缺省值必须从右向左给，中间不能留着参数不给缺省值。非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。另一种解决方法就是直接写一个该类型的函数，这个函数会与模板函数构成重载，并且符合的话会被优先使用。在没有被实例化时，编译器只会对函数进行语法等检查，不会查看类内部细节，如上面的。
C++中的左值和右值
weixin_47987343的博客
06-04 242
左值通常与变量和持久数据关联。右值通常与临时数据和表达式的结果关联。右值引用提供了一种操作右值并优化资源管理和性能的方式。
c++模拟实现vector
09-01
引用和提供了关于实现vector的两种方法。其中，引用展示了一个使用reserve和push_back方法的示例，而引用展示了一个使用new和memcpy函数的示例。这两种方法都是常见的实现vector的方式。 在第一种方法中，通过reserve函数可以预留足够的内存空间，然后使用push_back函数逐个将元素添加到vector中。这种方法的好处是可以避免不必要的内存重分配，提高了效率。 而第二种方法使用new操作符在堆上分配内存空间，并使用memcpy函数将已有的vector对象的数据复制到新的内存空间中。通过这种方式，可以实现深拷贝，即两个vector对象拥有独立的内存空间。这种方法的好处是可以在不修改原始vector对象的情况下创建一个新的vector对象。 除了以上两种方法，还可以使用其他方式实现vector类。例如，可以使用动态数组来实现vector的底层数据结构，然后通过成员函数实现vector的各种操作，如增加、删除、查找等。 总结来说，c语言模拟实现vector的关键是动态内存管理和对元素的增删改查操作。可以使用预留空间和逐个添加元素的方式，也可以使用动态数组和复制数据的方式来实现vector类。具体的实现方式可以根据需求和实际情况选择。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [C++——vector模拟实现](https://blog.csdn.net/weixin_49449676/article/details/126813526)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值