【C++】List

最新推荐文章于 2024-07-25 23:22:43 发布
最新推荐文章于 2024-07-25 23:22:43 发布
阅读量1k 收藏 23
点赞数 33
文章标签： c++ list 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lehjy/article/details/138317800
版权

文章目录

List

List的介绍

在这里插入图片描述

  1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
  2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向 其前一个元素和后一个元素。
  3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高 效。
  4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率 更好。
  5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list 的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间
    开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这 可能是一个重要的因素

List的使用

list中的接口比较多，此处类似，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展的能力。以下为list中一些常见的重要接口。
在这里插入图片描述
list iterator的使用：
在这里插入图片描述
【注意】

  1. begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
  2. rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动

list capacity：
在这里插入图片描述
list element access：
在这里插入图片描述

List的测试


void test_list1()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);

	list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;
}

在这里插入图片描述

void test_list2()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(2);
	lt.push_back(2);
	lt.push_back(4);
	lt.push_back(5);
	lt.push_back(2);
	lt.push_back(4);

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	lt.reverse();

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	//lt.sort();
	lt.sort(greater<int>());
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	lt.unique();

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

}

在这里插入图片描述

void test_list3()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	lt.splice(lt.end(), lt, lt.begin());
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	list<int> lt1;
	lt1.push_back(10);
	lt1.push_back(20);
	lt1.push_back(30);
	lt1.push_back(40);
	/*lt.splice(lt.begin(),lt);
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;*/

	lt.splice(lt.begin(), lt1);
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;


	/*for (auto e : lt1)
	{
		cout << e << " ";
	}
	cout << endl;*/


}

在这里插入图片描述

List的模拟实现

List的节点

template<class T>
	struct ListNode
	{
		ListNode(const T& val = T())
			:_prev(nullptr)
			, _next(nullptr)
			, data(val)
		{

		}
		ListNode<T>* _prev;//为什么是ListNode<T>*的指针呢？因为我们将来要指向
		//ListNode<T>类型的节点。
		ListNode<T>* _next;
		T data;
	};

List的构建

双向带头链表，所以list一定要有头结点。

template<class T>
	class list
	{
	public:
		typedef ListNode<T> Node;
	private:
		Node* _head;//头结点是一个节点指针类型。
		size_t _size;//因为库中有size这个接口，这里存一个会方便一点。
	};

};

List的构造

list()
		{
			empty_init();
			//刚创建一个链表的时候，没有插入任何数据，我们需要让他指向自己
		}

尾插push_back:

void push_back(const T& val)
{
	Node* node = new Node(val);//申请节点
	Node* tail = _head->_prev;//如何找到4？是_head->prev！保存起来方便我们使用。
	node->_prev = tail;//链接
	node->_next = _head;
	tail->_next = node;
	_head->_prev = node;
	_size++;//修改size
}

尾删pop_back:

先找到尾节点，然后保存一起来(方便我们删除)。然后将指针链接到尾删的前一个值然后保存一起来(方便我们删除)。然后将指针链接到尾删的前一个值。

void pop_back()
{
	Node* tail = _head->_prev;//保存

	_head->_prev = tail->_prev;//更改指向
	tail->_prev->_next = _head;
	delete tail;//删除节点
	_size--;//别忘了修改个数
}

节点个数：size（）

size_t size()
{
	return _size;
}

判断是否为空：empty()

bool empty()
{
	return _size == 0;
}

迭代器：

template<class T>
class List_Iterator
{
public:
	typedef ListNode<T> Node;
	Node* _node;

	List_Iterator(Node* node)
		:_node(node)
	{}
};

begin（和）end（）

begin()是返回数据的开始和end()返回头结点(有效数据的下一个)。

