总结实现list类

一.链表节点类

链表节点均用struct实现，均为公共变量，节点结构体中实现默认参数构造函数，为初始化头节点，生成一个新节点使用。

二.迭代器类

三个参数避免冗余代码，由list类调用时传值，对应的参数调用对应的成员函数，构造函数是直接将节点的指针赋值为迭代器类的成员变量，重载运算符通过指针去遍历结构体。

template <class T,class REF,class STR>
	struct _list_iterator {
		typedef listNode<T> Node;
		typedef _list_iterator<T,REF,STR> self;
		//typedef _list_iterator<T,const T&> const_iterator;
		Node* _node;
		_list_iterator<T, REF, STR>(Node* node=nullptr) {
			_node = node;
		}
		self& operator++() {//ǰ++
			_node = _node->_next;
			return *this;
		}
		self& operator--() {
			_node = _node->_prev;
			return *this;
		}
		self operator++(int) {
			self temp(*this);
			_node = _node->_next;
			return temp;
		}
		self operator--(int) {
			self temp(*this);
			_node = _node->_prev;
			return temp;
		}
		REF operator*() {
			return _node->_data;
		}
		bool operator!=(const self& s) const {
			if (_node != s._node)
				return true;
			else
				return false;
		}
		bool operator!=(const self& d)
		{
			if (_node != d._node)
				return true;
			else
				return false;
		}
		bool operator==(const self& s) const {
			if (_node == s._node)
				return true;
			else
				return false;
		}
		bool operator==(const self& s) {
			if (_node == s._node)
				return true;
			else
				return false;
		}
		STR operator->() {
			return &_node->_data;
		}
	};

三.list类

typedef迭代器类通过传不同的参数将迭代器分为const_iterator和iterator，比如实现list拷贝构造的时候就会调用const_iterator迭代器将对象的值给temp。实现迭代器的成员函数begin()和end()直接返回节点地址（单参数节点地址会调用迭代器类的构造函数实现隐式类型转换变成迭代器类）。

template <class T>
	class list {
	public:
		typedef listNode<T> Node;
		typedef _list_iterator<T,T&,T*> iterator;
		typedef _list_iterator<T, const T&,T*> const_iterator;
		//typedef _list_iterator<T, const T&,T*> const_iterator;
		list() {
			_head = new Node;
			_head->_next = _head->_prev = _head;
		}
		list(const list<T>& l) {
			_head = new Node;
			_head->_next = _head->_prev = _head;
			for (const auto& temp :  l) {
				push_back(temp);
			}
		}
		~list() {
			clear();
			delete _head;
		}
		void clear() {
			Node* cur = _head->_next;
			while (cur != _head) {
				Node* next= cur->_next;
				erase(cur);
				cur = next;
			}
		}
		iterator begin() {
			return _head->_next;
		}
		const_iterator begin() const {
			return _head->_next;
		}		
		iterator end() {
			return _head;
		}
		const_iterator end() const {
			return _head;
		}
		list<T>& operator=(list<T> l) {
			swap(l);
			return *this;
		}
		void push_front(const T& t = T()) {
			insert(begin(),t);
		}
		void pop_front() {
			auto it = begin();
			erase(it);
		}
		void push_back(const T& t = T()) {
			Node* node = new Node(t);
			Node* tail = _head->_prev;
			node->_prev = tail;
			tail->_next = node;
			node->_next = _head;  
			_head->_prev = node;
		}
		void pop_back() {
			Node* tail = _head->_prev;
			assert(tail != _head);
			tail->_prev->_next = _head;
			tail->_next->_prev = tail->_prev;
			delete tail;
		}
		iterator erase(iterator pos) {
			assert(pos != _head);
			Node* nodenext = pos._node->_next;
			pos._node->_prev->_next = pos._node->_next;
			pos._node->_next->_prev = pos._node->_prev;
			free(pos._node);
			pos._node = nullptr;
			return nodenext;
		}
		iterator insert(iterator pos,const T& t=T()) {
			Node* newnode = new Node(t);
			newnode->_prev = pos._node->_prev;
			newnode->_next = pos._node;
			pos._node->_prev->_next = newnode;
			pos._node->_prev = newnode;
			return newnode;
		}
		void swap(list<T>& l) {
			/*Node* temp = _head;
			_head = l._head;
			l._head = temp;*/
			std::swap(_head, l._head);
		}

	private:
		Node* _head;
	};