KVRefVec.h

#pragma once
 
#include <vector>
 
template<typename T>
class KVRefVec {
   std::vector<T*> objects;
public:
   KVRefVec(size_t N) : objects(N) {}
   const T& operator[](size_t i) const
   {
      return *objects[i];
   }
   void set(size_t i, T* t)
   {
      objects[i] = t;
   }
   size_t size() const
   {
      return objects.size();
   }
 
   struct iterator {
      typedef std::forward_iterator_tag iterator_category;
      typedef T value_type;
      typedef std::ptrdiff_t difference_type;
      typedef T* pointer;
      typedef T& reference;
 
      typename std::vector<T*>::iterator vec_it;
 
      iterator() {}
      iterator(const iterator& i) : vec_it{i.vec_it} {}
      iterator(KVRefVec<T>* refvec)
      {
         vec_it = refvec->objects.begin();
      }
      T& operator*() const
      {
         return *(*vec_it);
      }
      bool operator!=(const iterator& it) const
      {
         return vec_it != it.vec_it;
      }
      bool operator==(const iterator& it) const
      {
         return vec_it == it.vec_it;
      }
      const iterator& operator++()
      {
         ++vec_it;
         return *this;
      }
      iterator operator++(int)
      {
         iterator tmp(*this);
         operator++();
         return tmp;
      }
      iterator& operator=(const iterator& rhs)
      {
         if (this != &rhs) {
            vec_it = rhs.vec_it;
         }
         return *this;
      }
      static iterator make_end_iterator(KVRefVec<T>* refvec)
      {
         iterator end_it;
         end_it.vec_it = refvec->objects.end();
         return end_it;
      }
   };
 
   iterator begin()
   {
      return iterator(this);
   }
   iterator end()
   {
      return iterator::make_end_iterator(this);
   }
};