Clase `vector`

Artículo
08/25/2023

La clase vector de la Biblioteca Estándar de C++ es una plantilla de clase para contenedores de secuencia. Una plantilla de clase que almacena los elementos de un tipo determinado en una organización lineal y permite el acceso aleatorio rápido a cualquier elemento. Un vector es el contenedor más apropiado para una secuencia cuando el rendimiento de acceso aleatorio es importante.

Sintaxis

template <class Type, class Allocator = allocator<Type>>
class vector

Parámetros

Type
Tipo de datos de elementos que se almacenará en el vector.

Allocator
Tipo que representa el objeto asignador almacenado que encapsula los detalles sobre la asignación y la desasignación de memoria del vector. Este argumento es opcional y el valor predeterminado es allocator<Type>.

Comentarios

Los vectores permiten inserciones y eliminaciones de tiempo constante al final de la secuencia. Insertar o eliminar elementos en medio de un vector requiere tiempo lineal. El contenedor de la clase deque es más rápido en las inserciones y supresiones al principio y al final de una secuencia. El contenedor de la clase list es más rápido en las inserciones y supresiones en cualquier ubicación de una secuencia.

Se produce una reasignación del vector cuando una función miembro debe aumentar la secuencia contenida en el objeto de vectores más allá de su capacidad de almacenamiento actual. Otras inserciones y eliminaciones pueden modificar varias direcciones de almacenamiento dentro de la secuencia. En todos estos casos, los iteradores y referencias que apuntan a partes alteradas de la secuencia dejan de ser válidos. Si no se produce ninguna reasignación, solo los iteradores y referencias antes del punto de inserción o eliminación siguen siendo válidos.

La clase vector<bool> es una especialización total del vector de plantillas de clase para los elementos de tipo bool. Tiene un asignador para el tipo subyacente que se usa por la especialización.

La clase de referencia vectorvector<bool> es una clase anidada cuyos objetos pueden proporcionar referencias a los elementos (bits únicos) dentro de un objeto vector<bool>.

Miembros

Constructores

Nombre	Descripción
`vector`	Construye un vector de un tamaño determinado o con elementos de un valor determinado, o con un `allocator` específico, o como una copia de algún otro vector.

Typedefs

Nombre	Descripción
`[allocator_type]`(#allocator_type)	Tipo que representa la clase `allocator` para el objeto vector.
`const_iterator`	Tipo que proporciona un iterador de acceso aleatorio que puede leer un elemento `const` en un vector.
`const_pointer`	Tipo que proporciona un puntero a un elemento `const` en un vector.
`const_reference`	Tipo que proporciona una referencia a un elemento `const` almacenado en un vector. Se usa para leer y realizar operaciones `const`.
`const_reverse_iterator`	Tipo que proporciona un iterador de acceso aleatorio que puede leer cualquier elemento `const` en el vector.
`difference_type`	Tipo que proporciona la diferencia entre las direcciones de dos elementos en un vector.
`iterator`	Tipo que proporciona un iterador de acceso aleatorio que puede leer o modificar cualquier elemento de un vector.
`pointer`	Tipo que proporciona un puntero a un elemento en un vector.
`reference`	Tipo que proporciona una referencia a un elemento almacenado en un vector.
`reverse_iterator`	Tipo que proporciona un iterador de acceso aleatorio que puede leer o modificar cualquier elemento en un vector invertido.
`size_type`	Tipo que cuenta el número de elementos de un vector.
`value_type`	Tipo que representa el tipo de datos almacenado en un vector.

Funciones

Nombre	Descripción
`assign`	Borra un vector y copia los elementos especificados al vector vacío.
`at`	Devuelve una referencia al elemento en una ubicación especificada del vector.
`back`	Devuelve una referencia al último elemento del vector.
`begin`	Devuelve un iterador de acceso aleatorio al primer elemento del vector.
`capacity`	Devuelve el número de elementos que puede contener el vector sin asignar más espacio de almacenamiento.
`cbegin`	Devuelve un iterador const de acceso aleatorio al primer elemento del vector.
`cend`	Devuelve un iterador const de acceso aleatorio que apunta justo después del final del vector.
`crbegin`	Devuelve un iterador constante al primer elemento de un vector invertido.
`crend`	Devuelve un iterador constante al final de un vector invertido.
`clear`	Borra los elementos del vector.
`data`	Devuelve un puntero al primer elemento del vector.
`emplace`	Inserta en una posición especificada del vector un elemento construido en contexto.
`emplace_back`	Agrega al final del vector un elemento construido en contexto.
`empty`	Comprueba si el contenedor de vectores está vacío.
`end`	Devuelve un iterador de acceso aleatorio que apunta al final del vector.
`erase`	Quita un elemento o un intervalo de elementos en un vector a partir de posiciones especificadas.
`front`	Devuelve una referencia al primer elemento de un vector.
`get_allocator`	Devuelve un objeto a la clase `allocator` usada por un vector.
`insert`	Inserta uno o varios elementos en el vector en una posición especificada.
`max_size`	Devuelve la longitud máxima del vector.
`pop_back`	Elimina el elemento situado al final del vector.
`push_back`	Agrega un elemento al final del vector.
`rbegin`	Devuelve un iterador al primer elemento en un vector inverso.
`rend`	Devuelve un iterador al final de un vector invertido.
`reserve`	Reserva una longitud mínima de almacenamiento para un objeto vectorial.
`resize`	Especifica un nuevo tamaño de un vector.
`shrink_to_fit`	Descarta el exceso de capacidad.
`size`	Devuelve el número de elementos del vector.
`swap`	Intercambia los elementos de dos vectores.

Operadores

Nombre	Descripción
`operator[]`	Devuelve una referencia al elemento vector en una posición especificada.
`operator=`	Reemplaza los elementos del vector con una copia de otro vector.

`allocator_type`

Tipo que representa la clase de asignador para el objeto de vector.

typedef Allocator allocator_type;

Comentarios

allocator_type es un sinónimo del parámetro de plantilla Allocator.

Ejemplo

Vea en el ejemplo de get_allocator cómo se usa allocator_type.

`assign`

Borra un vector y copia los elementos especificados al vector vacío.

void assign(size_type count, const Type& value);
void assign(initializer_list<Type> init_list);

template <class InputIterator>
void assign(InputIterator first, InputIterator last);

Parámetros

first
Posición del primer elemento en el intervalo de elementos que se va a copiar.

last
Posición del primer elemento más allá del intervalo de elementos que se va a copiar.

count
Número de copias de un elemento que se va a insertar en el vector.

value
Valor del elemento que se va a insertar en el vector.

init_list
initializer_list que contiene los elementos que se van a insertar.

Comentarios

En primer lugar, assign borra los elementos que existen en un vector. Entonces, assign inserta en un vector un intervalo especificado de elementos del vector original o inserta copias de un nuevo elemento de un valor especificado en un vector.

Ejemplo

/ vector_assign.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> v1, v2, v3;

    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);
    v1.push_back(50);

    cout << "v1 = ";
    for (auto& v : v1){
        cout << v << " ";
    }
    cout << endl;

    v2.assign(v1.begin(), v1.end());
    cout << "v2 = ";
    for (auto& v : v2){
        cout << v << " ";
    }
    cout << endl;

    v3.assign(7, 4);
    cout << "v3 = ";
    for (auto& v : v3){
        cout << v << " ";
    }
    cout << endl;

    v3.assign({ 5, 6, 7 });
    for (auto& v : v3){
        cout << v << " ";
    }
    cout << endl;
}

