C++ 反向迭代器模拟实现

本章我们来解决一些历史遗留问题，就是C++中反向迭代器的实现。

一.源码分析及实现思路

SGI-STL30版本源代码，反向迭代器实现的核⼼源码在stl_iterator.h中，反向迭代器是⼀个适配器 ，各个容器中再适配出⾃⼰的反向迭代器。下⾯我们截出vector和list的的反向迭代器结构框架核⼼部分截取出来如下：

1.stl_list.h

cpp 复制代码

template <class T, class Alloc = alloc>
class list {
public:
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
typedef reverse_iterator<const_iterator> const_reverse_iterator;
typedef reverse_iterator<iterator> reverse_iterator;
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
typedef reverse_bidirectional_iterator<const_iterator, value_type,
const_reference, difference_type> const_reverse_iterator;
typedef reverse_bidirectional_iterator<iterator, value_type, reference,
difference_type> reverse_iterator;
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
iterator begin() { return (link_type)((*node).next); }
const_iterator begin() const { return (link_type)((*node).next); }
iterator end() { return node; }
const_iterator end() const { return node; }
reverse_iterator rbegin() { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const { return
const_reverse_iterator(end());}
reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rend() const { return
const_reverse_iterator(begin());}
}

• 源码中我们可以看到reverse_iterator实现了两个版本，通过__STL_CLASS_PARTIAL_SPECIALIZATION 条件编译控制使⽤哪个版本，简单点说就是⽀持

偏特化的迭代器萃取以后，反向迭代器使⽤的是这个版本， template <class Iterator>

class reverse_iterator; 之前使⽤的是

|-----------------------------------------------------------------------------------|
| template <class BidirectionalIterator, class T, class Reference,class Distance> |
| class reverse_bidirectional_iterator; |

|----------------------------------------------------------------------------------|
| template <class RandomAccessIterator, class T, class Reference,class Distance> |
| class reverse_iterator; |

• 可以看到他们的差别主要是在模板参数是否传递迭代器指向的数据类型，⽀持偏特化的迭代器萃取以后就不需要给了，因为 reverse_iterator 内部可以通过迭代器萃取获取数据类型。迭代器萃取的本质是⼀个特化。

2. stl_vector.h

cpp 复制代码

template <class T, class Alloc = alloc>
class vector {
public:
typedef T value_type;
typedef value_type* iterator;
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
typedef reverse_iterator<const_iterator> const_reverse_iterator;
typedef reverse_iterator<iterator> reverse_iterator;
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
typedef reverse_iterator<const_iterator, value_type, const_reference,
difference_type> const_reverse_iterator;
typedef reverse_iterator<iterator, value_type, reference, difference_type>
reverse_iterator;
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
iterator begin() { return start; }
const_iterator begin() const { return start; }
iterator end() { return finish; }
const_iterator end() const { return finish; }
reverse_iterator rbegin() { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const { return
const_reverse_iterator(end());}
reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rend() const { return
const_reverse_iterator(begin());}
}

3.stl_iterator.h

这是迭代器的核心实现部件，各个容器通过适配这个部件实现自己的迭代器。

bash 复制代码

template <class Iterator>
class reverse_iterator
{
protected:
    Iterator current;

public:
    typedef typename iterator_traits<Iterator>::iterator_category iterator_category;
    typedef typename iterator_traits<Iterator>::value_type value_type;
    typedef typename iterator_traits<Iterator>::difference_type difference_type;
    typedef typename iterator_traits<Iterator>::pointer pointer;
    typedef typename iterator_traits<Iterator>::reference reference;
    typedef Iterator iterator_type;
    typedef reverse_iterator<Iterator> self;

public:
    reverse_iterator() {}
    
    explicit reverse_iterator(iterator_type x) : current(x) {}
    
    reverse_iterator(const self& x) : current(x.current) {}
    
#ifdef __STL_MEMBER_TEMPLATES
    template <class Iter>
    reverse_iterator(const reverse_iterator<Iter>& x) : current(x.current) {}
#endif /* __STL_MEMBER_TEMPLATES */

    iterator_type base() const { return current; }
    
    reference operator*() const {
        Iterator tmp = current;
        return *--tmp;
    }
    
#ifndef __SGI_STL_NO_ARROW_OPERATOR
    pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */

    self& operator++() {
        --current;
        return *this;
    }
    
    self operator++(int) {
        self tmp = *this;
        --current;
        return tmp;
    }
    
    self& operator--() {
        ++current;
        return *this;
    }
    
    self operator--(int) {
        self tmp = *this;
        ++current;
        return tmp;
    }
    
    self operator+(difference_type n) const {
        return self(current - n);
    }
    
    self& operator+=(difference_type n) {
        current -= n;
        return *this;
    }
    
    self operator-(difference_type n) const {
        return self(current + n);
    }
    
    self& operator-=(difference_type n) {
        current += n;
        return *this;
    }
    
