"Pavol Droba" <droba@topmail.sk> wrote in message | > iterator_range: | > -------------- | > | > value_type& front() const; | > value_type& back() const; | > value_type& operator[]( size_type ) const; | > value_type& at( size_type ) const; | > | | These functions seems usefull. However, I think, that operator[] should | be available only when underlaying iterator is random-access like yes, it won't compile otherwise. | > void advance( size_type ); | > void narrow( size_type left, size_type right ); | > iterator_range& operator++(); | > value_type& operator*() const; | > | | I assume, that these are inspired by John Torjo's RTL. I'm not very keen of them, | since I consider the using of an iterator_range instead of iterator confusing. Ok, so here's how I was thinking: if we add, let's say, only operator++() and operator*(), then we get a very simple way to iterate over the range... manual loops are still very inconvenient in C++. (Yes, BOOST_FOREACH willl improve things a lot). Anyway, currently you would have to write for( typename range_iterator<Range>::type i = r.begin(), e = r.end(); ++i ) { ... } with the new stuff we simply say for( ; r, ++r ) { ... } If you consider sub_range<>, then we get a new kind of "iterator" that actually propagates constness, so it might complement iterator and const_iterator. | > freestanding: | > ------------ | > | > iterator_range make_sub_range( range&, size_type left, size_type right = 0 ); | > iterator_range make_super_range( range&, size_type left, size_type right = | > 0 ); | > iterator_range make_range( range&, difference_type left, difference_type right | > = 0 ); | > | | Generaly the same issue as above applies. However, I find these functions | not so offending. There might be a use for the them (last one especialy). ok. | What I find important when including such a functions is to make sure, | you don't get into the problems with less capable iterators. | (i.e that you don't disable the iterator_range for forward-only iterators | for instance) ah well, there is no magic in these functions, they work by calling std::advance() and will work for all forward iterators. they will of couse not work for single-pass iterators. -Thorsten