Re: iterate over vector in leaps

Baruch Burstein <bmburstein@gmail.com> writes:


IMHO, you will certainly need to implement your own custom iterator
here. This will need careful handling, and will need to be implemented
with significant differences compared to how you might implement an
`ordinary' custom iterator. For instance, your iterator will need to
maintain specific information about the vector that it is iterating over
since it will need to handle checks against running over the ends.
(This is not the case with, say, std::vector<T>::iterator since its use
requires that the user code do this type of checking.)

The following is a quick-and-dirty example of how you might begin to
implement such an iterator. I do not present this as necessarily the
right way to do this, and it won't work as-is with std::sort since it
doesn't provide all the overloaded operators required of a random access
iterator. However, it might give you enough ideas to enable you to
decide if this is indeed the right way to go. Note: I say this because
I am wondering if you are actually tied to using a vector here, and
whether you have considered whether std::valarray might not better suit
your needs. I realise that valarray has something of a `bad press' and
there had even been calls (I believe) to deprecate it. However, it does
permit viewing the container in `slices', which seems to fit,
conceptually at least, with what you are trying to achieve.

Example code below.

Regards

Paul Bibbings

==# Example code #==
#include <cstddef>
#include <iostream>
#include <vector>
#include <iterator>

template<typename T>
struct nth_iterator
  : public std::iterator<
             typename std::vector<T>::iterator::iterator_category,
             T,
             typename std::vector<T>::iterator::difference_type,
             typename std::vector<T>::iterator::pointer,
             typename std::vector<T>::iterator::reference
           >
{
  typedef typename std::vector<T>::iterator v_iterator;

  typedef typename v_iterator::iterator_category iterator_category;
  typedef T value_type;
  typedef typename v_iterator::difference_type difference_type;
  typedef typename v_iterator::pointer pointer;
  typedef typename v_iterator::reference reference;

  nth_iterator(typename std::vector<T>& vec,
               v_iterator iter,
               size_t step)
    : vec_(vec)
    , iter_(iter)
    , step_(step)
  { }

  nth_iterator& operator++() {
    size_t i = 0;
    while (i < step_ && iter_ != vec_.end())
    {
      ++iter_; ++i;
    }
    return *this;
  }

  bool operator==(const v_iterator& rhs) {
    return iter_ == rhs;
  }

  bool operator!=(const v_iterator& rhs) {
    return iter_ != rhs;
  }

  T& operator*() { return *iter_; }
private:
  typename std::vector<T>& vec_;
  v_iterator iter_;
  size_t step_;
};

void print_i_vec(const std::vector<int>& ci_vec)
{
  for (std::vector<int>::const_iterator civ_iter = ci_vec.begin();
       civ_iter != ci_vec.end();
       ++civ_iter)
  {
    std::cout << *civ_iter << ' ';
  }
  std::cout << '\n';
}

int main()
{
  std::vector<int> i_vec;

  for (int i = 1; i <= 10; ++i) i_vec.push_back(i);

  print_i_vec(i_vec);

  for (nth_iterator<int> nth_iter(i_vec, i_vec.begin(), 3);
       nth_iter != i_vec.end();
       ++nth_iter)
  {
    *nth_iter = 0;
  }

  print_i_vec(i_vec);

  return 0;
}

/* Output:
   14:25:02 Paul Bibbings@JIJOU
   /cygdrive/d/CPPProjects/CLCPP $./nth_iterator_vec
   1 2 3 4 5 6 7 8 9 10
   0 2 3 0 5 6 0 8 9 0
*/

==# End: Example code #==