template<class T>
	class list
	{
	public:
		typedef ListNode<T> Node;
		iterator begin()
		{
			//这里存在单参数构造函数的隐式类型转换
			//按道理 return iterator(_head->next);
			//应该是这样的，匿名对象，但是单参数的构造函数可以进行隐式类型转换。
			return _head->_next;
		}
		iterator end()
		{
			return _head;
		}
	private:
		Node* _head;//头结点是一个节点指针类型。
		size_t _size;//因为库中有size这个接口，这里存一个会方便一点。
	};

operator*()：

打印节点的数值。

T& operator* ()
{
	return _node->data;
}

前置++ operator++()：

List_Iterator<T>& operator++()
{
	_node= _node->_next;
	return *this;
}

后置++ operator++(int)：

后置++，就是我们创建一个临时变量，然后返回临时变量，但是让实际已经指向下一个节点了。注：不能返回引用，因为是临时变量。

List_Iterator<T> operator++(int)
{
	List_Iterator<T> tmp(*this);
	_node = _node->_next;
	return tmp;
}

前置-- operator–()：

List_Iterator<T> & operator--()
{
	_node= _node->_prev;
	return *this;
}

后置-- operator–(int)

List_Iterator<T> operator--(int)
{
	Self tmp(*this);
	_node = _node->_prev;
	return tmp;
}

重载不等于 operator!=(const Self& rhs)：

bool operator!=(const Self& rhs )
{
	return rhs._node != _node;
}

重载箭头 operator->()：

T* operator->()
{
	return &_node->data;
}

const迭代器

以上我们都是写的普通的迭代器，那么如果我们要写const的迭代器是要重新写一个。

template<class T>
class List_ConstIterator
{
public:
	typedef ListNode<T> Node;
	typedef List_ConstIterator<T> Self;
	Node* _node;

	List_ConstIterator(Node* node)
		:_node(node)
	{}
	//前置++
	Self& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	//后置++
	Self operator++(int)
	{
		Self tmp(*this);
		_node = _node->_next;
		return tmp;
	}
	//前置--
	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	//后置--
	Self operator--(int)
	{
		Self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}
	bool operator!=(const Self& rhs)  
	{
		return rhs._node != _node;
	}
	bool operator==(const Self& rhs)
	{
		return _node == rhs._node;
	}

	const T& operator* ()
	{
		return _node->data;
	}
	const T* operator->()
	{
		return &_node->data;
	}
};

但是这个迭代器的代码和普通迭代器的代码有很多相似之处，所以我们会觉得代码冗余，那么我们是不是可以利用类模板写呢？事实证明是可以的。

template<class T ,class Ref ,class Ptr>
class List_Iterator
{
public:
	typedef ListNode<T> Node;
	typedef List_Iterator< T, Ref, Ptr> Self;
	Node* _node;

	List_Iterator(Node* node)
		:_node(node)
	{}
	//前置++
	Self& operator++()
	{
		_node= _node->_next;
		return *this;
	}
	//后置++
	Self operator++(int)
	{
		Self tmp(*this);
		_node = _node->_next;
		return tmp;
	}
	//前置--
	Self& operator--()
	{
		_node= _node->_prev;
		return *this;
	}
	//后置--
	Self operator--(int)
	{
		Self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}
	bool operator!=(const Self& rhs )
	{
		return rhs._node != _node;
	}
	bool operator==(const Self& rhs)
	{
		return _node == rhs._node;
	}
	Ptr operator->()
	{
		return &_node->data;
	}
	Ref operator* ()
	{
		return _node->data;
	}
};

在某个位置前插入 insert()：

在这里插入图片描述

iterator insert(iterator pos, const T& val)
		{
			 Node* node = new Node(val);
			 Node* prev=pos->prev;
			 node->prev=prev;
			 node->next=pos;
			 pos->prev=node;
			 prev->next=node;
			 _size++;
			 return _head
		}

最后记得节点的个数+1。

删除某位置的值 erase():

在这里插入图片描述
在这里插入图片描述
库中要求返回被删除节点的下一个迭代器。

