inicio GeNeura cursos

vector<T>

vector<T> es un contenedor de las STL que, internamente, es un array de elementos de tipo T. Sobre él podemos realizar las mismas operaciones que sobre un array normal de C, pero, además tiene la ventaja de crecer de forma transparente.


Eficiencia

C array, T[] vector<T> deque<T> list<T>
insertar/borrar al principio no lineal constante constante
insertar/borrar al final no constante constante constante
insertar/borrar en medio no lineal lineal constante
acceder al primer elemento constante constante constante constante
acceder al último elemento constante constante constante constante
acceder a un elemento intermedio constante constante constante lineal
sobrecarga ninguna baja media alta

Especificación

template<class T, class Allocator = allocator>
class vector
{
  public:

  // typedefs:

    typedef T value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type* iterator;
    typedef const value_type* const_iterator;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef reverse_iterator<const_iterator> const_reverse_iterator;
    typedef reverse_iterator<iterator> reverse_iterator;

  // allocation/deallocation:

    vector();
    vector(size type n, const T& value = T());
    vector(const vector<T, Allocator>& x);
    template <class InputIterator> vector(InputIterator first,
                                          InputIterator last);
    ~vector();
    vector<T, Allocator>& operator=(const vector<T, Allocator>& x);
    void reserve(size_type n);
    void swap(vector<T, Allocator>& x);

  // accessors:

    iterator begin();
    const_iterator begin() const;
    iterator end();
    const_iterator end() const;
    reverse_iterator rbegin();
    const_reverse_iterator rbegin();
    reverse_iterator rend();
    const_reverse_iterator rend();
    size_type size() const;
    size_type max_size() const;
    size_type capacity() const;
    bool empty() const;
    reference operator[](size_type n);
    const_reference operator[](size_type n) const;
    reference front();
    const_reference front() const;
    reference back();
    const_reference back() const;

  // insert/erase:

    void push_back(const T& x);
    iterator insert(iterator position, const T& x = T());
    void insert(iterator position, size_type n, const T& x);
    template <class InputIterator> void insert(iterator position,
                                               InputIterator first,
                                               InputIterator last);
    void pop_back();
    void erase(iterator position);
    void erase(iterator first, iterator last);
};

template <class T, class Allocator>
bool operator==(const vector<T, Allocator>& x,
                const vector<T, Allocator>& y);

template <class T, class Allocator>
bool operator<const vector<T, Allocator>& x,
              const vector<T, Allocator>& y);
    

Requisitos


Ejercicios

  1. Crear un programa que use algunas de las propiedades más importantes de vector<T>
  2. Crea un objeto utilizando la sintaxis de localización (sobrecargar el operador new)
  3. Utiliza insert() de forma que sea necesario adquirir memoria
  4. Crea y utiliza una clase que cumpla todos los requisitos necesarios para ser utiizada dentro de un vector<T>