一、list介绍及使用

1. list文档介绍

（1）list是可以在常数范围内，在任意位置进行插入、删除的序列式容器，并且该容器可以前后双向迭代。

（2）list的底层是带头结点的双向循环链表，其中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。

（3）list和forward_list非常相似。最主要的不同在于forward_list是单链表，只能朝前迭代。

（4）与其他的序列式容器相比（array、vector、deque），list通常在任意位置的插入、删除元素的执行效率更高。

（5）与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问。

2. list常用接口介绍

2.1 list的构造

2.2 list iterator的使用

2.3 list capacity

 

2.4 list 元素访问

2.5 list 元素修改

3. list迭代器失效问题

3.1迭代器失效

        迭代器失效，即迭代器所指向的节点无效，在list中即该节点被删除了。

        因为list的底层结构为带头节点的双向循环链表，因此在list中插入元素是不会导致list迭代器失效，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

3.2 list可能导致迭代器失效的操作

        pop_back、pop_front、erase、resize、assign……

3.3解决方法

        在所有可能导致迭代器失效的操作之后，在使用迭代器前对迭代器进行重新赋值。

二、list与vector的区别★

 注意：

        空间利用率上，只是绝大多数情况下vector比list高，因为list每个节点多了两个指针域，但并不绝对。

三、模拟实现list

1.实现接口

1.1私有成员

void CreateHead();//创建头节点
Node* _head;

1.2默认成员

//默认构造函数
list();
//n个value构造
list(size_t n, const T& value = T());
template<class Iterator>
//区间构造
list(Iterator first, Iterator last);
//拷贝构造
list(const list<T>& L);
//赋值运算符重载
list<T>& operator=(list<T> L)

//析构函数
~list();

1.3迭代器

注意：

        list迭代器不能使用原生态的指针，因为list空间不连续，不能对指针进行算数运算。所以需要自己模拟封装迭代器对应类

template<class T, class Ref, class Ptr>
struct ListIterator;
template<class Iterator>
struct ListReverseIterator;

iterator begin();
iterator end();
const_iterator cbegin() const;
const_iterator cend() const;
reverse_iterator rbegin();
reverse_iterator rend();
const_reverse_iterator crbegin() const;
const_reverse_iterator crend() const;

1.4容量

size_t size() const ;
bool empty() ;
void resize(size_t newSize, const T& value = T()) ;

1.5元素访问

T& front();
const T& front() const;
T& back();
const T& back() const ;

1.6元素修改

void push_front(const T& value);
void pop_front();
void push_back(const T& value) ;
void pop_back();
iterator insert(iterator it, const T& value);
iterator erase(iterator it);
void clear();
void swap(list<T>& L) ;

2.代码实现

#include <iostream>
using namespace std;

namespace MyList {
	//链表节点
	template<class T>
	struct ListNode {
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _val;

		ListNode(const T& value = T())
			: _next(nullptr)
			, _prev(nullptr)
			, _val(value)
		{}
	};

	//注意：list迭代器不能使用原生态的指针
	//因为list空间不连续，不能对指针进行算数运算

	//模拟封装迭代器类
	template<class T, class Ref, class Ptr>
	struct ListIterator {
		typedef ListNode<T> Node;
		typedef Ref ItRef;
		typedef Ptr ItPtr;
		typedef ListIterator<T, Ref, Ptr> Self;
	public:
		//构造
		ListIterator(Node* node = nullptr)
			:_node(node)
		{}

		/*----------实现类似指针的操作----------*/
		Ref operator*() {
			return _node->_val;
		}
		Ptr operator->() {
			return &(operator*());
		}

		/*----------实现"++""--"----------*/
		Self& operator++() {
			_node = _node->_next;
			return *this;
		}
		Self operator++(int) {
			Self temp(*this);
			_node = _node->_next;
			return temp;
		}
		Self& operator--() {
			_node = _node->_prev;
			return *this;
		}
		Self& operator--(int) {
			Self temp(*this);
			_node = _node->_prev;
			return temp;
		}

		/*----------实现比较----------*/
		bool operator!=(const Self& s) const {
			return _node != s._node;
		}
		bool operator==(const Self& s) const {
			return _node == s._node;
		}

	public:
		Node* _node;
	};

	//模拟封装反向迭代器：内部封装正向迭代器即可
	template<class Iterator>
	struct ListReverseIterator {
		//因为静态成员变量也可以通过类名::静态成员名称的方式进行访问
		//直接写会编译报错，编译器不确定ItRef、ItPtr是静态成员变量还是类型
		//所以需要显示告诉编译器是typename
		typedef typename Iterator::ItRef Ref;
		typedef typename Iterator::ItPtr Ptr;
		typedef ListReverseIterator<Iterator> Self;
	public:
		ListReverseIterator(Iterator it)
			:_it(it)
		{}

