C++容器--list

最新推荐文章于 2024-01-05 22:48:21 发布
最新推荐文章于 2024-01-05 22:48:21 发布
阅读量301 收藏
点赞数
分类专栏： C++初级知识点汇总
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Thinker_serious/article/details/99608150
版权

list介绍

list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且可以前后双向迭代
list的底层式双向链表结构，双向链表中的每个元素存储在互不关联的独立节点中，节点中的指针指向前一个位置和后一个位置
list和forward_list非常相似：不同点在于，forward_list是单链表，只支持向前迭代，让其更加简单高效
与其他序列式容器相比(array,vector,deque)，list通常在任意位置插入，删除元素的执行效率更好
list的最大缺陷在于不支持随机访问，要访问第六个元素，必须从头部或尾部遍历到该位置，在这段位置上需要线性时间的开销；list需要一些额外的空间，用于保存每个节点的相关联信息

常见接口

构造

list();	// 构造空的list
list(size_type n, const value_type& val = value_type());	// 构造的list中包含n个值为val的值
list(const list& x);	// 拷贝构造函数
list(InputIterator first, InputIterator last);	// 用迭代器区间中的元素构造list

迭代器

list的迭代器不是原生的指针，而是通过封装之后的指针
在这里可以直接将迭代器理解为一个指针，该指针指向list中的某个节点
在实现前会将迭代器的封装讲一下实现思路

begin();	// 返回第一个元素的迭代器
end();		// 返回最后一个元素的下一个位置的迭代器
rbegin();	// 返回第一个元素的reverse_iterator，即end位置
rend();		// 返回最后一个元素的reverse_iterator,即begin位置

// (C++11)	const迭代器
 cbegin();
 cend();
 crbegin();
 crend();

注：

begin和end为正向迭代器，对迭代器进行++操作，迭代器向后移动
rbegin和rend为反向迭代器，对迭代器进行++操作，迭代器向前移动
const系列迭代器，不允许更改值

容量

bool empty() const;	// 检测list是否为空
size_t size() const;	// 返回list中有效节点的数量

元素引用

reference front();	// 返回list第一个节点值的引用
const_reference front() const;	// const引用
reference back();	// 返回list最后一个节点值的引用
const_reference back() const;	// const引用

注：

reference为引用的重命名，使用typedef进行重命名
const_reference为const引用的重命名

修改

void push_front(const value_type& val);	// 头插
void pop_front();	// 头删
void push_back(const value_type& val);	// 尾插
void pop_back();	// 尾删
iterator insert(iterator position, const value_type& val);	// 在pos位置进行插入
void insert(iterator position, size_type n, const value_type& val);	//在pos位置插入n个val
void insert(iterator position,InputIterator first,InputIterator last);
	// 插入[first, last)区间的元素
iterator erase(iterator position);	// 删除pos位置的元素
iterator erase(iterator first, iterator last);	// 删除[first,last)区间的元素
void swap(list& x);	// 交换两个list中的元素
void resize(size_type n, value_type val = value_type());
	// 将list有效元素改位n个，多出的元素用val填充
void clear();	// 清空list中的有效元素

list迭代器失效问题

迭代器失效即迭代器指向的节点被删除
list的底层结构为带头节点的双向循环链表，在list中进行插入是不会导致迭代器失效的
在删除的时候，只有删除的迭代器会失效，其他迭代器不受影响

#include <list>

// list迭代器失效问题，在删除元素后，迭代器指向的节点已经释放，所以不能进行操作
void TestListIterator1() {
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 }; 
	std::list<int> l(array, array + sizeof(array) / sizeof(array[0]));

	auto it = l.begin(); 
	while (it != l.end()) {       
		// erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给其赋值    
		l.erase(it);      
		++it; 
	} 
}
	
// 改正 
void TestListIterator() {    
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 }; 
	std::list<int> l(array, array+sizeof(array)/sizeof(array[0]));
	auto it = l.begin(); 
	while (it != l.end()) {
		// l.erase(it++);    
		it = l.erase(it);
	}
}

