list的常用接口底层实现与介绍

目录

概念：

list的基本结构：

list的迭代器⭐❤： 

自定义类型的完善： 

const的迭代器：

insert 

erase：

size 

empty 

push_back 、push_front 、pop_back、pop_front 

swap 、operator=

析构函数、clear() 

---

 

概念：

1. list是序列容器，允许在序列中的任何位置执行固定O(1)时间复杂度的插入和删除操作，并在两个方向进行迭代。
2. list容器使用双链表实现；双链表将每个元素存储在不同的位置，每个节点通过next，prev指针链接成顺序表。
3. list与其他标准序列容器（array，vector和deque）相比，list通常可以在容器内的任何位置插入、提取和移动元素。
4. list与其他标准序列容器（array，vector和deque）相比，list和forward_list（单链表实现）的主要缺点是他们不能通过位置直接访问元素；例如，要访问列表中的第五个元素，必须从已知位置（开始或结束）迭代到该位置，需要哦线性时间开销。
5. 存储密度低，list要使用一些额外的内容空间（next，prev）来保持与每个元素相关联（前后续的线性）的链接信息，从而导致存储小元素类型（如char，short，int等）的列表的存储密度低。

list的基本结构：

#include<iostream>
#include<assert.h>
using namespace std;
namespace bit {
	template <class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _data;
		ListNode(const T& x = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_data(x)
		{}
	};
	template<class T>
	class list {
		typedef ListNode<T> Node;
	public:
		list()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
	private:
		Node* _head;
		size_t _size;
	};
}

通过list的概念我们可以得知，list在本质上就是一种带头的双向链表结构，所以在创建list类之前，我们首先要构建一个节点的结构体，其次在list的构造函数中，为了让list遵循它本质上的数据结构，以及通过之后的插入删除等等操作，利用带头双向链表结构的特点，我们将成员变量特地设置为头节点以及长度。

list的迭代器⭐❤： 

list的迭代器特殊之处： 

• 迭代器的本质就是不管是什么类型的数据都可以进行访问！所以该如何使用迭代器遍历链表内的数据呢？是否能使用前驱、后继指针充当迭代器？答案是不能！
• 如果使用前驱后继指针充当迭代器，那么就需要遇到一个问题，链表的各个节点是不同位置不同地址的！
• 所以如果使用指针+1的方式并不能正确的遍历链表！
• 其次，如果使用前驱后继指针当迭代器，那么解引用能得到节点内的数据吗？不能！因为Node * 解引用后上一个Node 是一个strcut结构体

所以对于list的迭代器，正确的解决方案是另外在设置一个类对迭代器进行分装操作！ 

	template<class T>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T> self;
		Node* _node;
		ListIterator(Node*node)
			:_node(node)
		{}
	};

在原先的原身指针 prev和next下，并不能解决迭代器遍历操作，以及解引用操作，因为节点的空间问题并不能使用指针+1的操作，以及解引用prev和next并不能直接获取到节点内部存储的数值元素，所以我们需要在这个封装操作中进行。

至于这个封装为什么是结构体呢？

在C++中，struct和class是非常相似的，唯一的区别是默认的访问权限不同。在struct中，成员默认是公共的（public），而在class中，默认是私有的（private）。因此，在C++中，struct内部是可以定义函数的。 

在这个结构体的内部我们需要解决迭代器的遍历、解引用、遍历修改、不等于 等运算符重载问题！ 

		//*
		T& operator*()
		{
			return _node->_data;
		}
		//前置++ 因为这里是链表所以++应该是指向下一个节点！
		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;
		}
		slef& operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}
		bool operator!=(const self& it)
		{
			return _node != it._node;
		}

我们定义这些重载运算符的意义就在于为了之后我们在定义begin时，可以直接使用封装的重载运算符！

		typedef ListIterator<T> iteator;
		iterator begin()
		{
			iterator it(_head->_next);
			return it;
		}
		iterator end()
		{
			iterator it(_head);
			return it;
		}

自定义类型的完善： 

自定义类型的完善 ，因为我们写的是一个自定义类型，所以读取*it后解决完后还是一个自定义类型的数据结构，所以需要在使用数据结构的写法，表明其中内部的数据即可！

 

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

it->是需要进行拆解的，可以变成it.operator()->，这里其实是编译器的一种隐藏操作，之前的it++也是一种隐藏操作，可以变化为it.operator++（）

而it->_a1这里隐藏的是另一个-> ，也就是图中第二个->，第一个->是属于it的重载运算符标识！

const的迭代器：

首先要记住const不能调用非const的成员函数！但是非const可以调用const的成员函数

为了让const修饰的类型能够使用迭代器，我们需要根据const不能修改内容的特点进行另外设置一共专门让const使用的迭代器封装，但是由于只是需要变动operator*()和operator->所以我们可以使用模板类解决这类问题！ 

template<class T, class Ref, class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;

		Node* _node;

		ListIterator(Node* node)
			:_node(node)
		{}

		// *it
		//T& operator*()
		Ref operator*()
		{
			return _node->_data;
		}

		// it->
		//T* operator->()
		Ptr operator->()
		{
			return &_node->_data;
		}

		// ++it
		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& it)
		{
			return _node != it._node;
		}

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

insert 

 有了迭代器之后了，可以利用迭代器的操作进行insert的底层实现

void insert(iterator pos, const T& val)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(val);
			Node* prev = cur->_prev;

			// prev newnode cur;
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			_size++;
		}

erase：

操作和insert一样都是对指针的方向的修改！但是pos会在后面失效，也就是迭代器会失效，所以需要改变类型！然后进行返回！这里的返回变成了的pos节点的后面一个节点的迭代器。

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

			return iterator(next);
		}

size 

        size_t size() const
		{
			return _size;
		}

empty 

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

push_back 、push_front 、pop_back、pop_front 

        void push_back(const T& x)//尾插
		{
			insert(end(), x);
		}

		void push_front(const T& x)//头插
		{
			insert(begin(), x);
		}

		void pop_back()//尾删
		{
			erase(--end());
		}

		void pop_front()//头删
		{
			erase(begin());
		}

swap 、operator=

        void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		// lt1 = lt3
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

析构函数、clear() 

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

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}

---