iterator erase(iterator pos)
		{
			
		
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;

			prev->_next = next;
			next->_prev = prev;
			delete cur;
			return next;

		}

清空链表 clear()：

void clear()
{
	iterator it = begin();
	while (it != end())
	{
		it = erase(it);
	}
	_size = 0;
}

拷贝构造：

拷贝构造，由于你的头指针没有初始化，都是空，插入直接空指针访问，所以不能用push_back。所以你需要初始化。

//lt1(lt2)
list(const list<T>& lt)
{
	empty_init();//初始化头结点。
	for (auto& e : lt)
	{
		push_back(e);
	}
	iterator it = lt.begin();
	
}

析构函数：

~list()
{
	clear();//复用
	delete _head;
}

整体代码展现：

#include<iostream>
#include<assert.h>

namespace bit {
	template<class T>
	struct ListNode
	{
		ListNode(const T& val = T())
			:_prev(nullptr)
			, _next(nullptr)
			, data(val)
		{

		}
		ListNode<T>* _prev;//为什么是ListNode<T>*的指针呢？因为我们将来要指向
		//ListNode<T>类型的节点。
		ListNode<T>* _next;
		T data;
	};
	template<class T, class Ref, class Ptr>
	class List_Iterator
	{
	public:
		typedef ListNode<T> Node;
		typedef List_Iterator< T, Ref, Ptr> Self;
		Node* _node;

		List_Iterator(Node* node)
			:_node(node)
		{}
		//前置++
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		//后置++
		Self operator++(int)
		{
			Self tmp(*this);
			_node = _node->_next;
			return tmp;
		}
		//前置--
		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		//后置--
		Self operator--(int)
		{
			Self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}
		bool operator!=(const Self& rhs)
		{
			return rhs._node != _node;
		}
		Ref operator* ()
		{
			return _node->data;
		}
		bool operator==(const Self& rhs)
		{
			return _node == rhs._node;
		}
		Ptr operator->()
		{
			return &_node->data;
		}
	};
	//template<class T>
	//class List_ConstIterator
	//{
	//public:
	//	typedef ListNode<T> Node;
	//	typedef List_ConstIterator<T> Self;
	//	Node* _node;

