Question

I have a class with an standard container member, and I’m wondering is that possible that I make an own iterator with a specific route, for example it goes back and forth, and after that stops.

template<class T>
class compressed_string {
    vector<T> v;
public:
    typedef typename std::vector<T>::iterator iterator;
    iterator begin() { return v.begin(); }
    iterator end() { return v.end(); }

    compressed_string& add(const T& elem) {
        v.push_back(elem);
        return *this;
    }
    basic_string<T> not_nice_way_to_make_real_string() {
        basic_string<T> tmp;
        for(iterator i = v.begin(); i < v.end(); ++i)
            tmp += *i;
        for(iterator i = --v.end(); i >= v.begin(); --i)
            tmp += *i;
        return tmp;
    }
};

main:

compressed_string<char> s;
s.add('q').add('w').add('e').add('w');

cout << s.not_nice_way_to_make_real_string(); // q w e w w e w q

cout << endl

for ( compressed_string<char>::iterator i = s.begin(); i < s.end(); ++i )
    cout << *i;

So with this iterator member the output would be the same in this two lines.

How is this possible?

Answer 1

You’ll need an iterator that stores a bit of state:

• where it is (e.g. an iterator v_it over v)
• where it’s going (e.g. bool forward)
• where it’s bounded (e.g. iterators v_begin = v.begin() and v_end = v.end())

and some otherwise invalid iterator to represent the end, such as {v_end, backward}).

Then implement the increment operator along the lines of:

if (forward) {
    if (++v_it == v_end) {
        forward = false;
        --v_it;
    }
} else {
    if (v_it-- == v_begin) {
        v_it = v_end;
    }
}

and similarly for decrement, if you want a bidirectional iterator; in which case, it would be polite to provide a reverse_iterator too. You should provide both pre- and post-increment forms.

You’ll also need == and != comparisons, comparing both v_it and forward, and dereference operators * and -> that dereference v_it, and suitable begin and end functions; for bonus points, a const_iterator would be nice.

Note that you’ll need random access if you really want the code in your question (i < s.end() rather than the more generic i != s.end()) to work; that’s entirely possible, but rather excessive if you don’t otherwise need it.

UPDATE: as noted in the comments, this particular implementation could probably be improved a bit; for example, it’s possible to remove the need to store v_begin if you’re a bit careful about how you define the end iterator.