随后在多个std容器上迭代

Question

I have the following class (which obviously does not yet work as intended):

class A
{
private:
    std::vector<int> firstVector, secondVector;
public:
    std::vector<int>::iterator begin(){
        return firstVector.begin();
    }
    std::vector<int>::iterator end(){
        return secondVector.end();
    }
};

How can I define an iterator which will go over the two member containers subsequently, eg after firstVector.end()-1 secondVector.begin() is returned and going all the way to secondVector.end() ?

Answer 1

Basically you need to define some custom iterator that internally checks for the end of the first range, then goes on to the next one.

However, this sort of stuff occurs a lot. Eventually you'd ask why an iterator for two vectors, why an iterator for two vectors , why a sequence of the same container type, and so on. Nir Tzachar & I have written a C++ port of Python itertools that does this sort of common stuff. In this case, you'd just use

chain(firstVector, secondVector)

It can be downloaded from this bitbucket repo .

Answer 2

Nothing to stop you from rolling your own. Can even make it random access!

struct chain_iterator 
    : std::iterator<std::random_access_iterator_tag, int>
{
    using it = std::vector<int>::iterator;

    std::pair<it, it> v1, v2;
    bool first;
    it cur;
};

We keep the initial iterator pairs so that we can do random access correctly.

Incrementing is what you'd expect:

chain_iterator& operator++() {
    ++cur;
    if (first && cur == v1.second) {
        first = false;
        cur = v2.first;
    }
    return *this;
}

Dereference is trivial:

int& operator*() { return *cur; }

Advance has to do some extra checking:

chain_iterator& operator+=(size_t n) {
    if (!first) {
        // trivial case
        cur += n;
    }
    else {
        size_t d = v1.second - cur;
        if (d < n) {
            cur += n;
        }
        else {
            first = false;
            cur = v2.first + (d - n);
        }
    }
    return *this;
}

I'll leave the rest of the operations as an exercise.

Answer 3

You could write your own function to do the incrementing:

std::vector<int>::iterator& inc(std::vector<int>::iterator& it) {
    ++it;
    if (it == firstVector.end())
        it = secondVector.begin();
    return it;
}

This is also a good indication to others that the increment doesn't happen normally.