iterator的用法 | reverse_iterator的封装实现

进阶C++__STL__容器list使用方法【简单易懂】https://blog.csdn.net/qq_61386381/article/details/125922910

进阶C++__STL__容器vector使用方法【简单易懂】_https://blog.csdn.net/qq_61386381/article/details/125869840

对 map 和 set 来说，它们的 erase 函数返回的 void，而在进行 erase 之后，当前迭代器会失效，无法再用于获取下一个迭代器。因此需要 erase 之前就获取指向下一个元素的迭代器

tmpIt = it;

++it;

c.erase(tmpIt);

利用后缀++操作符的特性（先创建副本，然后再递增迭代器，然后返回副本）上面的三行代码可以简化为一行：

c.erase(it++);

list 正向遍历删除元素示例（vector 用法相同）：

    list<int>::iterator it;
    for (it = l.begin(); it != l.end();)
    {
        if (0 == (*it) % 2) {
            it = l.erase(it);
        }
        else {
            ++it;
        }
    }

map 正向遍历删除元素示例（set 用法相同）：
 

   map<int, int>::iterator mit;
    for (mit = m.begin(); mit != m.end();)
    {
        if (0 == mit->first % 2) {
            m.erase(mit++);
        }
        else {
            ++mit;
        }
    }

reverse_iterator的封装实现

反向迭代器适配器（reverse_iterator），可简称为反向迭代器或逆向迭代器，常用来对容器进行反向遍历，即从容器中存储的最后一个元素开始，一直遍历到第一个元素。

值得一提的是，反向迭代器底层可以选用双向迭代器或者随机访问迭代器作为其基础迭代器。不仅如此，通过对 ++（递增）和 --（递减）运算符进行重载，使得：

• 当反向迭代器执行 ++ 运算时，底层的基础迭代器实则在执行 -- 操作，意味着反向迭代器在反向遍历容器；
• 当反向迭代器执行 -- 运算时，底层的基础迭代器实则在执行 ++ 操作，意味着反向迭代器在正向遍历容器。

另外，实现反向迭代器的模板类定义在 <iterator> 头文件，并位于 std 命名空间中。 

函数接口 

// 将以下代码适配到vector和list中做反向迭代器，理解反向迭代器的原理
namespace bit
{
	// 适配器 -- 复用
	template<class Iterator, class Ref, class Ptr>
	struct Reverse_iterator
	{
		Iterator _it;
		typedef Reverse_iterator<Iterator, Ref, Ptr> Self;
		
		Reverse_iterator(Iterator it)
			:_it(it)
		{}
 
		Ref operator*()
		{
			Iterator tmp = _it;
			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;
		}
	};
}

函数实现

namespace bit
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
 
		// 反向迭代器适配支持
		typedef Reverse_iterator<iterator, T&, T*> reverse_iterator;
		typedef Reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;
 
		const_reverse_iterator rbegin() const
		{
			// list_node<int>*
			return const_reverse_iterator(end());
		}
 
		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(begin());
		}
 
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}
 
		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}
 
		iterator begin()
		{
			return _start;
		}
 
		iterator end()
		{
			return _finish;
		}
 
		const_iterator begin() const
		{
			return _start;
		}
 
		const_iterator end() const
		{
			return _finish;
		}
        // ...
}


namesapce std
{
    template<class T>
	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;
 
		// 反向迭代器适配支持
		typedef Reverse_iterator<iterator, T&, T*> reverse_iterator;
		typedef Reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;
 
		const_iterator begin() const
		{
			// list_node<int>*
			return const_iterator(_head->_next);
		}
 
		const_iterator end() const
		{
			return const_iterator(_head);
		}
 
		iterator begin()
		{
			return iterator(_head->_next);
			//return _head->_next;
		}
 
		iterator end()
		{
			return iterator(_head);
		}
 
		const_reverse_iterator rbegin() const
		{
			// list_node<int>*
			return const_reverse_iterator(end());
		}
 
		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(begin());
		}
 
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}
 
		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}
        //...
    }
  }