How to check if simple C++ standard library iterator can be advanced?

Question

Suppose I have a class encapsulating std container:

class Stash
{
    list<int> Data;

public:
    list<int>::const_iterator GetAccess() const { return Data.begin(); }
};

It's very convenient way of forcing the user to read the data in form of the iterator. However, I can't find the way other that comparing the iterator to container.end(). So, I would like to know if there's an option to do it solely by stdlib or I have to write iterator class myself (with can_advance method, for example).

Relevant question might be this one, but it asks whether the iterator is valid, not whether it can advance. I weren't able to find any information about the latter.

This is one of the reasons a `yield` keyword would be helpful. :/ — Xeo, Aug 15 '12 at 14:39
If you explain why in answer, I will accept it. I can't accept a comment ;) — Bartek Banachewicz, Aug 15 '12 at 14:39
Check out `boost::range` http://www.boost.org/doc/libs/1_50_0/libs/range/doc/html/index.html — Nikolai Fetissov, Aug 15 '12 at 14:44
@NikolaiNFetissov Unfortunately, I can't use boost in the thing I am currently working on; other than that, it's certainly better. — Bartek Banachewicz, Aug 15 '12 at 14:46
@Nikolai, well, the `pair` is simple enough for now. I don't think I need anything more complicated. Thanks for the input, though. — Bartek Banachewicz, Aug 15 '12 at 14:51
`boost::range` is effectively just that, except that it offers `begin()` and `end()` methods (and the needed typedefs you can get from `std::iterator`). — Xeo, Aug 15 '12 at 14:53

score 4 · Accepted Answer · answered Aug 15 '12 at 14:41

4

You can't do this, a single iterator does not contain the information when it is at the end of the sequence its pointing into.

Normally, this is solved by either providing a range (think std::make_pair(cont.begin(), cont.end())), or providing begin() and end() methods to your class, effectively making it a range.

answered Aug 15 '12 at 14:41

Xeo

129,499
52
291
397

Can I safely compare to the stored `.end()` later on? I mean, is it always valid, even if the container's items change? – Bartek Banachewicz Aug 15 '12 at 14:43
3

@Bartek: Depends on the container's iterator invalidation semantics. With `std::list`, it's fine. However, you shouldn't modify the container while iterating over it, that is normally considered *bad*. – Xeo Aug 15 '12 at 14:44

score 2 · Answer 2 · answered Aug 15 '12 at 15:16

2

Iterators work in pairs: an iterator that points to the beginning of a sequence and an iterator that points past the end of the sequence. That's why all the containers have begin() and end() member functions: so you can look at the sequence of values that the container manages.

It would be far more idiomatic to change the name of GetAccess to begin and to add end. Having end() would also make it possible to apply standard algorithms to the data.

answered Aug 15 '12 at 15:16

Pete Becker

74,985
8
76
165

+1 for possibility of applying standard algorithms to the returned iterator. – Bartek Banachewicz Aug 15 '12 at 15:26

score 0 · Answer 3 · answered Aug 16 '12 at 01:24

0

What you seem to be asking for is a "lookahead" iterator. You could write a class to "adapt" an iterator to have lookahead, where the adaptor just stays one step ahead of your code:

template<class FwdIter>
class lookahead_iterator
{
public:
    lookahead_iterator(const FwdIter& begin): cur_iter(begin), next_iter(++begin) {}
    operator FwdIter() const { return cur_iter; }
    lookahead_iterator<FwdIter>& operator ++() { cur_iter = next_iter++; return *this; }
    // Other methods as needed.
private:
    FwdIter cur_iter;
    FwdIter next_iter;
};

Needless to say, this gets a lot more complicated if you need more than a forward iterator.

answered Aug 16 '12 at 01:24

Mike DeSimone

41,631
10
72
96

I suppose `operator FwdIter() const { return cur_iter; }` was to be either `operator FwdIter ...` or `FwdIter operator() ...` – Bartek Banachewicz Aug 16 '12 at 07:17
It's supposed to be an overload for the typecast operator, invoked by explicit or implicit `static_cast(my_lookahead_operator)` or `(FwdIter)my_lookahead_operator`. It's definitely not `operator()`. – Mike DeSimone Aug 16 '12 at 12:38
I'm not sure what you mean. See http://www.learncpp.com/cpp-tutorial/910-overloading-typecasts/ for an intro on overloading typecast operators. – Mike DeSimone Aug 16 '12 at 13:25

How to check if simple C++ standard library iterator can be advanced?

3 Answers3