---

safe_vector.h

Go to the documentation of this file.

#include <vector>
namespace std{
  template <class T, class Allo = allocator <T> >
    class safe_vector : vector<T,Allo> {
    static int DIE_NOW() {
      return *(int*)0;
    }

      static int temprand() {
    static int seed;
    return seed += 319282;
      
      }
      int id;
      public:
      safe_vector (unsigned int __n, const T &val):vector<T,Allo>(__n,val) {
    id=temprand();
      }
      safe_vector () {
    id=temprand();
      }
      safe_vector (unsigned int __n): vector<T,Allo> (__n) {
    id=temprand();
      }
      safe_vector (const vector <T,Allo> &v): vector<T,Allo>(v){
    id=temprand();
      }
      const vector<T,Allo> & operator= (const vector <T,Allo> & a) {
    *((vector <T,Allo>*)this)=a;
    id = temprand();
    return a;
      }
      T& operator[](unsigned int n) { return (*((vector <T,Allo> *)this)).at(n); }
      const T& operator[](unsigned int n) const {return (*((vector <T,Allo> *)this)).at(n);}
      T& at(unsigned int n) { return (*((vector <T,Allo> *)this)).at(n); }
      const T& at(unsigned int n) const {return (*((vector <T,Allo> *)this)).at(n);}
      void push_back (const T& t) {
    vector<T,Allo>::push_back(t);
    id++;
      }
      void push_back () {
    vector<T,Allo>::push_back();
    id++;
      }
      vector<T,Allo> &operator = (const vector <T,Allo>& k) {
    *((vector <T,Allo> *)this) = k;
    id=temprand();
    return k;
      }
      void reserve (unsigned int n) {
    vector<T,Allo>::reserve (n);
    id++;
      }
      class iterator: public vector<T,Allo>::iterator {
    safe_vector <T,Allo> *v;
    int id;

      public:
    void check_relevance() const {
      if (id!=v->id) {
        fprintf (stderr,__PRETTY_FUNCTION__);
        DIE_NOW();
      }   
    }
    iterator (const vector<T,Allo>::iterator &i,safe_vector <T,Allo> *id):vector<T,Allo>::iterator(i) {
      this->v =id;
      this->id = id->id;
    }/*
    iterator (const const_iterator &i): vector<T,Allo>::iterator(i) {
      v = i->v;
      id = i->id;
      }*/
    bool operator == (const vector<T,Allo>::iterator &i) {
      check_relevance();
      return (*((vector<T,Allo>::iterator *)this))==i;
    }
    bool operator == (const vector<T,Allo>::const_iterator &i) {
      check_relevance();
      return (*((vector<T,Allo>::iterator *)this))==i;
    }
    bool operator != (const vector<T,Allo>::iterator &i) {
      check_relevance();
      return (*((vector<T,Allo>::iterator *)this))!=i;
    }
    bool operator != (const vector<T,Allo>::const_iterator &i) {
      check_relevance();
      return (*((vector<T,Allo>::iterator *)this))!=i;
    }
    T & operator * () {
      check_relevance();
      return (**((vector <T,Allo>::iterator*)this));
    }
    iterator operator ++ (int) {
      check_relevance();
      return iterator((*((vector<T,Allo>::iterator *)this))++,v);
    }
    
    iterator operator +=(int i) {
      (*((vector<T,Allo>::iterator *)this))+=i;
      check_relevance();
      return *this;
    }
    iterator operator -=(int i) {
      (*((vector<T,Allo>::iterator *)this))-=i;
      check_relevance();
      return *this;
    }
    iterator operator ++ () {
      return (*this)+=1;
    }
    iterator operator -- () {
      return (*this)-=1;
    }
    
      };

