C++迭代器模拟实现及理解

 个人主页：Lei宝啊 

愿所有美好如期而遇

---

迭代器理解： 

string和vector容器，他们底层的物理空间是连续的，所以他们的迭代器可以使用原生指针，char*，模板T*，但是list，map等容器，他们底层的物理空间不是连续的，所以他们的迭代器也就不能使用原生指针，我们平时是怎么使用迭代器呢？list::iterator  it;   it++;  it++是怎么到达下一个链表节点的呢？

我们可以想想iterator是什么类型，自定义类型可以进行运算符重载，也就是说it++是进行了运算符重载才能实现的，但是我们去哪里进行运算符重载，list里实现运算符重载？那就是list的++重载，所以我们需要定义一个iterator类，在他自己的类里进行++运算符重载，然后将他的类名在list类里typedef为iterator，这样，list就可以使用iterator了，list里的begin(),end()方法，返回值是iterator，也就是说在返回时构造一个iterator对象。

我们还可以发现一个问题，所有容器的迭代器都叫做iterator，每个容器的迭代器都是不同的，但是为了保证使用的统一性，在容器的内部统一将迭代器类重命名为iterator。

迭代器不只有iterator，还有反向迭代器，reverse_iterator，我们理解了上面的内容后，这个就很简单，再写出他们的迭代器类，再在容器类里面重命名为iterator_reverse不就行了，这样虽然是可行的，但是代码重复性太高，那么库里是怎么实现的呢？库里使用了适配器，只写了一个reverse_iterator类，模板参数加上class iterator，只要得到你的正向迭代器，那么我就能适配出反向迭代器，并且不管是哪个容器，都能适配出来。

迭代器模拟实现：

实现迭代器，我们还要模拟实现容器，vector，list都可以，我们这里以list为例，先模拟实现list：

	template
	struct ListNode
	{
		ListNode* next;
		ListNode* prev;
		T data;

		ListNode(const T& x = T())
			:next(nullptr)
			,prev(nullptr)
			,data(x)
		{}
	};

template
class list
{
	typedef ListNode Node;
public:
	typedef __list_iterator iterator;
	typedef __list_iterator const_iterator;

	typedef Reverse_iterator reverse_iterator;
	typedef Reverse_iterator const_reverse_iterator;

	void empty_init()
	{
		_head = new Node();
		_head->prev = _head;
		_head->next = _head;
	}

	//构造函数
	//list lt(); <  this
	//
	list()
	{
		empty_init();
	}

	list(int n, const T& value = T())
	{
		empty_init();
		for (int i = 0; i < n; i++)
		{
			push_back(value);
		}
	}

	template 
	list(Iterator first, Iterator last)
	{
		empty_init();
		while (first != last)
		{
			push_back(*first);
			first++;
		}
	}

	void swap(list& x)
	{
		std::swap(_head, x._head);
	}

	//拷贝构造
	list(list& copy)
	{			 
		empty_init();

		iterator it = copy.begin();
		while (it != copy.end())
		{
			push_back(it._node->data);
			it++;
		}
	}

	list& operator=(list tmp)
	{
		swap(tmp);
		return *this;
	}

	void push_back(const T& x = T())
	{
		//_head->prev newnode _head

		//Node* newnode = new Node(x);
		//Node* tail = _head->prev;
		//
		//tail->next = newnode;
		//newnode->prev = tail;
		//_head->prev = newnode;
		//newnode->next = _head;
		insert(end(), x);

	}

	void push_front(const T& val)
	{
		insert(begin(), val);
	}

	iterator insert(iterator pos, const T& x = T())
	{
		//pos->prev newnode pos
		Node* cur = pos._node;
		Node* prev = cur->prev;
	
		//prev newnode cur
		Node* newnode = new Node(x);
		newnode->next = cur;
		cur->prev = newnode;
		prev->next = newnode;
		newnode->prev = prev;

		return newnode;
	}

	reverse_iterator rbegin()
	{
		return end();
	}

	reverse_iterator rend()
	{
		return begin();
	}

	const_reverse_iterator rbegin()const
	{
		return end();
	}

	const_reverse_iterator rend()const
	{
		return begin();
	}

	iterator begin()
	{
		return iterator(_head->next);
	}

	const_iterator begin() const
	{
		return _head->next;
	}

	iterator end()
	{
		return iterator(_head);
	}

	const_iterator end() const
	{
		return _head;
	}

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

		prev->next = next;
		next->prev = prev;

		return iterator(next);
	}

	void pop_back() 
	{ 
		erase(--end()); 
	}

	void pop_front() 
	{ 
		erase(begin()); 
	}	

	size_t size()const
	{
		int num = 0;
		Node* cur = _head->next;
		while (cur != _head)
		{
			num++;
			cur = cur->next;
		}

		return num;
	}

	bool empty()const
	{
		return _head->next == _head;
	}

	T& front()
	{
		return _head->next->data;
	}

	const T& front()const
	{
		return _head->next->data;
	}

	T& back()
	{
		return _head->prev->data;
	}

	const T& back()const
	{
		return _head->prev->data;
	}

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

	~list()
	{
		clear();

		delete _head;
		_head = nullptr;
	}

private:
	Node* _head;

};

接下来就是迭代器：

template
struct __list_iterator
{
	typedef ListNode Node;
	
public:

	//构造函数
	__list_iterator(Node* node = nullptr)
		:_node(node)
	{}

	__list_iterator(const __list_iterator& self)
		:_node(self._node)
	{}

	//前置++
	__list_iterator& operator++()
	{
		_node = _node->next;
		return *this;
	}

	//后置++
	__list_iterator& operator++(int)
	{
		//auto tmp = __list_iterator(this->_node);
		auto tmp = __list_iterator(*this);
		_node = _node->next;
		return tmp;
	}

	//前置--
	__list_iterator& operator--()
	{
		_node = _node->prev;
		return *this;
	}

	//后置--
	__list_iterator& operator--(int)
	{
		//auto tmp = __list_iterator(this->_node);
		auto tmp = __list_iterator(*this);
		_node = _node->prev;
		return tmp;
	}

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

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

	bool operator!=(const __list_iterator& x)
	{
		return _node != x._node;
	}
	
	bool operator==(const __list_iterator& x)
	{
		return _node == x._node;
	}

	Node* _node;
};

最后就是适配器：

	// 将以下代码适配到vector和list中做反向迭代器，理解反向迭代器的原理
	// 适配器 -- 复用
	template
	struct Reverse_iterator
	{
		//构造函数
		Reverse_iterator(iterator it)
			:_it(--it)
		{}

		Reverse_iterator& operator++()
		{
			_it--;
			return *this;
		}

		//后置++
		Reverse_iterator& operator++(int)
		{
			//auto tmp = __list_iterator(this->_node);
			auto tmp = Reverse_iterator(*this);
			_it--;
			return tmp;
		}

		bool operator!=(const Reverse_iterator& x)
		{
			return _it != x._it;
		}

		Ref operator*()
		{
			return *_it;
		}

		iterator _it;
	};
	// vector和list反向迭代器实现