【C++STL】第二篇：vector类的介绍及模拟实现

最新推荐文章于 2021-12-04 18:06:32 发布
最新推荐文章于 2021-12-04 18:06:32 发布
阅读量440 收藏 2
点赞数 4
分类专栏： STL C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53505979/article/details/120145750
版权
C++ 同时被 2 个专栏收录
10 篇文章 0 订阅
订阅专栏
STL
3 篇文章 0 订阅
订阅专栏

前言

一、标准库中的vector类

vector类的文档介绍
1、vector是表示可变大小数组的序列容器。
2、就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3、本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
4、vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
5、因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
6、与其它动态序列容器相比（deques, lists and forward_lists）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起lists和forward_lists统一的迭代器和引用更好。

二、vector的使用及模拟实现

📖vector()

vector()无参构造 ，构造一个空容器，没有元素

简单的模拟实现，通过vector()来构造一个空的容器，没有元素

模拟实现：

#include<iostream>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			vector()
				:_start(nullptr)
				, _finish(nullptr)
				, _endOfStorage(nullptr)
			{}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

_start：指向vector的第一个元素。
_finish：指向vector最后一个元素的后一个位置。
__endOfStorage：指向vector容量的后面位置。
在这里插入图片描述

📖vector（size_type n, const value_type& val = value_type()）

vector（size_type n, const value_type& val = value_type()）构造并初始化n个val

构建一个带有n元素的容器。每个元素都是val的复制品。

使用：

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

int main()
{
	vector<int> v1(10,1);
	for(auto& e:v1)
	{
		cout<<e<<" ";
	}
	cout<<endl;
	return 0;
}

在这里插入图片描述
模拟实现：

#include<iostream>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			
			vector(size_t n, const T& val = T())//T()缺省参数//拷贝构造
				:_start(nullptr)
				, _finish(nullptr)
				, _endOfStorage(nullptr)
			{
				T* tmp = new T[n];
				_start = tmp;
				_finish = _start + n;
				_endOfStorage = _start + n;
				T* it = _start;
				while (it!=_finish)
				{
					*it = val;
					it++;
				}
			}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

📖vector (const vector& x)

vector (const vector& x)拷贝构造

以相同的顺序构建一个容器，其中每个元素的副本为x。

使用：

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

int main()
{
	vector<int> v1(10,1);
	vector<int> v2(v1);
	for(auto& e:v2)
	{
		cout<<e<<" ";
	}
	cout<<endl;
	return 0;
}

在这里插入图片描述
模拟实现：

#include<iostream>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			
			vector(const vector<T>& v)
				:_start(nullptr)
				, _finish(nullptr)
				, _endOfStorage(nullptr)
			{
				T*temp = new T[v.capacity()];
				_start = temp;
				for (size_t i = 0;i<v.size();i++)
				{
					_start[i] = v._start[i];
				}	
				_finish = _start + v.size();
				_endOfStorage = _start + v.size();
			}			
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

📖~vector()

~vector()清理数据

模拟实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			~vector()
			{
				assert(!empty());
				delete[]_start;
				_start = _finish = _endOfStorage = nullptr;
			}			
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

📖 iterator begin()和iterator const_iterator begin()

iterator begin()获取第一个数据位置
iterator const_iterator begin()获取第一个数据位置，但是不能修改

模拟实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			iterator begin()
			{
				return _start;
			}
			conat_iterator begin()const
			{
				return _start;
			}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

在这里插入图片描述

📖iterator end()和iterator const_iterator end()

iterator end()获取最后一个数据位置
iterator const_iterator end()获取最后一个数据位置，但是不能修改

模拟实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			iterator end()
			{
				return _finish;
			}
			conat_iterator end()const
			{
				return _finish;
			}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

在这里插入图片描述

📖size() const

size() const;获取数据个数

返回vector中的元素数。这是载体中实际物体的数量，不一定等于其存储容量。

使用：

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

int main()
{
	vector<int> v1(10,1);
	cout<<v1.size()<<endl;
	return 0;
}

在这里插入图片描述
模拟现实：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			size_t size()const
			{
				return _finish - _start;
			}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

📖 capacity() const

capacity() const获取容量大小

返回目前分配给vector的存储空间的大小

模拟实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			size_t capacity()const
			{
				return _endOfStorage - _start;
			}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

📖empty() const

empty() const判断是否为空

返回vector是否为空（即其大小是否为0）

模拟实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			bool empty()
			{
				return _start == _finish;
			}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

📖void reserve (size_type n)

void reserve (size_type n)改变vector的capacity

