[boost] Re: boost::operators -> boost::iterator_ops ?

From: jsiek_at_[hidden]
Date: 1999-11-28 19:17:22

Dave Abrahams writes:
 > Except that if you don't have a random access iterator unless op- is
 > supported. Whether an algorithm chooses to make use of op- is an
 > implementation detail. If you give an iterator's traits the tag
 > random_access_iterator_tag, but you don't define op-, you're essentially
 > lying to whatever library is going to use the traits.

True, if we define the random_access_iterator_tag, the iterator
should be a RandomAccessIterator. But on the other hand, the
random_access_iterator_tag was added only as a convenience to the
user. In general I am against adding extra requirements that aren't
really needed (it is a barrier to reuse). However, in this case I see
little harm in requiring the difference operator so that we can go
ahead an define the random_access_iterator_tag.

 > That would be an improvement, but only inasmuch as it improves the error
 > messages you get. As it stands, if you try to derive from
 > less_than_comparable and you haven't defined op<, your program is ill-formed
 > and you WILL get a diagnostic.

True.

 > One possible solution to my problem: have the random access helper define a
 > friend function (never called) which calls op- on a pair of const T&, and
 > somehow ensures that the result has the appropriate difference_type. I'm
 > sure we can come up with an answer to that last missing detail.

This would do the trick:

template <class T,
          class V, 
          class D = std::iterator_traits<char*>::difference_type, 
          class P = V*,
          class R = V&>
struct random_access_iterator_helper :
  equality_comparable<T,T>,
  less_than_comparable<T,T>,
  incrementable<T>,
  decrementable<T>,
  dereferenceable<T,V>,
  addable<T,D>,
  subtractable<T,D>,
  indexable<T,D,R>,
  std::iterator<std::random_access_iterator_tag, V, D, P, R>
{
  friend D requires_difference_operator(const T& x, const T& y) {
    return x - y;
  }
};

Cheers,

Jeremy