模拟实现list

迭代器封装

list的迭代器
迭代器有两种实现方式：1. 原生指针–vector; 2. 将原生指针进行封装
封装后的迭代器必须具备以下方法：

  1. 解引用，重载operator*();
  2. ->访问其指向空间的成员，迭代器必须重载operator->();
  3. 指针可以++向后移动，迭代器需要重载operator++(),operator++(int)，如果是双向链表还需要重载–
  4. 迭代器需要进行必要，所以还需要重载operator==(), operator!=();

封装后的迭代器可通过类模板参数进行传入

// 正向迭代器的封装
template<class T, class Ref, class Ptr>
class ListIterator {
public:
	typedef ListNode<T>* PNode;
	typedef ListIterator<T, Ref, Ptr> Self;
public:
	ListIterator(PNode pNode = nullptr)
		: _pNode(pNode)
	{}
	ListIterator(const Self& l)
		: _pNode(l._pNode)
	{}

	Ref operator*() {
		return _pNode->_val;
	}
	Ptr operator->() {
		return &(operator*());
	}
	Self& operator++() {
		_pNode = _pNode->_next;
		return *this;
	}
	Self operator++(int) {
		Self tmp(*this);
		_pNode = _pNode->_next;
		return tmp;
	}
	Self& operator--() {
		_pNode = _pNode->_prev;
		return *this;
	}
	Self operator--(int) {
		Self tmp(*this);
		_pNode = _pNode->_prev;
		return tmp;
	}


	bool operator!=(const Self& l) {
		return _pNode != l._pNode;
	}
	bool operator==(const Self& l) {
		return _pNode == l._pNode;
	}

	PNode _pNode;
};

// 反向迭代器的封装
template<class T, class Ref, class Ptr, class Iterator>
class ListReverseIterator {
	typedef ListReverseIterator<T, Ref, Ptr, Iterator> Self;
public:
	ListReverseIterator(const Iterator& it)
		: _it(it)
	{}
	ListReverseIterator(const Self& s)
		: _it(s._it)
	{}
	Ref operator*()  {
		Iterator tmp = _it;
		return *(--tmp);
	}
	Ptr operator->() {
		return &(operator*());
	}

	// 反向迭代器的++就是正向迭代器的--
	Self& operator++() {
		--_it;
		return *this;
	}
	Self operator++(int) {
		Iterator tmp(_it);
		--_it;
		return tmp;
	}

	Self& operator--() {
		++_it;
		return *this;
	}
	Self operator--(int) {
		Iterator tmp(_it);
		++_it;
		return tmp;
	}
	bool operator!=(const Self& s) {
		return _it != s._it;
	}
	bool operator==(const Self& s) {
		return _it == s._it;
	}

private:
	Iterator _it;
};

模拟实现

#include <iostream>

// 节点定义
template<class T>
struct ListNode
{
	ListNode(const T& val = T()) 
		: _prev(nullptr)
		, _next(nullptr)
		, _val(val) 
	{}
	ListNode<T> *_prev;
	ListNode<T> *_next;
	T _val;
};

template<class T, class Ref, class Ptr>
class ListIterator {
public:
	typedef ListNode<T>* PNode;
	typedef ListIterator<T, Ref, Ptr> Self;
public:
	ListIterator(PNode pNode = nullptr)
		: _pNode(pNode)
	{}
	ListIterator(const Self& l)
		: _pNode(l._pNode)
	{}

	Ref operator*() {
		return _pNode->_val;
	}
	Ptr operator->() {
		return &(operator*());
	}
	Self& operator++() {
		_pNode = _pNode->_next;
		return *this;
	}
	Self operator++(int) {
		Self tmp(*this);
		_pNode = _pNode->_next;
		return tmp;
	}
	Self& operator--() {
		_pNode = _pNode->_prev;
		return *this;
	}
	Self operator--(int) {
		Self tmp(*this);
		_pNode = _pNode->_prev;
		return tmp;
	}


