C++：list容器--模拟实现（下篇）

1. 模拟实现 list 一些常用接口

// list.h
#pragma once
#include <assert.h>
#include "Iterator.h"namespace room
{template<class T>struct list_node{list_node<T>* _next;list_node<T>* _prev;T _data;list_node(const T& x = T()):_next(nullptr),_prev(nullptr),_data(x){}};// 两个迭代器 -- 合成一个模板template<class T, class Ref, class Ptr>struct list_iterator{typedef list_node<T> Node;typedef list_iterator<T, Ref, Ptr> Self;Node* _node;list_iterator(Node* node):_node(node){}// 解引用运算符重载Ref operator*(){return _node->_data;}Ptr 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;}// 后置--运算符重载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;}};//// 迭代器//template<class T>//struct list_iterator//{//	typedef list_node<T> Node;//	Node* _node;//	list_iterator(Node* node)//		:_node(node)//	{}//	// 解引用运算符重载//	T& operator*()//	{//		return _node->_data;//	}//	T* operator->()//	{//		return &_node->_data;//	}//	//	// ++运算符重载//	list_iterator<T>& operator++()//	{//		_node = _node->_next;//		return *this;//	}//	// !=运算符重载//	bool operator!=(const list_iterator<T>& it)//	{//		return _node != it._node;//	}//	bool operator==(const list_iterator<T>& it)//	{//		return _node == it._node;//	}//};//// 迭代器//template<class T>//struct list_const_iterator//{//	typedef list_node<T> Node;//	Node* _node;//	list_const_iterator(Node* node)//		:_node(node)//	{}//	// 解引用运算符重载//	const T& operator*()//	{//		return _node->_data;//	}//	const T* operator->()//	{//		return &_node->_data;//	}//	// ++运算符重载//	list_const_iterator<T>& operator++()//	{//		_node = _node->_next;//		return *this;//	}//	// !=运算符重载//	bool operator!=(const list_const_iterator<T>& it)//	{//		return _node != it._node;//	}//	bool operator==(const list_const_iterator<T>& it)//	{//		return _node == it._node;//	}//};template<class T>class list{typedef list_node<T> Node;public:/*typedef Node* iterator;typedef list_iterator<T> iterator;typedef list_const_iterator<T> const_iterator;*/typedef list_iterator<T, T&, T*> iterator;typedef list_iterator<T, const T&, const T*> const_iterator;typedef ReverseIterator<iterator, T&, T*> reverse_iterator;typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;// 第一种写法//reverse_iterator rbegin()//{//	return reverse_iterator(--end());//}//reverse_iterator rend()//{//	return reverse_iterator(end());//}// 对称reverse_iterator rbegin(){return reverse_iterator(end());}reverse_iterator rend(){return reverse_iterator(begin());}const_reverse_iterator rbegin() const{return const_reverse_iterator(end());}const_reverse_iterator rend() const{return const_reverse_iterator(begin());}iterator begin(){//return iterator(_head->_next);iterator it(_head->_next);return it;}iterator end(){return iterator(_head);}const_iterator begin() const{return const_iterator(_head->_next);}const_iterator end() const{return const_iterator(_head);}void empty_init(){_head = new Node;_head->_next = _head;_head->_prev = _head;_size = 0;}list(){/*_head = new Node;_head->_prev = _head;_head->_next = _head;*/empty_init();}list(initializer_list<T> lt){empty_init();for (auto& e : lt){push_back(e);}}// lt2(lt1)list(const list<T>& lt){empty_init();for (auto& e : lt){push_back(e);}}// lt1 = lt3list<T>& operator=(list<T> lt){swap(lt);return *this;}void swap(list<T>& lt){std::swap(_head, lt._head);std::swap(_size, lt._size);}~list(){clear();delete _head;_head = nullptr;}void clear(){iterator it = begin();while (it != end()){it = erase(it);}}size_t size() const{return _size;}void push_back(const T& x){/*Node* newnode = new Node(x);Node* tail = _head->_prev;newnode->_prev = tail;tail->_next = newnode;newnode->_next = _head;_head->_prev = newnode;*/insert(end(), x);}void push_front(const T& x){insert(begin(), x);}void pop_front(){erase(begin());}void pop_back(){erase(--end());}void insert(iterator pos, const T& x){Node* cur = pos._node;Node* prev = cur->_prev;Node* newnode = new Node(x);prev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;++_size;}iterator erase(iterator pos){assert(pos != end());Node* cur = pos._node;Node* nextNode = cur->_next;Node* prevNode = cur->_prev;prevNode->_next = nextNode;nextNode->_prev = prevNode;delete cur;--_size;return iterator(nextNode);}private:Node* _head;size_t _size;};
}

2. list 的反向迭代器

        反向迭代器的 ++ 就是正向迭代器的 --，反向迭代器的 -- 就是正向迭代器的 ++。因此，反向迭代器的实现可以借助正向迭代器，即：反向迭代器内部可以包含一个正向迭代器，对正向迭代器的接口进行包装即可。

// Iterator.h
// 所有容器的反向迭代器
// 迭代器适配器
#pragma oncetemplate<class Iterator, class Ref, class Ptr>
class ReverseIterator
{
public:typedef ReverseIterator<Iterator, Ref, Ptr> Self;ReverseIterator(Iterator it): _it(it){}Ref operator*(){//return *_it;	// 第一种写法Iterator tmp = _it;--tmp;return *tmp;}Ptr operator->(){return &(operator*());}Self& operator++(){--_it;return *this;}Self& operator--(){++_it;return *this;}bool operator!=(const Self& s){return _it != s._it;}bool operator==(const Self& s){return _it == s._it;}private:Iterator _it;
};

3. list 与 vector 的对比

        vector 与 list 都是STL中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：

	vector	list
底层结构	动态顺序表，一段连续空间	带头结点的双向循环链表
随机访问	支持随机访问，访问某个元素效率O(1)	不支持随机访问，访问某个元素效率O(n)
插入和删除	任意位置插入和删除效率低，需要挪动元素，时间复杂度为O(n)，插入时有可能需要扩容，扩容：开辟新空间，拷贝元素，释放旧空间，导致效率更低	任意位置插入和删除效率高，不需要挪动元素，时间复杂度为O(1)
空间利用率	底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高	底层结点动态开辟，小结点容易造成内存碎片，空间利用率低，缓存利用率低
迭代器	原生态指针	对原生态指针（结点指针）进行封装
迭代器失效	在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值否则会失效	插入元素不会导致迭代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不受影响
使用场景	需要高效存储，支持随机访问，不关心插入删除效率	大量插入和删除操作，不关心随机访问