    reference operator[](difference_type n) const { 
        return *(*this + n); 
    }
};

template <class Iterator>
inline bool operator==(const reverse_iterator<Iterator>& x,
                       const reverse_iterator<Iterator>& y) {
    return x.base() == y.base();
}

template <class Iterator>
inline bool operator<(const reverse_iterator<Iterator>& x,
                      const reverse_iterator<Iterator>& y) {
    return y.base() < x.base();
}

template <class Iterator>
inline typename reverse_iterator<Iterator>::difference_type
operator-(const reverse_iterator<Iterator>& x,
          const reverse_iterator<Iterator>& y) {
    return y.base() - x.base();
}

template <class Iterator>
inline reverse_iterator<Iterator>
operator+(typename reverse_iterator<Iterator>::difference_type n,
          const reverse_iterator<Iterator>& x) {
    return reverse_iterator<Iterator>(x.base() - n);
}

#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */

// This is the old version of reverse_iterator, as found in the original
// HP STL. It does not use partial specialization.
template <class BidirectionalIterator, class T, class Reference = T&,
          class Distance = ptrdiff_t>
class reverse_bidirectional_iterator {
    typedef reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
                                          Distance> self;
protected:
    BidirectionalIterator current;

public:
    typedef bidirectional_iterator_tag iterator_category;
    typedef T value_type;
    typedef Distance difference_type;
    typedef T* pointer;
    typedef Reference reference;

    reverse_bidirectional_iterator() {}
    
    explicit reverse_bidirectional_iterator(BidirectionalIterator x)
        : current(x) {}
        
    BidirectionalIterator base() const { return current; }
    
    Reference operator*() const {
        BidirectionalIterator tmp = current;
        return *--tmp;
    }
    
#ifndef __SGI_STL_NO_ARROW_OPERATOR
    pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */

    self& operator++() {
        --current;
        return *this;
    }
    
    self operator++(int) {
        self tmp = *this;
        --current;
        return tmp;
    }
    
    self& operator--() {
        ++current;
        return *this;
    }
    
    self operator--(int) {
        self tmp = *this;
        ++current;
        return tmp;
    }
};

template <class RandomAccessIterator, class T, class Reference = T&,
          class Distance = ptrdiff_t>
class reverse_iterator {
    typedef reverse_iterator<RandomAccessIterator, T, Reference, Distance> self;
protected:
    RandomAccessIterator current;

public:
    typedef random_access_iterator_tag iterator_category;
    typedef T value_type;
    typedef Distance difference_type;
    typedef T* pointer;
    typedef Reference reference;

    reverse_iterator() {}
    
    explicit reverse_iterator(RandomAccessIterator x) : current(x) {}
    
    RandomAccessIterator base() const { return current; }
    
    Reference operator*() const { return *(current - 1); }
    
#ifndef __SGI_STL_NO_ARROW_OPERATOR
    pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */

    self& operator++() {
        --current;
        return *this;
    }
    
    self operator++(int) {
        self tmp = *this;
        --current;
        return tmp;
    }
    
    self& operator--() {
        ++current;
        return *this;
    }
    
    self operator--(int) {
        self tmp = *this;
        ++current;
        return tmp;
    }
    
    self operator+(Distance n) const {
        return self(current - n);
    }
    
    self& operator+=(Distance n) {
        current -= n;
        return *this;
    }
    
    self operator-(Distance n) const {
        return self(current + n);
    }
    
    self& operator-=(Distance n) {
        current += n;
        return *this;
    }
    
    Reference operator[](Distance n) const { 
        return *(*this + n); 
    }
};

#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

• 反向迭代器本质是⼀个适配器，使⽤模版实现，传递哪个容器的迭代器就可以封装适配出对应的反向迭代器。因为反向迭代器的功能跟正向的迭代器功能⾼度相似，只是遍历的⽅向相反，类似operator++ 底层调⽤迭代器的 operator-- 等，所以封装⼀下就可以实现。

•在这里我们需要注意一下源码中关于operator*的实现，它返回的是当前未知的前一个位置，这个与容器的rbegin和rend的实现才能定夺。

•我们来看看链表中的reverse_iterator实现逻辑。

正向迭代器的begin为头结点的next，end为头结点。

那么对于封装了iterator的reverse_iterator，它的rbegin就相当于正向迭代器的--end()，而rend就是正向迭代器的end()。

如果为了将来在适配器中实现更顺(正向的end是反向的begin，正向的begin是反向的end)，就按以下结构实现：

只不过这样实现的operator*下，应该返回当前位置的前一个位置。

二.反向迭代器的实现和容器适配

cpp 复制代码

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

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

	Ref operator*()
	{
		return *_it;
	}

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

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

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

	bool operator!=(const Self& s)
	{
		return _it != s._it;
	}

	bool operator==(const Self& s)
	{
		return _it == s._it;
	}

	Iterator _it;
};

List对我们实现的reverse_iterator的适配：

cpp 复制代码

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 ReverseIterator<iterator, T&, T*> reverse_iterator;
	typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;

	reverse_iterator rbegin()
	{
		return reverse_iterator(--end());
	}

	reverse_iterator rend()
	{
		return reverse_iterator(end());
	}
	
	
	const_reverse_iterator rbegin() const
	{
		return const_reverse_iterator(--end());
	}

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

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

	iterator end()
	{
		return _head;
	}

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

	const_iterator end() const
	{
		return _head;
	}

	//...
private:
	Node* _head;
	size_t _size;
};

对于vector的容器适配

cpp 复制代码

template<class T>
class vector
{
public:
	typedef T* iterator;
	typedef const T* const_iterator;

	typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
	typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;

	//....
	// 对称
	reverse_iterator rbegin()
	{
		return reverse_iterator(--end());
	}

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

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

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

	iterator begin()
	{
		return _start;
	}

	iterator end()
	{
		return _finish;
	}

	const_iterator begin() const
	{
		return _start;
	}

	const_iterator end() const
	{
		return _finish;
	}

	//...
private:
	iterator _start = nullptr;
	iterator _finish = nullptr;
	iterator _end_of_storage = nullptr;
};