	bool operator!=(const Self& l) {
		return _pNode != l._pNode;
	}
	bool operator==(const Self& l) {
		return _pNode == l._pNode;
	}

	PNode _pNode;
};

template<class T, class Ref, class Ptr, class Iterator>
class ListReverseIterator {
	typedef ListReverseIterator<T, Ref, Ptr, Iterator> Self;
public:
	ListReverseIterator(const Iterator& it)
		: _it(it)
	{}
	ListReverseIterator(const Self& s)
		: _it(s._it)
	{}
	Ref operator*()  {
		Iterator tmp = _it;
		return *(--tmp);
	}
	Ptr operator->() {
		return &(operator*());
	}

	// 反向迭代器的++就是正向迭代器的--
	Self& operator++() {
		--_it;
		return *this;
	}
	Self operator++(int) {
		Iterator tmp(_it);
		--_it;
		return tmp;
	}

	Self& operator--() {
		++_it;
		return *this;
	}
	Self operator--(int) {
		Iterator tmp(_it);
		++_it;
		return tmp;
	}
	bool operator!=(const Self& s) {
		return _it != s._it;
	}
	bool operator==(const Self& s) {
		return _it == s._it;
	}

private:
	Iterator _it;
};

template<class T>
class List {
	typedef ListNode<T> Node;
	typedef Node* PNode;
public:
	typedef ListIterator<T, T&, T*> Iterator;
	typedef ListIterator<T, const T&, const T*> ConstIterator;
	typedef ListReverseIterator<T, T&, T*, Iterator> ReverseIterator;
	typedef ListReverseIterator<T, const T&, const T*, ConstIterator> ConstReverseIterator;
public:
	List() {
		CreateHeap();
	}
	List(int n, const T& value = T()) {
		CreateHeap();
		for (int i = 0; i < n; ++i)
		{
			push_back(value);
		}
	}

	template<class Iterator>
	List(Iterator first, Iterator last) {
		CreateHeap();
		while (first != last)
		{
			push_back(*first);
			++first;
		}
	}
	List(const List<T>& l) {
		CreateHeap();

		List<T> tmp(l.CBegin(), l.CEnd());
		this->Swap(tmp);
	}

	List<T>& operator=(const List<T>& l) {
		if (this != &l)
		{
			List<T> tmp(l);
			this->Swap(tmp);
		}
		return *this;
	}

	~List() {
		Clear();
		delete _pHead;
		_pHead = nullptr;
	}

	// Iterator
	Iterator Begin() {
		return Iterator(_pHead->_next);
	}
	Iterator End() {
		return Iterator(_pHead);
	}
	ReverseIterator RBegin() {
		return ReverseIterator(End());
	}
	ReverseIterator REnd() {
		return ReverseIterator(Begin());
	}
	ConstIterator CBegin() const {
		return ConstIterator(_pHead->_next);
	}
	ConstIterator CEnd() const {
		return ConstIterator(_pHead);
	}
	ConstReverseIterator CRBegin() const {
		return ConstReverseIterator(CEnd());
	}
	ConstReverseIterator CREnd() const {
		return ConstReverseIterator(CBegin());
	}

	// list capacity
	size_t Size() const {
		size_t count = 0;
		PNode pCur = _pHead->_next;
		while (pCur != _pHead)
		{
			++count;
			pCur = pCur->_next;
		}
		return count;
	}
	bool Empty() const {
		return _pHead->_next == pHead;
	}
	void ReSize(size_t newSize, const T& val = T());

	// list access
	T& Front() {
		return _pHead->_next->_val;
	}
	const T& Front() const {
		return _pHead->_next->_val;
	}
	T& Back() {
		return _pHead->_prev->_val;
	}
	const T& Back() const {
		return _pHead->_prev->_val;
	}

