（入门自用）C++--反向迭代器--0927

容器

array,string,vector,list等

array

即静态数组。

相比于C语言中的数组实现

array<int,10> al;//创建一个可以存放10个int类型的静态数组

int a2[10];//效果跟上面一样

 优点

越界都能查出来 -- 函数调用
a1[10];
a1[15] = 0;

指针解引用 --  抽查是否越界，只针对越界写，越界读不检查 

容器适配器

用容器实现的数据结构。stack、queue、queue、priority_queue、反向迭代器（复用迭代器）

反向迭代器

非复用的list反向迭代器

反向迭代器的功能实现与迭代器在用户端看来仅有++或--的方向不同。所以可以在一个新的头文件中复制迭代器加以修改，重载++，--，*，->等操作符。

这里以实现非复用的list的反向迭代器为例，操作如下：

注意：实现此处时，选取的rend()为 end()位置，rbegin()位置为end()的前一个位置。

与库里实现的位置并不相同。

//以下代码写在 reverse_iterator.h文件
namespace chy //命名空间可以不连续
{
    template<class Iterator,class Ref,class Ptr>
    struct __reverse_iterator
    {
        Iterator _cur;
        typedef __reverse_iterator<Iterator,Ref,Ptr> reverse_iterator;
        reverse_iterator(Iterator it)//使用迭代器构造
            :_cur(it);
        {}
        reverse_iterator operator++()//调用++不用传参数 且返回类型为反向迭代器
        {
            //反向迭代器++ 就是--
            --_cur;
            return *this;
        }
        reverse_iterator operator--()//调用--不用传参数 且返回类型为反向迭代器
        {
            //反向迭代器-- 就是++
            ++_cur;
            return *this;
        }
        Ref operator*()//返回值为引用类型
        {
            return *_cur;
        }  
        Ptr operator->()//返回值为指针类型
        {
            return &(operator*());
        }
    }
}

复用的list反向迭代器

注意：这里采用和库里相同的 rend() rbegin()会返回的位置。在库中，采用了完全对称的结构。

rend()就是begin()的位置，rbegin()就是end()的位置。因此，上述代码中*操作符的重载需更新写法

Ref operator*()
{
    auto tmp=_cur;
    --tmp;
    return *tmp;
} 

在list.h中 #include "reverse_iterator.h"

#pragma once
namespace chy
{
    //结点结构体
    template<class T>
    stuct list_node    
    {};
    
    //迭代器
    struct list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref, Ptr> iterator;

		typedef bidirectional_iterator_tag iterator_category;
		typedef T value_type;
		typedef Ptr pointer;
		typedef Ref reference;
		typedef ptrdiff_t difference_type;


		Node* _node;

		list_iterator(Node* node)
			:_node(node)
		{}

		Ref operator*()
		{
			return _node->_data;
		}
	};

 
    //链表
    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
		{
			return const_iterator(_head->_next);
		}

		const_iterator end() const
		{
			return const_iterator(_head);
		}

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

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

		reverse_iterator rbegin()//复用
		{
			return reverse_iterator(end());
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}



    private:
        Node* _head; 
    };
    
    //迭代器
    //{...}
}