`at`

Devuelve una referencia al elemento en una ubicación especificada del vector.

reference at(size_type position);

const_reference at(size_type position) const;

Parámetros

position
Subíndice o número de posición del elemento al que se va a hacer referencia en el vector.

Valor devuelto

Referencia al elemento indicado en el argumento. Si position es mayor que el tamaño del vector, at inicia una excepción.

Comentarios

Si el valor devuelto de at se asigna a const_reference, el objeto de vector no se puede modificar. Si el valor devuelto de at se asigna a reference, el objeto de vector se puede modificar.

Ejemplo

// vector_at.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const int &i = v1.at( 0 );
   int &j = v1.at( 1 );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`back`

Devuelve una referencia al último elemento del vector.

reference back();

const_reference back() const;

Valor devuelto

Último elemento del vector. Si el vector está vacío, el valor devuelto no está definido.

Comentarios

Si el valor devuelto de back se asigna a const_reference, el objeto de vector no se puede modificar. Si el valor devuelto de back se asigna a reference, el objeto de vector se puede modificar.

Al compilar con _ITERATOR_DEBUG_LEVEL definido como 1 o 2, se produce un error en tiempo de ejecución si intenta obtener acceso a un elemento de un vector vacío. Para obtener más información, consulte Checked Iterators.

Ejemplo

// vector_back.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main() {
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.back( );
   const int& ii = v1.front( );

   cout << "The last integer of v1 is " << i << endl;
   i--;
   cout << "The next-to-last integer of v1 is "<< ii << endl;
}

`begin`

Devuelve un iterador de acceso aleatorio al primer elemento del vector.

const_iterator begin() const;

iterator begin();

Valor devuelto

Un iterador de acceso aleatorio que se dirige al primer elemento del vector o a la ubicación que sigue a un vector vacío. Siempre compare el valor devuelto con vector::end para asegurarse de que es válido.

Comentarios

Si el valor devuelto de begin se asigna a un vector::const_iterator, vector no se puede modificar. Si el valor devuelto de begin se asigna a un vector::iterator, vector sí se puede modificar.

Ejemplo

// vector_begin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> c1;
    vector<int>::iterator c1_Iter;
    vector<int>::const_iterator c1_cIter;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_Iter = c1.begin();
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;

    cout << "The vector c1 now contains elements:";
    c1_Iter = c1.begin();
    *c1_Iter = 20;
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;

    // The following line would be an error because iterator is const
    // *c1_cIter = 200;
}

The vector c1 contains elements: 1 2
The vector c1 now contains elements: 20 2

`capacity`

Devuelve el número de elementos que puede contener el vector sin asignar más espacio de almacenamiento.

size_type capacity() const;

Valor devuelto

Longitud actual de almacenamiento asignado para el vector.

Comentarios

