在自定义迭代器上应用reverse_iterator后引用无效

reverse_iterator不适用于所谓的"隐藏迭代器"，即返回对自身内容的引用的迭代器。reverse_iterator的operator*生成包装迭代器的副本，对其进行递减，并返回对副本的解引用结果。因此，如果取消引用迭代器返回对其内部某个内容的引用，则该引用将变为悬空。

在C++11规范中曾试图使其工作，但事实证明，如果不为非隐藏迭代器添加大量开销^*，就不可能实现，因此该规范被恢复到C++03版本。

_{^*要支持"隐藏迭代器"，必须添加一个额外的数据成员来存储递减的当前迭代器，使reverse_iterator的大小加倍；然后必须使用某种形式的同步，因为CCD_ 5是CCD_。对于这样一个不常见的用例，要向所有reverse_iterator添加大量开销}

如前所述，C++03和C++14标准以这种方式定义reverse_iterator::operator*：

24.5.1.3.4 operator*[反向iter.op.star]

reference operator*() const;

1效果：

Iterator tmp = current;
return *--tmp;

operator*返回后，tmp将被销毁，因此对存储在tmp内部的数据的任何引用都将无效。C++11标准改变了这一点，并添加了一个注释：

24.5.1.3.4 operator*[反向iter.op.star]

reference operator*() const;

1效果：

deref_tmp = current;
--deref_tmp;
return *deref_tmp;

2[注意：此操作必须使用辅助成员变量，而不是一个临时变量，用于避免返回持续超过其关联迭代器的生存期。（见24.2.）——尾注]

这实际上是不可能实现的，因为operator*上有const限定符，所以在C++11和C++14之间恢复了措辞。

最好的解决方案可能是基于针对任何版本的C++的C++11措辞来实现您自己的reverse_iterator版本。幸运的是，该规范非常简单易懂。作为一个工作示例，下面是我为C++14编写的一个示例：

template <class Iterator>
class stashing_reverse_iterator :
  public std::iterator<
    typename std::iterator_traits<Iterator>::iterator_category,
    typename std::iterator_traits<Iterator>::value_type,
    typename std::iterator_traits<Iterator>::difference_type,
    typename std::iterator_traits<Iterator>::pointer,
    typename std::iterator_traits<Iterator>::reference
  > {
  typedef std::iterator_traits<Iterator> traits_type;
public:
  typedef Iterator iterator_type;
  typedef typename traits_type::difference_type difference_type;
  typedef typename traits_type::reference       reference;
  typedef typename traits_type::pointer         pointer;
  stashing_reverse_iterator() : current() {}
  explicit stashing_reverse_iterator(Iterator x) : current(x) {}
  template <class U>
  stashing_reverse_iterator(const stashing_reverse_iterator<U>& u) : current(u.current) {}
  template <class U>
  stashing_reverse_iterator& operator=(const stashing_reverse_iterator<U>& u) {
    current = u.base();
    return *this;
  }
  Iterator base() const {
    return current;
  }
  // Differs from reverse_iterator::operator*:
  // 1. const qualifier removed
  // 2. current iterator is stored in a member field to ensure references are
  //    always valid after this function returns
  reference operator*() {
    deref_tmp = current;
    --deref_tmp;
    return *deref_tmp;
  }
  pointer operator->() const {
    return std::addressof(operator*());
  }
  stashing_reverse_iterator& operator++() {
    --current;
    return *this;
  }
 stashing_reverse_iterator operator++(int) {
    stashing_reverse_iterator tmp = *this;
    --current;
    return tmp;
  }
  stashing_reverse_iterator& operator--() {
    ++current;
    return *this;
  }
  stashing_reverse_iterator operator--(int) {
    stashing_reverse_iterator tmp = *this;
    ++current;
    return tmp;
  }
  stashing_reverse_iterator  operator+ (difference_type n) const {
    return stashing_reverse_iterator(current - n);
  }
  stashing_reverse_iterator& operator+=(difference_type n) {
    current -= n;
    return *this;
  }
  stashing_reverse_iterator  operator- (difference_type n) const {
    return stashing_reverse_iterator(current + n);
  }
  stashing_reverse_iterator& operator-=(difference_type n) {
    current += n;
    return *this;
  }
  // Differs from reverse_iterator::operator[]:
  // 1. const qualifier removed because this function makes use of operator*
  reference operator[](difference_type n) {
    return *(*this + n);
  }
protected:
  Iterator current;
private:
  Iterator deref_tmp;
};
template <class Iterator1, class Iterator2>
bool operator==(
  const stashing_reverse_iterator<Iterator1>& x,
  const stashing_reverse_iterator<Iterator2>& y)
{ return x.base() == y.base(); }
template <class Iterator1, class Iterator2>
bool operator<(
  const stashing_reverse_iterator<Iterator1>& x,
  const stashing_reverse_iterator<Iterator2>& y)
{ return x.base() > y.base(); }
template <class Iterator1, class Iterator2>
bool operator!=(
  const stashing_reverse_iterator<Iterator1>& x,
  const stashing_reverse_iterator<Iterator2>& y)
{ return !(x.base() == y.base()); }
template <class Iterator1, class Iterator2>
bool operator>(
  const stashing_reverse_iterator<Iterator1>& x,
  const stashing_reverse_iterator<Iterator2>& y)
{ return x.base() < y.base(); }
template <class Iterator1, class Iterator2>
bool operator>=(
  const stashing_reverse_iterator<Iterator1>& x,
  const stashing_reverse_iterator<Iterator2>& y)
{ return x.base() <= y.base(); }
template <class Iterator1, class Iterator2>
bool operator<=(
  const stashing_reverse_iterator<Iterator1>& x,
  const stashing_reverse_iterator<Iterator2>& y)
{ return x.base() >= y.base(); }
template <class Iterator1, class Iterator2>
auto operator-(
  const stashing_reverse_iterator<Iterator1>& x,
  const stashing_reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base())
{ return y.base() - x.base(); }
template <class Iterator>
stashing_reverse_iterator<Iterator> operator+(
  typename stashing_reverse_iterator<Iterator>::difference_type n,
  const stashing_reverse_iterator<Iterator>& x)
{ return stashing_reverse_iterator<Iterator>(x.base() - n); }
template <class Iterator>
stashing_reverse_iterator<Iterator> make_stashing_reverse_iterator(Iterator i)
{ return stashing_reverse_iterator<Iterator>(i); }

用法与reverse_iterator:相同

// prints 5,4,3,2,1, for a sanely implemented number_iterator
std::copy(
  make_stashing_reverse_iterator(number_iterator(5)),
  make_stashing_reverse_iterator(number_iterator(0)),
  std::ostream_iterator<int>(std::cout, ","));