	// list modify
	void push_back(const T& val) {
		PNode pNewNode = new Node(val);

		pNewNode->_next = _pHead;
		pNewNode->_prev = _pHead->_prev;

		_pHead->_prev = _pHead;
		pNewNode->_prev = _pHead->_prev;

		_pHead->_prev = pNewNode;
		pNewNode->_prev->_next = pNewNode;
	}

	void pop_back() {
		PNode pDel = _pHead->_prev;
		if (pDel != _pHead)
		{
			_pHead->_prev = pDel->_prev;
			pDel->_prev->_next = _pHead;
			delete pDel;
		}
	}

	void push_front(const T& val) {
		PNode pNewNode = new Node(val);

		pNewNode->_next = _pHead->_next;
		pNewNode->_prev = _pHead;

		_pHead->_next = pNewNode;
		pNewNode->_next->_prev = pNewNode;
	}

	void pop_front() {
		PNode pDel = _pHead->_next;
		if (pDel != _pHead)
		{
			_pHead->_next = pDel->_next;
			pDel->_next->_prev = _pHead;
			delete pDel;
		}
	}

	Iterator insert(Iterator pos, const T& val) {
		PNode pNewNode = new Node(val);
		PNode pCur = pos._pNode;

		pNewNode->_prev = pCur->_prev;
		pNewNode->_next = pCur;
		pNewNode->_prev->_next = pNewNode;
		pCur->_prev = pNewNode;
		return Iterator(pNewNode);
	}

	Iterator erase(Iterator pos) {
		PNode pDel = pos._pNode;
		PNode pRet = pDel->_next;

		pDel->_prev->_next = pDel->_next;
		pDel->_next->_prev = pDel->_prev;
		delete pDel;

		return Iterator(pRet);
	}

	void Clear() {
		PNode pCur = _pHead->_next;
		while (pCur != _pHead)
		{
			_pHead->_next = pCur->_next;
			delete pCur;
			pCur = _pHead->_next;
		}
		_pHead->_next = _pHead;
		_pHead->_prev = _pHead;
	}

	void Swap(List<T>& l) {
		std::swap(_pHead, l._pHead);
	}




private:
	void CreateHeap() {
		_pHead = new Node;
		_pHead->_next = _pHead;
		_pHead->_prev = _pHead;
	}
private:
	PNode _pHead;
};

template<class T>
void PrintList(List<T>& l) {
	auto it = l.Begin();
	while (it != l.End())
	{
		std::cout << *it << " ";
		++it;
	}
	std::cout << std::endl;
}

template<class T>
void PrintListReverse(const List<T>& l) {
	auto it = l.CRBegin();
	while (it != l.CREnd())
	{
		std::cout << *it << " ";
		++it;
	}

	std::cout << std::endl;
}

void TestList1() {
	List<int> l1;   
	List<int> l2(10, 5);    
	PrintList(l2);

	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };   
	List<int> l3(array, array + sizeof(array) / sizeof(array[0])); 
	PrintList(l3);

	List<int> l4(l3);    
	PrintList(l4);

	l1 = l4;    
	PrintList(l1);    
	PrintListReverse(l1);
}