La función miembro resize es más eficaz si se asigna memoria suficiente para tenerla en cuenta. Use la función miembro reserve para especificar la cantidad de memoria asignada.

Ejemplo

// vector_capacity.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 1 );
   cout << "The length of storage allocated is "
        << v1.capacity( ) << "." << endl;

   v1.push_back( 2 );
   cout << "The length of storage allocated is now "
        << v1.capacity( ) << "." << endl;
}

The length of storage allocated is 1.
The length of storage allocated is now 2.

`cbegin`

Devuelve un iterador const que direcciona el primer elemento del intervalo.

const_iterator cbegin() const;

Valor devuelto

Iterador const de acceso aleatorio que apunta al primer elemento del intervalo o la ubicación situada más allá del final de un intervalo vacío (para un intervalo vacío, cbegin() == cend()).

Comentarios

Con el valor devuelto de cbegin, los elementos del intervalo no se pueden modificar.

Se puede usar esta función miembro en lugar de la función miembro begin() para garantizar que el valor devuelto es const_iterator. Normalmente, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente. En el ejemplo se considera que Container es un contenedor modificable (distinto de const) de cualquier naturaleza que admite begin() y cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

Devuelve un iteradorconst más allá del final que apunta al elemento que sigue al último elemento del vector.

const_iterator cend() const;

Valor devuelto

Un iterador const más allá del final del vector. Apunta al elemento que sigue al último elemento del vector. Ese elemento es un marcador de posición y no se debe desreferenciar. Úselo solo para hacer comparaciones. Si el vector está vacío, es entonces vector::cend() == vector::cbegin().

Comentarios

cend se usa para probar si un iterador ha sobrepasado el final de su intervalo.

Se puede usar esta función miembro en lugar de la función miembro end() para garantizar que el valor devuelto es const_iterator. Por lo general, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente. En el ejemplo se considera que Container es un contenedor modificable (distinto de const) de cualquier naturaleza que admite end() y cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

El valor devuelto por cend no se debe desreferenciar. Úselo solo para hacer comparaciones.

`clear`

Borra los elementos del vector.

void clear();

Ejemplo

// vector_clear.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "The size of v1 is " << v1.size( ) << endl;
   v1.clear( );
   cout << "The size of v1 after clearing is " << v1.size( ) << endl;
}

The size of v1 is 3
The size of v1 after clearing is 0

`const_iterator`

Tipo que proporciona un iterador de acceso aleatorio que puede leer un elemento const en un vector.

typedef implementation-defined const_iterator;

Comentarios

Un tipo const_iterator no se puede utilizar para modificar el valor de un elemento.

Ejemplo

Vea en el ejemplo de back cómo se usa const_iterator.

`const_pointer`

Tipo que proporciona un puntero a un elemento const en un vector.

typedef typename Allocator::const_pointer const_pointer;

Comentarios

Un tipo const_pointer no se puede utilizar para modificar el valor de un elemento.

Un iterador se usa normalmente para tener acceso a un elemento de vector.

`const_reference`

Tipo que proporciona una referencia a un elemento const almacenado en un vector. Se usa para leer y realizar operaciones const.

typedef typename Allocator::const_reference const_reference;

Comentarios

Un tipo const_reference no se puede utilizar para modificar el valor de un elemento.

Ejemplo

// vector_const_ref.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const vector <int> v2 = v1;
   const int &i = v2.front( );
   const int &j = v2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

   // The following line would cause an error as v2 is const
   // v2.push_back( 30 );
}

The first element is 10
The second element is 20

`const_reverse_iterator`

Tipo que proporciona un iterador de acceso aleatorio que puede leer cualquier elemento const en el vector.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Comentarios

Un tipo const_reverse_iterator no puede modificar el valor de un elemento y se usa para procesar una iteración en el vector en orden inverso.

Ejemplo

Consulte rbegin para obtener un ejemplo de cómo declarar y usar un iterador.

`crbegin`

Devuelve un iterador constante al primer elemento de un vector invertido.

const_reverse_iterator crbegin() const;

Valor devuelto

Un iterador inverso constante de acceso aleatorio que se dirige al primer elemento de un vector inverso o al que fue el último elemento del vector sin invertir.

Comentarios

Con el valor devuelto de crbegin, el objeto vector no se puede modificar.

Ejemplo

// vector_crbegin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
}

The first element of vector is 1.
The first element of the reversed vector is 2.

`crend`

Devuelve un iterador inverso const más allá del final que apunta al elemento que sigue al último elemento del vector invertido.

const_reverse_iterator crend() const;

Valor devuelto

Iterador inverso const más allá del extremo para el vector invertido. Apunta al elemento siguiente al último elemento del vector invertido, que es el mismo que el elemento anterior al primer elemento del vector no invertido. Ese elemento es un marcador de posición y no se debe desreferenciar. Úselo solo para hacer comparaciones.

Comentarios

crend se usa con un vector invertido igual que vector::cend se usa con un vector.

Con el valor devuelto de crend (adecuadamente reducido), el objeto vector no se puede modificar.

Se puede utilizar crend para comprobar si un iterador inverso llegó al final de su vector.

El valor devuelto por crend no se debe desreferenciar. Úselo solo para hacer comparaciones.