		Ref operator*() {
			Iterator temp(_it);
			--temp;
			return *temp;
		}
		Ptr operator->() {
			return &(*operator*());
		}

		Self& operator++() {
			--_it;
			return *this;
		}
		Self operator++(int) {
			Self temp(*this);
			--_it;
			return temp;
		}
		Self& operator--() {
			++_it;
			return *this;
		}
		Self operator--(int) {
			Self temp(*this);
			++_it;
			return temp;
		}
		bool operator!=(const Self& rit) const {
			return _it != rit._it;
		}
		bool operator==(const Self& rit) const {
			return _it == rit._it;
		}
	public:
		Iterator _it;//正向迭代器
	};

	/*=========================================================================================*/

	template<class T>
	class list {
		typedef ListNode<T> Node;
	public:
		typedef ListIterator<T, T&, T*> iterator;
		typedef ListIterator<T, const T&, const T*> const_iterator;
		typedef ListReverseIterator<iterator> reverse_iterator;
		typedef ListReverseIterator<const_iterator> const_reverse_iterator;
	public:
		/*----------默认成员----------*/
		//默认构造函数
		list() {
			CreateHead();
		}
		//n个value构造
		list(int n, const T& value = T()) {
			CreateHead();
			for (int i = 0; i < n; ++i) { push_back(value); }
		}
		template<class Iterator>
		//区间构造
		list(Iterator first, Iterator last) {
			CreateHead();
			while (first != last) {
				push_back(*first);
				++first;
			}
		}
		//拷贝构造
		list(const list<T>& L) {
			CreateHead();
			auto it = L.cbegin();
			while (it != L.cend()) {
				push_back(*it);
				++it;
			}
		}
		//赋值运算符重载
		list<T>& operator=(list<T> L) {
			this->swap(L);
			return *this;
		}

		//析构函数
		~list() {
			clear();
			delete _head;
			_head = nullptr;
		}

		/*----------迭代器----------*/
		iterator begin() {
			return iterator(_head->_next);
		}
		iterator end() {
			return iterator(_head);
		}
		const_iterator cbegin() const {
			return const_iterator(_head->_next);
		}
		const_iterator cend() const {
			return const_iterator(_head);
		}
		reverse_iterator rbegin() {
			return reverse_iterator(end());
		}
		reverse_iterator rend() {
			return reverse_iterator(begin());
		}
		const_reverse_iterator crbegin() const {
			return const_reverse_iterator(cend());
		}
		const_reverse_iterator crend() const {
			return const_reverse_iterator(cbegin());
		}

		/*----------容量----------*/
		size_t size() const {
			Node* cur = _head->_next;
			size_t count = 0;
			while (cur != _head) {
				++count;
				cur = cur->_next;
			}
			return count;
		}
		bool empty() {
			return _head->_next == _head;
		}
		void resize(size_t newSize, const T& value = T()) {
			size_t oldSize = size();
			if (newSize < oldSize) {
				for (size_t i = oldSize; i > newSize; --i) { pop_back(); }
			}
			else {
				for (size_t i = oldSize; i < newSize; ++i) { push_back(value); }
			}
		}

		/*----------元素访问----------*/
		T& front() {
			return *begin();
		}
		const T& front() const {
			return *cbegin();
		}
		T& back() {
			return *(--end);
		}
		const T& back() const {
			return *(--cend);
		}

		/*----------元素修改----------*/
		void push_front(const T& value) {
			insert(begin(), value);
		}
		void pop_front() {
			erase(begin());
		}
		void push_back(const T& value) {
			insert(end(), value);
		}
		void pop_back() {
			erase(end()--);
		}
		iterator insert(iterator it, const T& value) {
			Node* pos = it._node;
			//插入方式，将新节点连接进去，再断开原链表
			Node* temp = new Node(value);
			//(1)连接
			temp->_next = pos;
			temp->_prev = pos->_prev;
			//(2)断开
			temp->_prev->_next = temp;
			temp->_next->_prev = temp;
			return iterator(temp);
		}
		iterator erase(iterator it) {
			if (it == end()) return end();
			Node* pos = it._node;
			Node* ret = pos->_next;

			pos->_prev->_next = pos->_next;
			pos->_next->_prev = pos->_prev;
			delete pos;
			return iterator(ret);
		}
		void clear() {
			auto it = begin();
			while (it != end()) {
				it = erase(it);//记得重新赋值，防止迭代器失效
			}
		}
		void swap(list<T>& L) {
			std::swap(_head, L._head);
		}

		/*----------私有成员----------*/
	private:
		void CreateHead() {//创建头节点
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
		}
		Node* _head;
	};
}