要求vector容量至少足以包含n元素。
如果 n 大于当前vector容量，则函数会导致容器重新分配其存储，使其容量增加到 n（或更高）。
在所有其他情况下，函数调用不会导致重新分配，并且vector容量不受影响。
此功能对矢量大小没有影响，无法更改其元素.

使用：

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

int main()
{
	vector<int> v1(10,1);
	cout<<"vector当前容量："<<v1.capacity()<<endl;
	for (auto& e : v1)
	{
		cout << e << " ";
	}
	cout<<endl;
	v1.reserve(12);
	cout<<"情况一，12>vector当前容量"<<v1.capacity()<<endl;
	for (auto& e : v1)
	{
		cout << e << " ";
	}
	cout<<endl;
	cout <<"用reserve扩容不会改变vector里的元素" << endl;
	return 0;
}

在这里插入图片描述

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

int main()
{
	vector<int> v1(10,1);
	cout<<"vector当前容量："<<v1.capacity()<<endl;
	v1.reserve(8);
	cout<<"情况一，8<vector当前容量"<<v1.capacity()<<endl;
	cout <<"当n<vector当前容量,vector容量不受影响" << endl;
	cout<<endl;
	return 0;
}

在这里插入图片描述
模拟实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			void reserve(size_t n)//temp是临时变量，当这个函数执行结束时，temp自动销毁
			{
				if (n > capacity())
				{
					size_t sz=size();
					T* tmp = new T(n);//开辟n个T类型的连续的空间
					if (_start)
					{
						for (size_t i = 0; i < sz; i++)
						{
							tmp[i] = _start[i];//这里要用for循环来赋值
						}
						delete[]_start;
					}
					//指针指向新开辟的空间
					_start = tmp;
					_finish = _start + sz;
					_endOfStorage = _start + n;
			}
		}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

注意：在实现reserve()时，我用了for循环来给新开辟的空间赋值，而不是用memcpy。
如果在reserve中使用memcpy来给新开辟的空间赋值的话，在一些情况下会有bug。例如，当vector中是存放着字符串时，然后用reserve开辟更多的空间，就会时新开辟的空间里的_start指向一处被释放的空间，原数据被清理了。
在这里插入图片描述
memcpy会把指向string的指针拷贝到新开辟的空间中，但不会把存放字符串的空间一起拷贝下来，使得在reserve后，旧空间存放字符串的数据被清理了。
而使用for循环来赋值，则是因为通过赋值运算符来调用string中的重载来进行深拷贝。
总结：T如果是内置类型或者是浅拷贝自定义类型（Date），我们可以用memcpy。但T是深拷贝自定义类型（string）就不能使用memcpy，应使用 for+赋值。

📖void resize (size_type n, value_type val = value_type())

void resize (size_type n, value_type val = value_type())改变vector的size

调整容器大小，使其包含n元素。
如果 n 小于当前容器大小，则内容将减少到其第一个 n 元素，删除超出（并销毁它们）的内容。
如果 n 大于当前容器大小，则内容通过在末端插入尽可能多的元素来扩展，以达到 n 的大小。
如果Val被指定，则新元素将初始化为val的副本，否则，它们将具有价值初始化。如果 n 也大于当前的容器容量，则会自动重新分配分配的存储空间。

模拟实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			void resize(size_t n, const T& value = T())
			{
				if (n < size())
				{
					_finish = _start + n;
				}
			else
				{
					if (n>capacity())
					{
						reserve(n);
					}
					while (_finish<_start+n)
					{
						*_finish = value;
						++_finish;
					}
				}
			}	
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

📖void push_back (const value_type& val)

void push_back (const value_type& val)尾插

在vector末端添加一个新的元素，在它当前的最后一个元素之后

代码实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			void push_back(const T& x)
			{
				if (_finish == _endOfStorage)
				{
					int _capacity = 0 == capacity() ? 4 : capacity() * 2;
					reserve(_capacity);
				}
				*_finish = x;
				_finish++;
		}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

📖void pop_back()

void pop_back()尾删

去除载体中的最后一个元素，有效地将容器大小减小一个。

模拟实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			void pop_back()
			{	
				if (empty())
				--_finish;
			}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

在这里插入图片描述

📖iterator insert (iterator position, const value_type& val)

iterator insert (iterator position, const value_type& val)在position之前插入val

