is there possible to write user iteration class for vectors (or other similar data types) in c++?

Question

Normal standard method of iterating is this:

for(std::vector<T>::iterator it = v.begin(); it != v.end(); ++it) {
    /* std::cout << *it; ... */
}

It involves too much typing and repetating vector variable name.

Is there a way to simplify it like in

for (auto item : vector_var) { /*...*/ }

loop but also having access to index and other functions.

I think of this:

for (auto item : myIterationClass(vector_var)) {
   item->index;
   item->value;
   item->delete();
   item->replaceWith(42);
}

It doesn't have to be fast but lean on the code I need to write.

Answer 1

Assuming you'd accept that your loop is slightly changed, it is certainly doable:

for (auto item : myIterationClass(vector_var)) {
    item.index();
    item.value();
    item.erase();
    item.replaceWith(42);
}

The idea is to have myIterationClass() be a thin wrapper which return iterators with a fairly custom value. The use of erase() is a bit problematic, though, as you are not supposed to change the container while it is being iterated, i.e., if these are really needed it is necessary to record the elements to be erased and process them later.

Although I don't this this is a good idea, below is a quick demo implementing index() and value(). Implementing replaceWith() would be trivial while implementing anything mutating the length of the sequence could be interesting. Given that the iterator controls the sequence it could probably be done by directly mutating the underlying sequence and adjusting the kept index appropriately. Note that there are also different approach how the iterators are represented. I randomly choose to use a combination of a pointer to the container and an index. If the sequence doesn't add or remove elements, it could also be done using two iterator and computing the index as the difference between the two.

#include <algorithm>
#include <iostream>
#include <vector>

template <typename T>
class wrapped_iterator
{
    T*                    container;
    typename T::size_type position;
public:
    wrapped_iterator(T* container, typename T::size_type position)
        : container(container)
        , position(position) {
    }
    wrapped_iterator<T>& operator*() { return *this; }
    wrapped_iterator<T>& operator++() { ++position; return *this; }
    wrapped_iterator<T>  operator++(int) {
        wrapped_iterator<T> rc(*this);
        ++*this;
        return rc;
    }
    bool operator== (wrapped_iterator<T> const& other) const {
        return position == other.position;
    }
    bool operator!= (wrapped_iterator<T> const& other) const {
        return !(*this == other);
    }
    typename T::size_type        index() const { return position; }
    typename T::const_reference& value() const { return (*container)[position]; }
};

template <typename T>
class wrapped
{
    T* container;
public:
    typedef wrapped_iterator<T> iterator;
    wrapped(T& container): container(&container) {}
    iterator begin() const { return iterator(container, 0u); }
    iterator end() const { return iterator(container, container->size()); }
};

template <typename T>
wrapped<T> wrapper(T& container) {
    return wrapped<T>(container);
}

int main()
{
    std::vector<int> v{ 7, 6, 5, 4, 3, 2, 1 };
    for (auto item : wrapper(v)) {
        std::cout << "index=" << item.index() << ' '
                  << "value=" << item.value() << '\n';
    }
}

Answer 2

It's not so bad with auto alone:

for (auto it = std::begin(v), e = std::end(v); it != e; ++it)
{
    auto index = std::distance(it, e);

    // ...
}

It's maybe not pretty, but it's short enough to type and readable.

---

Update: Here's a mildly hacky macro "implementation", in the spirit of the range based for loop. (Beware when using with arrays.)

#include <iterator>

#define INDEX_FOR(init, idx, cont, body)  \
do                                        \
{                                         \
  auto && __x = (cont);                   \
  for (auto __it = std::begin(__x),       \
       __end = std::end(__x);             \
       __it != __end; ++__it)             \
  {                                       \
    init = *__it;                         \
    auto idx = std::distance(__it, __end);\
    body                                  \
  }                                       \
} while (false)

Example usage:

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v { 4, -9, 11, 102, 81 };

    INDEX_FOR(auto & x, i, v, {
        std::cout << "Element " << i << " = " << x << "\n";
    });
}

Answer 3

Bjarne Stroustrup in C++11 FAQ says that for (auto item : vector_var) is valid expression. Please, see here: http://www.stroustrup.com/C++11FAQ.html#for

Answer 4

I think this is shorter and easier to use for vectors since auto iteration constructs look somewhat creepy...

int i = 0;
while(i <= myVector.size()) {
    myVector[i];
    i++;
}

But I prefer maps/lists anyway because used correctly they have alot more performance.

Answer 5

One way using boost is this:

for(auto item:boost::combine(vec, boost::irange(0, vec.size())))
{
    auto value = boost::get<0>(item);
    auto index = boost::get<1>(item);
    ...
}

It doesn't give you a way to erase the element, but that should probably be done using the remove-erase idiom.