Ejemplo

// vector_crend.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`data`

Devuelve un puntero al primer elemento del vector.

const_pointer data() const;

pointer data();

Valor devuelto

Puntero al primer elemento del vector o a la ubicación que sigue a un vector vacío.

Ejemplo

// vector_data.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> c1;
    vector<int>::pointer c1_ptr;
    vector<int>::const_pointer c1_cPtr;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_cPtr = c1.data();
    for (size_t n = c1.size(); 0 < n; --n, c1_cPtr++)
    {
        cout << " " << *c1_cPtr;
    }
    cout << endl;

    cout << "The vector c1 now contains elements:";
    c1_ptr = c1.data();
    *c1_ptr = 20;
    for (size_t n = c1.size(); 0 < n; --n, c1_ptr++)
    {
        cout << " " << *c1_ptr;
    }
    cout << endl;
}

The vector c1 contains elements: 1 2
The vector c1 now contains elements: 20 2

`difference_type`

Tipo que proporciona la diferencia entre dos iteradores que hacen referencia a elementos del mismo vector.

typedef typename Allocator::difference_type difference_type;

Comentarios

Un difference_type también se puede describir como el número de elementos entre dos punteros, dado que un puntero a un elemento contiene su dirección.

Un iterador se usa normalmente para tener acceso a un elemento de vector.

Ejemplo

// vector_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <vector>
#include <algorithm>

int main( )
{
   using namespace std;

   vector <int> c1;
   vector <int>::iterator c1_Iter, c2_Iter;

   c1.push_back( 30 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 10 );
   c1.push_back( 30 );
   c1.push_back( 20 );

   c1_Iter = c1.begin( );
   c2_Iter = c1.end( );

   vector <int>::difference_type   df_typ1, df_typ2, df_typ3;

   df_typ1 = count( c1_Iter, c2_Iter, 10 );
   df_typ2 = count( c1_Iter, c2_Iter, 20 );
   df_typ3 = count( c1_Iter, c2_Iter, 30 );
   cout << "The number '10' is in c1 collection " << df_typ1 << " times.\n";
   cout << "The number '20' is in c1 collection " << df_typ2 << " times.\n";
   cout << "The number '30' is in c1 collection " << df_typ3 << " times.\n";
}

The number '10' is in c1 collection 1 times.
The number '20' is in c1 collection 2 times.
The number '30' is in c1 collection 3 times.

`emplace`

Inserta en una posición especificada del vector un elemento construido en contexto.

template <class... Types>
iterator emplace(
    const_iterator position,
    Types&&... args);

Parámetros

position
Posición del vector en la que se inserta el primer elemento.

args
Argumentos del constructor. La función deduce qué sobrecarga de constructor invocar según los argumentos que se proporcionan.

Valor devuelto

La función devuelve un iterador que apunta a la posición en la que se insertó el nuevo elemento en el vector.

Comentarios

Las operaciones de inserción pueden ser costosas, consulte la clase vector para obtener una explicación del rendimiento de un vector.

Ejemplo

// vector_emplace.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.emplace( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
vv1[0] = 10 20 30

`emplace_back`

Agrega al final del vector un elemento construido en contexto.

template <class... Types>
void emplace_back(Types&&... args);

Parámetros

args
Argumentos del constructor. La función deduce qué sobrecarga de constructor invocar según los argumentos que se proporcionan.

Ejemplo

#include <vector>
struct obj
{
   obj(int, double) {}
};

int main()
{
   std::vector<obj> v;
   v.emplace_back(1, 3.14); // obj in created in place in the vector
}

`empty`

Comprueba si el vector está vacío.

bool empty() const;

Valor devuelto

true si el vector está vacío, false si el vector no está vacío.

Ejemplo

// vector_empty.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );

   if ( v1.empty( ) )
      cout << "The vector is empty." << endl;
   else
      cout << "The vector is not empty." << endl;
}

The vector is not empty.

`end`

Devuelve un iterador más allá del final que apunta al elemento que sigue al último elemento del vector.

iterator end();

const_iterator end() const;

Valor devuelto

Un iterador más allá del final del vector. Apunta al elemento que sigue al último elemento del vector. Ese elemento es un marcador de posición y no se debe desreferenciar. Úselo solo para hacer comparaciones. Si el vector está vacío, es entonces vector::end() == vector::begin().

Comentarios

Si el valor devuelto de end se asigna a una variable de tipo const_iterator, el objeto de vector no se puede modificar. Si el valor devuelto de end se asigna a una variable de tipo iterator, el objeto de vector se puede modificar.

Ejemplo

// vector_end.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>
int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_Iter = v1.begin( ) ; v1_Iter != v1.end( ) ; v1_Iter++ )
      cout << *v1_Iter << endl;
}

1
2

`erase`

Quita un elemento o un intervalo de elementos en un vector a partir de posiciones especificadas.

iterator erase(
    const_iterator position);

iterator erase(
    const_iterator first,
    const_iterator last);

Parámetros

position
Posición del elemento que se quita del vector.

first
Posición del primer elemento que se quita del vector.

last
Posición inmediatamente siguiente al último elemento que se quita del vector.

Valor devuelto

