---

vector.h

#ifndef _vector_T_h
#define _vector_T_h

#include <cassert>

template <class T>
class Vector {
  private:
    T * datos; 
    int nelementos; 
  public:
    // ---------------  Constructores ----------------
    Vector<T>(int n=0);
    Vector<T>(const Vector<T>& original);
    // ------------------ Destructor ------------------
    ~Vector<T>();
    // --------------- Otras funciones ---------------
    int size() const;
    T& operator[] (int i);
    const T& operator[] (int i) const;
    void resize(int n);
    Vector<T>& operator= (const Vector<T>& original);
    // ---------------  Iteradores -----------------
    class const_iterador; // Para poder decir que es amiga de iterador

    class iterador {
        private:
          T* puntero;
        public:
          iterador(): puntero(0)
              {}
          iterador(const iterador& v): puntero(v.puntero)
              {}
          ~iterador()
              {}
          iterador& operator= (const iterador& orig)
              { puntero=orig.puntero; return *this;}
          T& operator*() const
              { assert(puntero!=0);return *puntero; }
          iterador& operator++()
              {assert(puntero!=0);puntero++;return *this;}
          iterador& operator--()
              {assert(puntero!=0);puntero--;return *this;}
          bool operator!=(const iterador& v) const
              {return puntero!=v.puntero;}
          bool operator==(const iterador& v) const
              {return puntero==v.puntero;}
          friend class Vector<T>;
          friend class const_iterador;
    };

   class const_iterador {
        private:
          const T* puntero;
          const_iterador(const T* p): puntero(p) {}
        public:
          const_iterador(): puntero(0) {}
          const_iterador(const const_iterador& v): puntero(v.puntero)
                {}
          ~const_iterador()
                {}
          const_iterador& operator= (const const_iterador& orig)
                { puntero=orig.puntero; return *this;}
          const_iterador(iterador v): puntero(v.puntero)
                {}
          const T& operator*() const
                {assert(puntero!=0);return *puntero; }
          const_iterador& operator++()
                {assert(puntero!=0);puntero++;return*this;}
          const_iterador& operator--()
                {assert(puntero!=0);puntero--;return *this;}
          bool operator!=(const const_iterador& v) const
                {return puntero!=v.puntero; }
          bool operator==(const const_iterador& v) const
                {return puntero==v.puntero; }
          friend class Vector<T>;
     };

    // -------------------- miembros para la iteración ----------------------
    iterador begin() { iterador i; i.puntero= datos; return i;}
    iterador end() { iterador i; i.puntero= datos+nelementos; return i;}
    const_iterador begin() const {return const_iterador(datos);}
    const_iterador end() const {return const_iterador(datos+nelementos);}
};

#include <vector.cpp>

#endif /* _vector_T_h */

---