	//	List_ConstIterator(Node* node)
	//		:_node(node)
	//	{}
	//	//前置++
	//	Self& operator++()
	//	{
	//		_node = _node->_next;
	//		return *this;
	//	}
	//	//后置++
	//	Self operator++(int)
	//	{
	//		Self tmp(*this);
	//		_node = _node->_next;
	//		return tmp;
	//	}
	//	//前置--
	//	Self& operator--()
	//	{
	//		_node = _node->_prev;
	//		return *this;
	//	}
	//	//后置--
	//	Self operator--(int)
	//	{
	//		Self tmp(*this);
	//		_node = _node->_prev;
	//		return tmp;
	//	}
	//	bool operator!=(const Self& rhs)  
	//	{
	//		return rhs._node != _node;
	//	}
	//	const T& operator* ()
	//	{
	//		return _node->data;
	//	}
	//	bool operator==(const Self& rhs)
	//	{
	//		return _node == rhs._node;
	//	}
	//	const T* operator->()
	//	{
	//		return &_node->data;
	//	}
	//};
	template<class T>
	class list
	{
	public:
		typedef ListNode<T> Node;
		typedef List_Iterator<T, T&, T*> iterator;
		typedef List_Iterator<T, const T&, const T*> const_iterator;
		//typedef List_Iterator<T> iterator;
		//typedef List_ConstIterator<T> const_iterator;
		void empty_init()
		{
			_head = new Node;//给头一个空间
			_head->_prev = _head;
			_head->_next = _head;
			_size = 0;
		}
		list()
		{
			empty_init();
			//刚创建一个链表的时候，没有插入任何数据，我们需要让他指向自己
		}
		~list()
		{
			clear();
			delete _head;
		}
		//lt1(lt2)
		list(const list<T>& lt)
		{
			empty_init();
			for (auto& e : lt)
			{
				push_back(e);
			}
			iterator it = lt.begin();
			//类型不明确，用范围for更好
				//auto it = lt.begin();//这样也可以
				//while (it != lt.end())
				//{
				//	push_back(*it);
				//	it++;
				//}
		}
		void push_back(const T& val)
		{
			/*Node* node = new Node(val);
			Node* tail = _head->_prev;
			node->_prev = tail;
			node->_next = _head;
			tail->_next = node;
			_head->_prev = node;*/
			insert(end(), val);
		}
		void pop_back()
		{
			/*Node* tail = _head->_prev;

			_head->_prev = tail->_prev;
			tail->_prev->_next = _head;
			delete tail;*/
			erase(--end());
		}
		//当我们想使用insert的时候，发现需要迭代器那么我们先实现迭代器，怎么做呢？
		iterator begin()
		{
			//这里存在单参数构造函数的隐式类型转换
			//
			return _head->_next;
		}
		iterator end()
		{
			return _head;
		}
		const_iterator begin()const
		{
			//这里存在单参数构造函数的隐式类型转换
			return _head->_next;
		}
		const_iterator end()const
		{
			return _head;
		}
		//目前测试的迭代器没有大碍，那么就写insert
		iterator insert(iterator pos, const T& val)
		{
			 Node* node = new Node(val);
			 Node* prev=pos->prev;
			 node->prev=prev;
			 node->next=pos;
			 pos->prev=node;
			 prev->next=node;
			 _size++;
			 return _head
		}
		iterator erase(iterator pos)
		{
			
		
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;

			prev->_next = next;
			next->_prev = prev;
			delete cur;
			return next;

		}
		size_t size()
		{
			return _size;
		}
		bool empty()
		{
			return _size == 0;
		}
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
			_size = 0;
		}
	private:
		Node* _head;
		size_t _size;
	};
}
Lehjy
关注
  • 33
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C++ list 查找
萧海的博客
09-09 2607
#include <iostream> #include <list> #include <algorithm> using namespace std; int main() { 　　list<int> list1; 　　for (int k=0;k<10;k++) 　　{ 　　　　list1.push_back(k); 　　} 　　for (int k=0;k<10;k++) 　　{ 　　　　list1.insert(list1.end
C++ List Control 应用
05-24
在C++编程中，List Control是一种非常常用的控件，它允许程序员在用户界面中展示列表形式的数据。在Windows应用程序开发中，特别是在MFC（Microsoft Foundation Classes）框架下，List Control通常用于显示多列数据...
C++List详解
m0_53889456的博客
05-11 7038
list容器详解，学我这一篇就够了。你写的C++list到底有什么不一样？都让人写烂的东西了你怎么还写？你比别人强？点进来看看你就知道有什么不一样了。
C++list
yugongbaocc的博客
12-01 1406
list中没有find()模板，需要调用algorithm库中的find。没有reserve和resize了，因为链表是按需要申请和释放空间的。用库里面sort对vector排序要比list中的sort对链表排序快。平时不用头插和头删用vector，不用的话，用list也是可以的。但erase后，pos会失效，因为此时pos位置结点已经没了。元素访问没有[]了，意味着以后大部分需要使用迭代器进行访问。它俩能够相减，需要迭代器是连续的，而链表迭代器不连续。remove一个对象中没有的数，不会报错。
C++list类
weixin_44614083的博客
05-07 2730
系列文章目录 C++入门 C++类和对象（上） C++类和对象（中） C++类和对象（下） C/C++内存管理 C++string类 C++vector类 文章目录系列文章目录一、list是什么？二、使用步骤1.引入库2.读入数据总结 一、list是什么？ list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。 list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素与后一个元素。 list与forward_li
C++ list 排序案例
往南的博客
10-16 2298
代码如下： #include<iostream> using namespace std; #include<string> #include<algorithm> #include<list> // list 之排序案例 /** * Author:晚风亦是救赎 * CreateTime:2021/10/16 * * 案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高 * 排序规则：按照年龄进行升序，如果年龄相同按照身
C++ list容器详解
qq_52324409的博客
10-31 5425
C++ list容器list容器的基本概念1.list的构造函数2.list的赋值和交换3.list的大小操作4.list的插入和删除5.list的数据存取6.list的反转与排序7.list的排序案例 list容器的基本概念 概念：list一种将数据进行链式存储的数据结构，被称为链表 链表：是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的 链表的组成：链表由一系列结点组成 结点的组成：由一个存储数据元素的数据域和一个存储下一个结点地址的指针域组成 优点： 可
c++ list
weixin_43870610的博客
05-07 8894
头文件 #include 声明一个int型的list：list a； 1、list的构造函数 lista{1,2,3} lista(n) //声明一个n个元素的列表，每个元素都是0 lista(n, m) //声明一个n个元素的列表，每个元素都是m lista(first, last) //声明一个列表，其元素的初始值来源于由区间所指定的序列中的元素，first和last是迭代器 2、begin()和end() 通过调用list容器的成员函数begin()得到一个指向容器起始位置的iterator
c++ list详解
sblbsgqxx的博客
01-24 3510
list的底层结构是带头双向循环链表，因为该结构的特性，使list可以在常数范围内在任意位置进行插入和删除，但是不支持[]随机访问。
C++ list常用操作
Han同学
12-17 1880
C++ list常用操作
c++ list 正确删除
热门推荐
U201414786的博客
01-05 1万+
  c++  std::list 是一个双向链表，对它的遍历大部分都是使用list&lt;T&gt;::iterator it;大致的结构如下： 下面的简单代码是去除链表中小于1000的值，关键在于it =ListNumber-&gt;erase(it); 需要返回it，因为it是正在遍历的指针；删除后就无法继续遍历后面的队列了，会报错； ListNumber-&gt;erase(it++)...