Iterador que designa el primer elemento restante después de los elementos quitados o, si no hay ningún elemento después, un puntero al final del vector.

Ejemplo

// vector_erase.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );
   v1.push_back( 40 );
   v1.push_back( 50 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.erase( v1.begin( ) );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.erase( v1.begin( ) + 1, v1.begin( ) + 3 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
}

v1 = 10 20 30 40 50
v1 = 20 30 40 50
v1 = 20 50

`front`

Devuelve una referencia al primer elemento de un vector.

reference front();

const_reference front() const;

Valor devuelto

Referencia al primer elemento en el objeto de vector. Si el vector está vacío, el valor devuelto no está definido.

Comentarios

Si el valor devuelto de front se asigna a const_reference, el objeto de vector no se puede modificar. Si el valor devuelto de front se asigna a reference, el objeto de vector se puede modificar.

Ejemplo

// vector_front.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.front( );
   const int& ii = v1.front( );

   cout << "The first integer of v1 is "<< i << endl;
   // by incrementing i, we move the front reference to the second element
   i++;
   cout << "Now, the first integer of v1 is "<< i << endl;
}

`get_allocator`

Devuelve una copia del objeto de asignador usado para construir el vector.

Allocator get_allocator() const;

Valor devuelto

Asignador utilizado por el vector.

Comentarios

Los asignadores de la clase vector especifican cómo la clase administra el almacenamiento. Los asignadores predeterminados proporcionados con las clases contenedoras de la biblioteca estándar de C++ son suficientes para la mayoría de las necesidades de programación. La escritura y el uso de sus propias clases de asignador son características avanzadas de C++.

Ejemplo

// vector_get_allocator.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects that use the default allocator.
   vector<int> v1;
   vector<int, allocator<int> > v2 = vector<int, allocator<int> >(allocator<int>( )) ;

   // v3 will use the same allocator class as v1
   vector <int> v3( v1.get_allocator( ) );

   vector<int>::allocator_type xvec = v3.get_allocator( );
   // You can now call functions on the allocator class used by vec
}

`insert`

Inserta uno o varios elementos, o un intervalo de elementos en el vector en una posición especificada.

iterator insert(
    const_iterator position,
    const Type& value);

iterator insert(
    const_iterator position,
    Type&& value);

void insert(
    const_iterator position,
    size_type count,
    const Type& value);

template <class InputIterator>
void insert(
    const_iterator position,
    InputIterator first,
    InputIterator last);

Parámetros

position
Posición del vector donde se inserta el primer elemento.

value
Valor del elemento que se va a insertar en el vector.

count
Número de elementos que se van a insertar en el vector.

first
Posición del primer elemento en el intervalo de elementos que se va a copiar.

last
Posición del primer elemento más allá del intervalo de elementos que se va a copiar.

Valor devuelto

Las dos primeras funciones insert devuelven un iterador que apunta a la posición del vector en la que se insertó el nuevo elemento.

Comentarios

Como condición previa, first y last no deben ser iteradores en el vector o el comportamiento es indefinido. Las operaciones de inserción pueden ser costosas, consulte la clase vector para obtener una explicación del rendimiento de un vector.

Ejemplo

// vector_insert.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.insert( v1.begin( ) + 1, 40 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
   v1.insert( v1.begin( ) + 2, 4, 50 );

   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   const auto v2 = v1;
   v1.insert( v1.begin( )+1, v2.begin( )+2, v2.begin( )+4 );
   cout << "v1 =";
   for (Iter = v1.begin( ); Iter != v1.end( ); Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.insert( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
v1 = 10 40 20 30
v1 = 10 40 50 50 50 50 20 30
v1 = 10 50 50 40 50 50 50 50 20 30
vv1[0] = 10 50 50 40 50 50 50 50 20 30

`iterator`

Tipo que proporciona un iterador de acceso aleatorio que puede leer o modificar cualquier elemento de un vector.

typedef implementation-defined iterator;

Comentarios

Se puede usar un tipo iterator para modificar el valor de un elemento.

Ejemplo

Vea el ejemplo de begin.

`max_size`

Devuelve la longitud máxima del vector.

size_type max_size() const;

Valor devuelto

Máxima longitud posible del vector.

Ejemplo

// vector_max_size.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::size_type i;

   i = v1.max_size( );
   cout << "The maximum possible length of the vector is " << i << "." << endl;
}

`operator[]`

Devuelve una referencia al elemento vector en una posición especificada.

reference operator[](size_type position);

const_reference operator[](size_type position) const;

Parámetros

position
Posición del elemento vector.

Valor devuelto

Si la posición especificada es mayor o igual que el tamaño del contenedor, el resultado es sin definir.

Comentarios

Si el valor devuelto de operator[] se asigna a const_reference, el objeto de vector no se puede modificar. Si el valor devuelto de operator[] se asigna a una referencia, el objeto vector se puede modificar.

Al compilar con _ITERATOR_DEBUG_LEVEL definido como 1 o 2, se produce un error de tiempo de ejecución si intenta tener acceso a un elemento fuera de los límites del vector. Para obtener más información, consulte Checked Iterators.

Ejemplo

// vector_op_ref.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   int& i = v1[1];
   cout << "The second integer of v1 is " << i << endl;
}