int main()
{
	TestList1();
	return 0;
}
Thinker_serious
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++语言 STL容器list总结
01-21
在使用std::list<>链表时，难免会对数据进行添加删除操作。而遍历链表则有两种方式：通过索引访问，象数组一样处理；通过std::list<>::iterator链表遍历器进行访问 STL 中的list 就是一 双向链表，可高效地...
C++ list的使用
sinat_31608641的博客
08-15 1158
一、简介 list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的，list中的数据元素是通过链表指针串连成逻辑意义上的线性表，也就是list也具有链表的主要优点，即：在链表的任一位置进行元素的插入、删除操作都是快速的. 二、list的源码 list的实现大概是这样的：list的每个节点有三个域：前驱元素指针域、数据域和后继元素指针域。前驱元素指针域保存了前驱元素的首地址；数据域则是本节点的数据；后继元素指针域则保存了后继元素的首地址。 list的源码如.
C++中的list类【详细分析及模拟实现】
kevvviinn的博客
03-26 2813
本文介绍C++STL中的第三个容器——list类，详细介绍并使用库中为我们提供的接口，并配以多道测试实例帮助运用，然后我们深度剖析了如何模拟实现list类，包括设计思路以及方法的实现；最后比较了vector和list两种容器的优劣
C++中的list 使用总结
weixin_42145502的博客
11-28 821
1.STL ---list简单介绍 list 是顺序容器的一种。list 是一个双向链表。使用 list 需要包含头文件 list。双向链表的每个元素中都有一个指针指向后一个元素，也有一个指针指向前一个元素，如图1所示。 在 list 容器中，在已经定位到要增删元素的位置的情况下，增删元素能在常数时间内完成。如图2所示，在 ai 和 ai+1 之间插入一个元素，只需要修改 ai 和 ai+1 中...
15C++STL之list
LJLThomson的博客
07-07 400
list序列容器 1.简介 list是一种序列式容器，集成了双向链表的优点，所以其实本质也是双向链表。与java中LinkedList基本一致。 2.内部实现机制 list每个元素有三个域：前驱元素指针域、数据域和后继元素指针域。 前驱元素指针域保存了前驱元素的首地址；数据域则是本节点的数据；后继元素指针域则保存了后继元素的首地址。 优点有以下： ​ 1.特别适合插入、删除 ​ 2.特别适合查找首元素和尾部元素，越接近中间，效率越低，时间复杂度为O（n/2) ​ 3.不适合查找中间元素。 3.list构造函
C++智能指针
qq_53558968的博客
08-10 188
文章目录为什么需要智能指针C++98的auto_ptrunique_ptrshared_ptrweak_ptr别的思考 为什么需要智能指针 C++98的auto_ptr unique_ptr shared_ptr weak_ptr 别的思考
C++实现STL容器之List
最新发布
04-08
C++实现STL容器之List
c++容器list、vector、map、set区别与用法详解
12-17
c++容器list、vector、map、set区别 list 封装链表，以链表形式实现，不支持[]运算符。 对随机访问的速度很慢(需要遍历整个链表)，插入数据很快(不需要拷贝和移动数据，只需改变指针的指向)。 新添加的元素，...
C++ STL::list常用操作及底层实现（中1）——实现list常用操作之插入(insert、push_front、push_back、splice)
weixin_43744293的博客
06-07 2202
STL::list插入介绍及自实现插入功能1插入数据之insert()：1.1 `iterator insert(iterator position,const value_type & val);`1.2. ` iterator insert(iterator position,size_type n,const value_type & val);`1.3. `template iterator insert(iterator position, InputIterator fi
List容器（C++）
crisp077的博客
06-27 672
​ 功能：将数据进行链式存储​ 链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的​ 链表的组成：链表由一系列结点组成​ 节点的组成：一个时存储数据元素的数据域，另一个是存储下一个结点地址的指针域​ STL中的链表是一个双向循环链表​ 由于链表的存储方式并不是连续的内存空间，因此链表list 中的迭代器只支持前移和后移，属于双向迭代器list优点：list缺点：​ List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这才vecto
C++——list容器的插入,删除,数据存取与反转和排序
m0_74822436的博客
01-05 486
尾插 --push_back*尾删 --pop_back*头插 --push_front*头删 --pop_front*插入 --insert*删除 --erase*移除 --remove*清空 --clear。
C++之STL——list类
qq_41490958的博客
10-10 713
STL——list类list简介list的使用list的构造函数list的迭代器list的capacitylist的元素提取list的插入和删除 list简介 1、list的插入和删除的时间复杂度是在常数范围内的序列式容器，并且由于list的底层是用双链表实现的，该容器支持双向迭代。 2、与其他序列式容器相比(array，vector，deque)，list在任意位置进行插入和删除的效率更高。 3、list最大的缺陷就是不支持任意位置的随机访问。 list的使用 list的构造函数 构造函数 接口
如何给获取到的List集合里面的对象重新赋值
香草天空Sky的博客
03-26 6387
第一种方法：给userList里面的对象的name和sex重新赋值后，所得到的list集合中的对象名字都为小李，性别都为男； List<User> userList = userService.queryUser(); for(User u:userList){ u.setName("小李"); u.setSex("男"); } 第二种方法是： ...
【C++】list使用
chuxinchangcun的博客
01-05 1万+
age = _age;} int age;//升序 } int main() {//如果想用sort按年龄排序结构体,就需要自定义排序函数 //这里的第三个参数传入的是函数指针,不需要()进行调用 sort(s , s + 3 , cmp);i < 3;i ++) {} }[外链图片转存中…(img-1EiJ8vgQ-1672931727055)]关于迭代器分类单向迭代器：支持++ 如:forword_list 单链表。
C++——list的简介及使用
热门推荐
qq_56663697的博客
11-13 2万+
文章目录list的简介list的使用list 的构造list 插入和删除数据push_front和pop_frontpush_back和pop_backinserteraselist 迭代器的使用list 获取数据list 容量list 相关操作函数swapclearsortresizeremoveuniquereverse list的简介 list文档 list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。 list的底层是双向链表结构，双向链表中每个元素存储在互不
【C++】快速入门list的使用
weixin_60478154的博客
11-28 1487
【C++】list的使用
list迭代器的失效问题（对比vector迭代器），list类的实现
小白的Coding之旅
08-13 1003
list的构造 构造函数 接口说明 list() 构造空的list list (size_type n, const value_type& val = value_type()) 构造的list中包含n个值为val的元素 list (const list& x) 拷贝构造函数 list (InputIterator first, InputIterato...
容器list基本概念
嵌入式
07-04 458
功能 将数据进行链式存储 链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的 链表的组成：链表由一系列结点组成 结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域 STL中的链表是一个双向循环链表 由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器 list的优点： ...
C++ -- STL文件解析
08-27
STL是指标准模板库（Standard Template Library），它是C++语言的一部分，提供了一系列的模板类和函数，用于支持通用的数据结构和算法。STL的目标是提供高效、可重用和可扩展的组件，以便开发人员能够更轻松地编写高质量的代码。STL包含了许多常见的数据结构，如vector、list、set、map等，以及各种算法，比如排序、查找、遍历等。通过使用STL，开发人员可以更加高效地处理各种数据结构和算法的问题，提高代码的开发效率和质量。 在STL中，我们可以使用各种容器来存储和管理数据。例如，我们可以使用std::map来创建一个键值对的映射，其中每个键都有一个与之相关联的值。下面是一个示例代码，展示了如何创建和使用一个std::map对象： std::map<std::string, int> disMap() { std::map<std::string, int> tempMap{ {"C语言教程",10},{"STL教程",20} }; return tempMap; } std::map<std::string, int> newMap(disMap()); 在这个示例中，disMap()函数创建了一个临时的std::map对象，并初始化了其中的一些键值对。然后，使用移动构造函数将这个临时对象移动到了一个新的std::map对象newMap中。最终，我们可以通过newMap对象来访问和操作这些键值对。 综上所述，STL是C++中的标准模板库，提供了一系列的模板类和函数，用于支持通用的数据结构和算法。STL的使用可以提高代码的开发效率和质量，并且通过各种容器和算法，可以方便地处理各种数据结构和算法的问题。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [C++ STL详解超全总结(快速入门STL)](https://blog.csdn.net/qq_50285142/article/details/114026148)[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: 50%"] - *2* *3* [【C++实验】阅读STL源码并分析](https://blog.csdn.net/qq_35760825/article/details/125311509)[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: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值