C++ list的实例详解
01-20
C++ list的实例详解 Source: #include #include <list> #include #include using namespace std; typedef list<int> LISTINT; //创建一个list容器的实例LISTINT typedef list<int> LISTCHAR; //创建一个list...
基于C++ list中erase与remove函数的使用详解
09-05
在C++编程中，`list` 是一个关联容器，提供了双向链表的实现。这篇文章主要讲解了`list`中的两个重要成员函数`erase`和`remove`，它们用于删除链表中的元素。理解这两个函数的正确用法对于编写高效且无误的C++代码至...
C++ list详解
02-12
C++中的`list`是标准模板库(STL)的一部分，它是一个双向链表的数据结构，提供了高效的操作，如插入和删除元素。在这个详尽的解释中，我们将深入探讨`list`容器的各个方面，包括它的定义、操作、优势以及在实际编程中...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1230
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 674
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 280
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1139
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
Windows图形界面(GUI)-MFC-C/C++ - Dialog
最新发布
0xCC说逆向
07-25 974
流程打开资源视图：在Visual Studio中，右键点击资源文件夹（通常是），选择“添加” -> “资源”。添加对话框资源：在弹出的对话框中选择“Dialog”，然后点击“新建”。设计对话框：在资源编辑器中，你可以拖放控件到对话框上，如按钮、文本框、列表框等。拓展资源ID：每个对话框都有一个唯一的资源ID，用于在代码中引用。对话框编辑器：用于可视化地设计和布局对话框。
C++ list
06-02
在 C++ 中，list 是双向链表容器，可以用来存储和操作相同类型的数据。list 支持在任意位置插入/删除元素，但是不支持随机访问元素。 以下是 list 的一些常用操作： 1. push_front()：在链表头部插入元素。 2. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Lehjy

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

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

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

打赏作者

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

抵扣说明：

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

余额充值