      class const_iterator: public vector<T,Allo>::const_iterator {
      public:
    const safe_vector <T,Allo> *v;
    int id;
    void check_relevance() const {
      if (id!=v->id) {
        fprintf (stderr,__PRETTY_FUNCTION__);
        DIE_NOW();
      }   
    }
    const T & operator * () {
      check_relevance();
      return (**((vector <T,Allo>::const_iterator*)this));
    }
    bool operator == (const vector<T,Allo>::iterator &i) {
      check_relevance();
      return (*((vector<T,Allo>::const_iterator *)this))==i;
    }
    bool operator == (const vector<T,Allo>::const_iterator &i) {
      check_relevance();
      return (*((vector<T,Allo>::const_iterator *)this))==i;
    }
    bool operator != (const vector<T,Allo>::iterator &i) {
      check_relevance();
      return (*((vector<T,Allo>::const_iterator *)this))!=i;
    }
    bool operator != (const vector<T,Allo>::const_iterator &i) {
      check_relevance();
      return (*((vector<T,Allo>::const_iterator *)this))!=i;
    }
    const_iterator (const vector<T,Allo>::const_iterator &i,const safe_vector <T,Allo> *id):vector<T,Allo>::const_iterator(i) {
      this->v =id;
      this->id = id->id;
    }
    const_iterator (const iterator &i): vector<T,Allo>::const_iterator(i) {
      v = i->v;
      id = i->id;
    }

    const_iterator operator ++ (int) {
      check_relevance();
      return (*((vector<T,Allo>::const_iterator *)this))++;
    }
    iterator operator +=(int i) {
      (*((vector<T,Allo>::const_iterator *)this))+=i;
      check_relevance();
      return *this;
    }
    iterator operator -=(int i) {
      (*((vector<T,Allo>::const_iterator *)this))-=i;
      check_relevance();
      return *this;
    }
    iterator operator ++ () {
      return (*this)+=1;
    }
    iterator operator -- () {
      return (*this)-=1;
    }
      };
      iterator begin() {
    return iterator (((vector<T,Allo>*)this)->begin(),this);
      }
      iterator end() {
    return iterator (((vector<T,Allo>*)this)->end(),this);
      }
      const_iterator end() const{
    return const_iterator (((vector<T,Allo>*)this)->end(),this);
      }
      const_iterator begin() const{
    return const_iterator (((const vector<T,Allo> *)this)->begin(),this);
      }
      iterator erase (iterator a, iterator b) {
    a.check_relevance();
    b.check_relevance();
    id++;
    return iterator (((vector <T,Allo> *)this)->erase(a,b),this);
      }
      void swap (safe_vector <T,Allo> &a) {
    temp = id;
    id = a.id;
    a.id = temp;
    ((vector <T,Allo> *)this)->swap (a);
      }
      void resize (size_type ns, const T & x) {
    ((vector <T,Allo> *)this)->resize(ns,x);
    id++;
      }
      void resize (size_type ns) {
    ((vector <T,Allo> *)this)->resize(ns);
    id++;
      }
    T& back () {
      if (size()>0) return ((vector <T,Allo> *)this)->back();      
    }
    const T& back () const {
      if (size()>0) return ((vector <T,Allo> *)this)->back();      
    }
    T& front () {
      if (size()>0) return ((vector <T,Allo> *)this)->front();      
    }
    const T& front () const {
      if (size()>0) return ((vector <T,Allo> *)this)->front();      
    }
    
      void clear() {
    ((vector <T,Allo> *)this)->clear();
    id++;
      }
      iterator erase (iterator a) {
    a.check_relevance();
    id++;
    return iterator (((vector <T,Allo> *)this)->erase(a),this);
    
      }
      iterator insert (iterator positn, const T& t) {
    positn.check_relevance();
    vector<T,Allo>::iterator i=vector<T,Allo>::insert (positn,t);
    id++;
    return iterator(i,this);
      }
      iterator insert (iterator positn, unsigned int n, const T& t) {
    positn.check_relevance();
    vector<T,Allo>::iterator i=vector<T,Allo>::insert (positn,n,t);
    id++;
    return iterator(i,this);
      }
      iterator insert (iterator positn) {
    positn.check_relevance();
    vector<T,Allo>::iterator i=vector<T,Allo>::insert (positn);
    id++;
    return iterator(i,this);
      }
      iterator insert (iterator positn, unsigned int n) {
    positn.check_relevance();
    vector<T,Allo>::iterator i=vector<T,Allo>::insert (positn,n);
    id++;
    return iterator(i,this);
      }
  };
  template <class _Tp, class Allo > inline void swap(safe_vector<_Tp,Allo>& x, safe_vector<_Tp,Allo>&y)
{
  x.swap(y);
}
}

---