`operator=`

Reemplaza los elementos del vector con una copia de otro vector.

vector& operator=(const vector& right);

vector& operator=(vector&& right);

Parámetros

right
La clase vector que se copia en vector.

Comentarios

Después de borrar todos los elementos existentes en un vector, operator= copia o mueve el contenido de right al vector.

Ejemplo

// vector_operator_as.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int> v1, v2, v3;
   vector<int>::iterator iter;

   v1.push_back(10);
   v1.push_back(20);
   v1.push_back(30);
   v1.push_back(40);
   v1.push_back(50);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << *iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;
}

`pointer`

Tipo que proporciona un puntero a un elemento en un vector.

typedef typename Allocator::pointer pointer;

Comentarios

Se puede usar un tipo pointer para modificar el valor de un elemento.

Ejemplo

// vector_pointer.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
    using namespace std;
    vector<int> v;
    v.push_back( 11 );
    v.push_back( 22 );

    vector<int>::pointer ptr = &v[0];
    cout << *ptr << endl;
    ptr++;
    cout << *ptr << endl;
    *ptr = 44;
    cout << *ptr << endl;
}

11
22
44

`pop_back`

Elimina el elemento situado al final del vector.

void pop_back();

Comentarios

Para obtener un ejemplo de código, vea vector::push_back().

`push_back`

Agrega un elemento al final del vector.

void push_back(const T& value);

void push_back(T&& value);

Parámetros

value
El valor que se asignará al elemento que se agrega al final del vector.

Ejemplo

// compile with: /EHsc /W4
#include <vector>
#include <iostream>

using namespace std;

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << "  " << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

int main()
{
    vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(10 + i);
    }

    cout << "vector data: " << endl;
    print_collection(v);

    // pop_back() until it's empty, printing the last element as we go
    while (v.begin() != v.end()) {
        cout << "v.back(): "; print_elem(v.back()); cout << endl;
        v.pop_back();
    }
}

`rbegin`

Devuelve un iterador al primer elemento en un vector inverso.

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

Valor devuelto

Un iterador inverso de acceso aleatorio que se dirige al primer elemento de un vector inverso o al que fue el último elemento del vector sin invertir.

Comentarios

Si el valor devuelto de rbegin se asigna a const_reverse_iterator, el objeto de vector no se puede modificar. Si el valor devuelto de rbegin se asigna a reverse_iterator, el objeto de vector se puede modificar.

Ejemplo

// vector_rbegin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.rbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
}

The first element of vector is 1.
The first element of the reversed vector is 2.

`reference`

Tipo que proporciona una referencia a un elemento almacenado en un vector.

typedef typename Allocator::reference reference;

Ejemplo

Consulte at para ver un ejemplo de cómo usar reference en la clase de vector.

`rend`

Devuelve un iterador inverso más allá del final que apunta al elemento que sigue al último elemento del vector invertido.

const_reverse_iterator rend() const;
reverse_iterator rend();

Valor devuelto

Iterador inverso más allá del extremo para el vector invertido. Apunta al elemento siguiente al último elemento del vector invertido, que es el mismo que el elemento anterior al primer elemento del vector no invertido. Ese elemento es un marcador de posición y no se debe desreferenciar. Úselo solo para hacer comparaciones.

Comentarios

rend se usa con un vector invertido del mismo modo que end se usa con un vector.

Si el valor devuelto de rend se asigna a un const_reverse_iterator, el objeto de vector no se puede modificar. Si el valor devuelto de rend se asigna a un reverse_iterator, el objeto de vector se puede modificar.

Se puede usar rend para comprobar si un iterador invertido ha llegado al final de su vector.

El valor devuelto por rend no se debe desreferenciar. Úselo solo para hacer comparaciones.

Ejemplo

// vector_rend.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`reserve`

Reserva una longitud mínima de almacenamiento para un objeto de vector y asigna espacio si es necesario.

void reserve(size_type count);

Parámetros

count
Longitud mínima de almacenamiento a asignar para el vector.

Ejemplo

// vector_reserve.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
}

Current capacity of v1 = 1
Current capacity of v1 = 20

`resize`

Especifica un nuevo tamaño de un vector.

void resize(size_type new_size);
void resize(size_type new_size, Type value);

Parámetros

new_size
Nuevo tamaño del vector.

value
El valor de inicialización de elementos nuevos añadido al vector si el nuevo tamaño es mayor que el tamaño original. Si el valor se omite, los nuevos objetos utilizan su constructor predeterminado.

Comentarios

Si el tamaño del contenedor es menor que el tamaño solicitado new_size, resize agrega elementos al vector hasta que esta alcanza el tamaño solicitado. Cuando el tamaño del contenedor es mayor que el tamaño solicitado, resize elimina los elementos más cercanos al final del contenedor hasta que este alcanza el tamaño new_size. No se realiza ninguna acción si el tamaño actual del contenedor es igual que el tamaño solicitado.

size refleja el tamaño actual del vector.

Ejemplo

