迭代器的使用

什么是迭代器

所谓迭代器，其本质也是一个模板类，是一种用于遍历数据集合的对象，它提供了一种统一的访问数据集合中元素的方式。通过迭代器，用户可以依次访问数据集合中的每个元素，而不必关心数据集合的具体实现方式。

迭代器的作用

迭代器提供一种统一的方式来遍历数据集合中的元素，无论数据集合的具体实现方式如何，在string容器中我们可以使用[ ]来进行遍历、取值，前提是是一个连续的储存空间，而对于像list容器这种储存空间不连续的容器就没有[ ]，迭代器的作用也就体现出来，而且迭代器不仅list这类容器可用，string这类容器也可以用。

迭代器的实现

对于容器来说需要的函数有begin()，end()。

而迭代器需要重载 *、->、++、--、==、!=、使其具有了遍历复杂数据结构的能力，其遍历机制取决于所遍历的容器，所有迭代器的使用和指针的使用非常相似。

以list容器迭代器为例实现

//迭代器部分需要实现的内容
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->_var;
	}
	Ptr operator->()
	{
		return &_node->_var;
	}
	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& node) const
	{
		return _node != node._node;
	}
	bool operator==(const self& node) const
	{
		return _node == node._node;
	}
};



//list容器部分需要实现的内容
class list {
	typedef list_node<T> Node;
public:
	typedef list_iterator<T, T&, T*> iterator;
	typedef list_iterator<T, const T&, const T*> const_iterator;
	iterator begin()
	{
		return iterator(node->_next);
	}
	iterator end()
	{
		return node;
	}
	const_iterator begin()const
	{
		return const_iterator(node->_next);
	}
	const_iterator end()const
	{
		return node;
	}
}

反向迭代器

1.反向迭代器和正向迭代器结构相同。

2.反向迭代器的头是正向迭代器的尾，反向迭代器的尾是正向迭代器的头。

3.同样反向迭代器的++是正向迭代器的--，反向迭代器的--是正向迭代器的++。

4.其他操作与正向迭代器相同

反向迭代器的实现

template<class Iterator, class Ref, class Ptr>
struct Reverse_iterator
{
    typedef ReverseIterator<Iterator, Ref, Ptr> Self;
    Iterator _it;

    Reverse_iterator(Iterator it)
        :_it(it)
    {
    }

    Ref operator*()
    {
        Iterator tmp = _it;
        return *(--tmp);
    }

    Ptr operator->()
    {
        return &(operator*());
    }

    Self& operator++()
    {
        --_it;
        return *this;
    }
    Self operator++(int)
    {
        Iterator tmp = *_it;
        --_it;
        return tmp;
    }
    Self& operator--()
    {
        ++_it;
        return *this;
    }
    Self operator--(int)
    {
        Iterator tmp = *_it;
        ++_it;
        return tmp;
    }
    bool operator!=(const Self& s) const
    {
        return _it != s._it;
    }
    bool operator==(const Self& s) const
    {
        return _it == s._it;
    }
        
};

总的来说迭代器是一种用于遍历数据集合的对象，它提供了一种统一的访问数据集合中元素的方式。迭代器隐藏了数据集合的内部结构，使得用户可以通过统一的接口访问数据集合中的元素，而不必关心数据集合的具体实现细节。迭代器的作用在于提供了一种统一的、灵活的、可迭代的访问数据集合中元素的方式，从而简化了数据集合的遍历操作，提高了代码的灵活性和可维护性。通过迭代器，用户可以方便地遍历各种数据结构，如数组、列表、集合等，并在遍历的同时进行一些操作，如过滤、转换等。迭代器在许多编程语言中都有广泛的应用，是一种非常重要的数据访问工具。