模拟实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
		void insert(iterator pos, const T& v)
		{
			assert(pos <= _finish);
			if (_finish==_endOfStorage)
			{
				size_t len = pos - _start;
				size_t _capacity = 0 == _capacity() ? 1 : capacity() * 2;

				reserve(_capacity);
				pos = _start + len;
			}
			iterator end = _fiish - 1;
			while (end>=pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = v;

			_finish++;
		}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

📖iterator erase(iterator pos)

iterator erase(iterator pos)删除position位置的数据

模拟实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
		iterator erase(iterator pos)
		{
			iterator it = pos + 1;
			while (it != _finish)
			{
				*(it - 1) = *it;
				++it;
			}

			--_finish;

			return pos;
		}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

📖void swap (vector& x)

void swap (vector& x);交换两个vector的数据空间

模拟实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
		void swap(vector<T>& v)
		{
			::swap(_start, v._start);
			::swap(_finish, v._finish);
			::swap(_endofstorage, v._endofstorage);
		}

		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

📖 reference operator[] (size_type n)

reference operator[] (size_type n)像数组一样访问

模拟实现：

#include<iostream>
#include<assert.h>
using namespace std;
namespace cxy
{
	template <class T>//类模板
	class vector
	{
		public:
			typedef T* iterator;
			typedef const T* conat_iterator;
			T& operator[](size_t i)
			{
			assert(i < size());

			return _start[i];
			}
		private:
			iterator _start;
			iterator _finish;
			iterator _endOfStorage;
	};
}

到这里就结束了，有一些不对的地方希望指出，共同学习。

世_生
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
C++ 栈和队列 Vector
周健华的专栏
08-18 1万+
原帖 http://blog.csdn.net/zhy_cheng/article/details/8090346 使用标准库的栈和队列时，先包含相关的头文件 #include #include 定义栈如下： stack stk; 定义队列如下： queue q; 栈提供了如下的操作 [cpp] view plaincopy
vector的实现原理
bwabdbkjdbkjwabd的博客
11-01 805
vector 是一段连续的线性内存空间。 Vector类维护3 个迭代器（三个类型指针）来表示： start,finish,end_of_storage 其中，start 指向的是 vector 容器对象的起始字节位置；last 指向当前最后一个元素的末尾字节；end_of_storage指向整个 vector 容器所占用内存空间的末尾字节。 start 和 finish 可以用来表示 vector 容器中目前已被使用的内存空间； finish和 end_of_storage 可以用来表示 vector 容
C++用Vector实现栈的功能小试牛刀
u011490194的专栏
12-04 1352
#include <iostream> #include <vector> using namespace std; int main() { vector<char> stack(0); char tmp; do{ cin>>tmp; if(tmp != '#'){ stack.push_back(tmp); }else{ stac.
【C++学习之（四）】标准库 vector
森森猪的博客
03-30 150
模板（template）：c++ 有类模板和函数模板 模板不是具体的类或者函数 编译器根据模板创建的类或者函数的过程叫做实例化，当使用模板时应该告诉编译器 应该把类或者函数实例化何种类型 vector就是一个类模板 class template 定义和初始化vector对象 列表初始化只能用花括号 vector<string> s("the","c","is");//错误 ...
C++ 实现堆栈stack类模板
04-07
实现堆栈stack类模板，类模板的模型为：堆栈按数组索引减小的方向增长.
C++精选代码库。包含常用STL容器模拟实现、algorithm算法头文件函数demo
最新发布
03-08
在C++编程语言中，STL（Standard Template Library，标准模板库）是其核心部分，提供了高效且功能强大的数据结构和算法。这个精选代码库显然专注于C++的STL容器和algorithm头文件中的函数，这些都是C++程序员必备的...
C++ STL泛化演技比赛编程
03-22
5. 演讲比赛模拟：在实际编程中，可以使用STL容器来存储参赛者、评委、评分等信息。例如，使用`vector`或`list`存储参赛者列表，`map`存储评委与评分的关系，`set`记录分数以去重。通过泛型算法进行数据处理，如排序...
蓝桥杯省赛：2018年B组C++（第九届）题目及答案
04-03
【蓝桥杯省赛：2018年B组C++（第九届）题目及答案】 蓝桥杯是一项全国性的专业编程竞赛，旨在提升大学生在软件和信息技术领域的创新能力与实践能力。2018年的第九届蓝桥杯省赛B组主要针对C++语言的编程技能进行考核...
C++ - 使用标准库实现事件和委托，信号和槽机制
10-17
在C++中，虽然没有内置的事件和委托支持，但可以通过一些设计模式或第三方库来实现，例如使用STL（Standard Template Library）中的函数对象和回调函数。本文将探讨如何利用C++标准库来模拟事件和委托的概念，尤其是...
蓝桥杯省赛：2015年B组C++（第六届）题目及答案
04-03
2. **类与对象**：类是C++中面向对象编程的基础，它是数据和操作这些数据的方法的集合。对象则是类的实例，通过类可以创建多个具有相同属性和行为的对象。在蓝桥杯中，设计和使用类来解决问题是常见的任务。 3. **...
C++标准库类vector
zone的博客
03-09 129
C++标准库类vector vector表示对象的集合，其中所有对象的类型都相同。集合中的每个对象都有一个与之对应的索引，用于访问对象。因为vector容纳着其他对象，所以它也常被称为“容器（container）”。 要想使用vector，必须包含适当的头文件。 #include<vector> using std::vector; vector是一个类模板。模板本身不是类或函数，相反可以将模板看作为编译器生成类或函数编写的一份说明。编译器根据模板创建类或函数的过程称为实例化。当使用模板时，需
数据结构之栈原理（Vector）
OAH`Zero
07-13 617
栈接口 public E push(E item)； public synchronized E pop()； public synchronized E peek()； public boolean empty()； public synchronized int search(Object o)； 底层实现是Vector public class Stack extends Vector {…} 采用是继承的方式，也就是说Stack也可以使用Vector其他方法。 Vector分析 构造方法 创
MyTL我的模板库第一篇，Stack栈类双向链表实现
zanllp的博客
01-16 428
一直很想造一个模板库，趁着放假有时间继续完成，部分类原型在在几个月就已经完成，经过不断迭代勉强能用，准备在未来完成的web后端服务器中尽可能的多使用MyTL。c++的内存管理异常的复杂，尽管使用了智能指针但还是在内存管理这块花了三分之二以上的时间。 MyTL的GitHub Stack的GitHub amespace MyTL { //保存数据的节点 双向链表 template&amp;lt;type...
基于Vector实现C++中的适配器stack（顺序栈）
ChaseRaod的博客
05-02 1991
前面我们讲过用模板实现顺序表的代码实现 模板顺序表 而实际应用中，我们常需要将一种接口转换为用户所需要的另一种接口，这就要用到C++中的适配器，对原本的程序进行一层包装。栈就是其中的一种。 栈遵循后进先出的规则，其插入和删除都是在栈顶操作，是一种特殊的线性顺序表，因此，实现栈我们通常建立在顺序表的基础上。srack不允许遍历，也不提供迭代器。 下面是栈的代码实现：#define _CRT
【C++】vector容器的模拟实现
ly_6699的博客
03-10 1035
vector容器实际是一个动态数组，它与array的操作非常相似。最大的区别就在于vector的“动态”，动态的理解就是数组的扩容由vector内部机制实现动态开辟空间，无需用户手动操作（申请新空间-复制元素-释放原空间）。 下面我将通过对vector的理解，自己模拟实现vector的基本操作方法，供大家更好的理解这个容器。 下面是vector函数实现的思想，最下面附有笔者完整代码和测试类，有需要的自取~
OpenCv库函数（types_c.h)持续更新
sinat_33816866的博客
02-23 2761
#ifndef __OPENCV_CORE_TYPES_H__ #define __OPENCV_CORE_TYPES_H__ #if !defined _CRT_SECURE_NO_DEPRECATE && defined _MSC_VER #  if _MSC_VER > 1300 #    define _CRT_SECURE_NO_DEPRECATE /* to avoid
c语言 可变长数组,C++ vector，STL vector（可变长的动态数组）详解
weixin_32270483的博客
05-19 442
vector 是顺序容器的一种。vector 是可变长的动态数组，支持随机访问迭代器，所有 STL 算法都能对 vector 进行操作。要使用 vector，需要包含头文件 vector。在 vector 容器中，根据下标随机访问某个元素的时间是常数，在尾部添加一个元素的时间大多数情况下也是常数，总体来说速度很快。在中间插入或删除元素时，因为要移动多个元素，因此速度较慢，平均花费的时间和容器中的元...
【C++】Vector类的模拟实现
qq_44109833的博客
11-14 184
自己写一个Vector的简单模拟实现，来加深自己对vector的理解 #include<iostream> #include<assert.h> #include<string> using namespace std; template<class T> class Vector { //typedef T* iterator;//放到这里默认认...
使用std::vector作为管理动态数组的优先选择
11-30 802
本文来自: 乘风原创程序(http://www.qqcf.com) 详细出处参考：http://study.qqcf.com/web/530/119818.htm 摘要: 本文介绍了C++标准库中的容器类vector，分析了它的优点，并且建议在应用程序中使用它作为动态数组的优先选择，而不是MFC的CArray在一些使用 MFC 的程序中，经常看到许多程序使用 CArray的设计问题
C++标准模板库STL详解：容器、迭代器与算法
"这篇资料是关于C++编程中第九章的内容，主要讲解了标准模板库STL。STL是一个包含了一系列通用程序组件的库，尤其是类模板和函数模板，用于提高编程效率。它由容器、迭代器、算法、函数对象、内存分配器和适配器等六...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

世_生

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

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

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

打赏作者

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

抵扣说明：

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

余额充值