// vectorsizing.cpp
// compile with: /EHsc /W4
// Illustrates vector::reserve, vector::max_size,
// vector::resize, vector::resize, and vector::capacity.
//
// Functions:
//
//    vector::max_size - Returns maximum number of elements vector could
//                       hold.
//
//    vector::capacity - Returns number of elements for which memory has
//                       been allocated.
//
//    vector::size - Returns number of elements in the vector.
//
//    vector::resize - Reallocates memory for vector, preserves its
//                     contents if new size is larger than existing size.
//
//    vector::reserve - Allocates elements for vector to ensure a minimum
//                      size, preserving its contents if the new size is
//                      larger than existing size.
//
//    vector::push_back - Appends (inserts) an element to the end of a
//                        vector, allocating memory for it if necessary.
//
//////////////////////////////////////////////////////////////////////

// The debugger cannot handle symbols more than 255 characters long.
// The C++ Standard Library often creates symbols longer than that.
// The warning can be disabled:
//#pragma warning(disable:4786)

#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename C> void print(const string& s, const C& c) {
    cout << s;

    for (const auto& e : c) {
        cout << e << " ";
    }
    cout << endl;
}

void printvstats(const vector<int>& v) {
    cout << "   the vector's size is: " << v.size() << endl;
    cout << "   the vector's capacity is: " << v.capacity() << endl;
    cout << "   the vector's maximum size is: " << v.max_size() << endl;
}

int main()
{
    // declare a vector that begins with 0 elements.
    vector<int> v;

    // Show statistics about vector.
    cout << endl << "After declaring an empty vector:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    // Add one element to the end of the vector.
    v.push_back(-1);
    cout << endl << "After adding an element:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    for (int i = 1; i < 10; ++i) {
        v.push_back(i);
    }
    cout << endl << "After adding 10 elements:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(6);
    cout << endl << "After resizing to 6 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(9, 999);
    cout << endl << "After resizing to 9 elements with an initialization value of 999:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(12);
    cout << endl << "After resizing to 12 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    // Ensure there's room for at least 1000 elements.
    v.reserve(1000);
    cout << endl << "After vector::reserve(1000):" << endl;
    printvstats(v);

    // Ensure there's room for at least 2000 elements.
    v.resize(2000);
    cout << endl << "After vector::resize(2000):" << endl;
    printvstats(v);
}

`reverse_iterator`

Tipo que proporciona un iterador de acceso aleatorio que puede leer o modificar cualquier elemento en un vector invertido.

typedef std::reverse_iterator<iterator> reverse_iterator;

Comentarios

El tipo reverse_iterator se utiliza para procesar una iteración en el vector en orden inverso.

Ejemplo

Vea el ejemplo de rbegin.

`shrink_to_fit`

Descarta el exceso de capacidad.

void shrink_to_fit();

Ejemplo

// vector_shrink_to_fit.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.shrink_to_fit();
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
}

Current capacity of v1 = 1
Current capacity of v1 = 20
Current capacity of v1 = 1

`size`

Devuelve el número de elementos del vector.

size_type size() const;

Valor devuelto

Longitud actual del vector.

Ejemplo

// vector_size.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::size_type i;

   v1.push_back( 1 );
   i = v1.size( );
   cout << "Vector length is " << i << "." << endl;

   v1.push_back( 2 );
   i = v1.size( );
   cout << "Vector length is now " << i << "." << endl;
}

Vector length is 1.
Vector length is now 2.

`size_type`

Tipo que cuenta el número de elementos de un vector.

typedef typename Allocator::size_type size_type;

Ejemplo

Vea el ejemplo de capacity.

`swap`

Intercambia los elementos de dos vectores.

void swap(
    vector<Type, Allocator>& right);

friend void swap(
    vector<Type, Allocator>& left,
    vector<Type, Allocator>& right);

Parámetros

right
Vector que proporciona los elementos que se van a intercambiar. O bien, un vector cuyos elementos se van a intercambiar con los elementos del vector left.

left
Un vector cuyos elementos se van a intercambiar con los elementos del vector right.

Ejemplo

// vector_swap.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1, v2;

   v1.push_back( 1 );
   v1.push_back( 2 );
   v1.push_back( 3 );

   v2.push_back( 10 );
   v2.push_back( 20 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
   cout << endl;

   v1.swap( v2 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
}

The number of elements in v1 = 3
The number of elements in v2 = 2

The number of elements in v1 = 2
The number of elements in v2 = 3

`value_type`

Tipo que representa el tipo de datos almacenado en un vector.

typedef typename Allocator::value_type value_type;

Comentarios

value_type es un sinónimo del parámetro de plantilla Type.

Ejemplo

// vector_value_type.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

`vector`

Construye un vector. Las sobrecargas construyen un vector de un tamaño específico o con elementos de un valor específico. O bien, como una copia de todo o la parte de algún otro vector. Algunas sobrecargas también permiten especificar el asignador que se va a usar.

vector();
explicit vector(const Allocator& allocator);
explicit vector(size_type count);
vector(size_type count, const Type& value);
vector(size_type count, const Type& value, const Allocator& allocator);

vector(const vector& source);
vector(vector&& source);
vector(initializer_list<Type> init_list, const Allocator& allocator);

template <class InputIterator>
vector(InputIterator first, InputIterator last);
template <class InputIterator>
vector(InputIterator first, InputIterator last, const Allocator& allocator);

Parámetros

allocator
La clase de asignador que se usa con este objeto. get_allocator devuelve la clase de asignador del objeto.

count
Número de elementos del vector construido.

value
Valor de los elementos del vector construido.

source
Vector del que el vector construido va a ser una copia.

first
Posición del primer elemento en el intervalo de elementos que se va a copiar.

last
Posición del primer elemento más allá del intervalo de elementos que se va a copiar.

init_list
initializer_list que contiene los elementos que se van a copiar.

Comentarios

Todos los constructores almacenan un objeto de asignador (allocator) e inicializan el vector.

Los dos primeros constructores especifican un vector inicial vacío. El segundo constructor especifica explícitamente el tipo de asignador (allocator) que se va a usar.

El tercer constructor especifica una repetición de un número especificado (count) de elementos del valor predeterminado para la clase Type.

Los constructores cuarto y quinto especifican una repetición de elementos (count) de valor value.

El sexto constructor especifica una copia del vector source.

El séptimo constructor mueve el vector source.

El octavo constructor utiliza una initializer_list para especificar los elementos.

Los constructores noveno y décimo copian el intervalo [first, last) de un vector.

Ejemplo

// vector_ctor.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector <int>::iterator v1_Iter, v2_Iter, v3_Iter, v4_Iter, v5_Iter, v6_Iter;

    // Create an empty vector v0
    vector <int> v0;

    // Create a vector v1 with 3 elements of default value 0
    vector <int> v1(3);

    // Create a vector v2 with 5 elements of value 2
    vector <int> v2(5, 2);

    // Create a vector v3 with 3 elements of value 1 and with the allocator
    // of vector v2
    vector <int> v3(3, 1, v2.get_allocator());

    // Create a copy, vector v4, of vector v2
    vector <int> v4(v2);

    // Create a new temporary vector for demonstrating copying ranges
    vector <int> v5(5);
    for (auto i : v5) {
        v5[i] = i;
    }

    // Create a vector v6 by copying the range v5[ first,  last)
    vector <int> v6(v5.begin() + 1, v5.begin() + 3);

    cout << "v1 =";
    for (auto& v : v1){
        cout << " " << v;
    }
    cout << endl;

    cout << "v2 =";
    for (auto& v : v2){
        cout << " " << v;
    }
    cout << endl;

    cout << "v3 =";
    for (auto& v : v3){
        cout << " " << v;
    }
    cout << endl;
    cout << "v4 =";
    for (auto& v : v4){
        cout << " " << v;
    }
    cout << endl;

    cout << "v5 =";
    for (auto& v : v5){
        cout << " " << v;
    }
    cout << endl;

    cout << "v6 =";
    for (auto& v : v6){
        cout << " " << v;
    }
    cout << endl;

    // Move vector v2 to vector v7
    vector <int> v7(move(v2));
    vector <int>::iterator v7_Iter;

    cout << "v7 =";
    for (auto& v : v7){
        cout << " " << v;
    }
    cout << endl;

    cout << "v8 =";
    vector<int> v8{ { 1, 2, 3, 4 } };
    for (auto& v : v8){
        cout << " " << v ;
    }
    cout << endl;
}

v1 = 0 0 0
v2 = 2 2 2 2 2
v3 = 1 1 1
v4 = 2 2 2 2 2
v5 = 0 0 0 0 0
v6 = 0 0
v7 = 2 2 2 2 2
v8 = 1 2 3 4

Vea también

Seguridad para subprocesos en la biblioteca estándar de C++
Referencia de biblioteca estándar de C++

Compartir a través de

Clase vector

Sintaxis

Parámetros

Comentarios

Miembros

Constructores

Typedefs

Funciones

Operadores

allocator_type

Comentarios

Ejemplo

assign

Parámetros

Comentarios

Ejemplo

at

Parámetros

Valor devuelto

Comentarios

Ejemplo

back

Valor devuelto

Comentarios

Ejemplo

begin

Valor devuelto

Comentarios

Ejemplo

capacity

Valor devuelto

Comentarios

Ejemplo

cbegin

Valor devuelto

Comentarios

cend

Valor devuelto

Comentarios

clear

Ejemplo

const_iterator

Comentarios

Ejemplo

const_pointer

Comentarios

const_reference

Comentarios

Ejemplo

const_reverse_iterator

Comentarios

Ejemplo

crbegin

Valor devuelto

Comentarios

Ejemplo

crend

Valor devuelto

Comentarios

Ejemplo

data

Valor devuelto

Ejemplo

difference_type

Comentarios

Ejemplo

emplace

Parámetros

Valor devuelto

Comentarios

Ejemplo

emplace_back

Parámetros

Ejemplo

empty

Valor devuelto

Ejemplo

end

Valor devuelto

Clase `vector`

`allocator_type`

`assign`

`at`

`back`

`begin`

`capacity`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`data`

`difference_type`

`emplace`

`emplace_back`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`max_size`

`operator[]`

`operator=`

`pointer`

`pop_back`

`push_back`

`rbegin`

`reference`

`rend`

`reserve`

`resize`

`reverse_iterator`

`shrink_to_fit`

`size`

`size_type`