Namespaces
Variants

std:: vector

From cppreference.net
C++
Containers library
std::vector
Member types
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
Definido en el encabezado <vector>
template <

class T,
class Allocator = std:: allocator < T >

> class vector ;
(1)
namespace pmr {

template < class T >
using vector = std :: vector < T, std:: pmr :: polymorphic_allocator < T >> ;

}
(2) (desde C++17)
1) std::vector es un contenedor de secuencia que encapsula arrays de tamaño dinámico.
2) std::pmr::vector es una plantilla de alias que utiliza un polymorphic allocator .

Excepto por la std::vector<bool> especialización parcial, los elementos se almacenan de forma contigua, lo que significa que los elementos pueden ser accedidos no solo a través de iteradores, sino también usando desplazamientos a punteros regulares a elementos. Esto significa que un puntero a un elemento de un vector puede ser pasado a cualquier función que espere un puntero a un elemento de un array.

El almacenamiento del vector se maneja automáticamente, expandiéndose según sea necesario. Los vectores normalmente ocupan más espacio que los arreglos estáticos, porque se asigna más memoria para manejar el crecimiento futuro. De esta manera, un vector no necesita realojarse cada vez que se inserta un elemento, sino solo cuando se agota la memoria adicional. La cantidad total de memoria asignada se puede consultar usando la función capacity() . La memoria adicional se puede devolver al sistema mediante una llamada a shrink_to_fit() [1] .

Las reasignaciones suelen ser operaciones costosas en términos de rendimiento. La función reserve() puede utilizarse para eliminar reasignaciones si se conoce de antemano el número de elementos.

La complejidad (eficiencia) de las operaciones comunes en vectores es la siguiente:

  • Acceso aleatorio - constante 𝓞(1) .
  • Inserción o eliminación de elementos al final - constante amortizado 𝓞(1) .
  • Inserción o eliminación de elementos - lineal en la distancia al final del vector 𝓞(n) .

std::vector (para T distinto de bool ) cumple con los requisitos de Container , AllocatorAwareContainer (desde C++11) , SequenceContainer , ContiguousContainer (desde C++17) y ReversibleContainer .

Todas las funciones miembro de std::vector son constexpr : es posible crear y utilizar objetos std::vector en la evaluación de una expresión constante.

Sin embargo, los objetos std::vector generalmente no pueden ser constexpr , porque cualquier almacenamiento asignado dinámicamente debe liberarse en la misma evaluación de la expresión constante.

(desde C++20)
  1. ↑ En libstdc++, shrink_to_fit() no está disponible en modo C++98.

Contenidos

Parámetros de plantilla

T - El tipo de los elementos.
T debe cumplir con los requisitos de CopyAssignable y CopyConstructible . (hasta C++11)
Los requisitos que se imponen a los elementos dependen de las operaciones reales realizadas en el contenedor. Generalmente, se requiere que el tipo de elemento sea un tipo completo y cumpla con los requisitos de Erasable , pero muchas funciones miembro imponen requisitos más estrictos. (desde C++11)
(hasta C++17)

Los requisitos que se imponen a los elementos dependen de las operaciones reales realizadas en el contenedor. Generalmente, se requiere que el tipo de elemento cumpla con los requisitos de Erasable , pero muchas funciones miembro imponen requisitos más estrictos. Este contenedor (pero no sus miembros) puede instanciarse con un tipo de elemento incompleto si el asignador satisface los requisitos de completitud del asignador .

Macro de prueba de características Valor Estándar Característica
__cpp_lib_incomplete_container_elements 201505L (C++17) Soporte mínimo para tipos incompletos
(desde C++17)

Allocator - Un asignador que se utiliza para adquirir/liberar memoria y para construir/destruir los elementos en esa memoria. El tipo debe cumplir con los requisitos de Allocator . El comportamiento es indefinido (hasta C++20) El programa está mal formado (desde C++20) si Allocator::value_type no es el mismo que T .

Especializaciones

La biblioteca estándar proporciona una especialización de std::vector para el tipo bool , que puede estar optimizada para eficiencia de espacio.

bitset dinámico eficiente en espacio
(especialización de plantilla de clase)

Invalidación de iteradores

Operaciones Invalidados
Todas las operaciones de solo lectura Nunca.
swap , std::swap end()
clear , operator= , assign Siempre.
reserve , shrink_to_fit Si el vector cambió su capacidad, todos ellos. Si no, ninguno.
erase Elementos borrados y todos los elementos posteriores (incluyendo end() ).
push_back , emplace_back Si el vector cambió su capacidad, todos ellos. Si no, solo end() .
insert , emplace Si el vector cambió su capacidad, todos ellos.
Si no, solo aquellos en o después del punto de inserción (incluyendo end() ).
resize Si el vector cambió su capacidad, todos ellos. Si no, solo end() y cualquier elemento borrado.
pop_back El elemento borrado y end() .

Tipos de miembros

Tipo de miembro Definición
value_type T
allocator_type Allocator
size_type Tipo entero sin signo (normalmente std::size_t )
difference_type Tipo entero con signo (normalmente std::ptrdiff_t )
reference value_type &
const_reference const value_type &
pointer

Allocator::pointer

(hasta C++11)

std:: allocator_traits < Allocator > :: pointer

(desde C++11)
const_pointer

Allocator::const_pointer

(hasta C++11)

std:: allocator_traits < Allocator > :: const_pointer

(desde C++11)
iterator

LegacyRandomAccessIterator y LegacyContiguousIterator a value_type

(hasta C++20)

LegacyRandomAccessIterator , contiguous_iterator , y ConstexprIterator a value_type

(desde C++20)
const_iterator

LegacyRandomAccessIterator y LegacyContiguousIterator a const value_type

(hasta C++20)

LegacyRandomAccessIterator , contiguous_iterator , y ConstexprIterator a const value_type

(desde C++20)
reverse_iterator std:: reverse_iterator < iterator >
const_reverse_iterator std:: reverse_iterator < const_iterator >

Funciones miembro

construye el vector
(función miembro pública)
destruye el vector
(función miembro pública)
asigna valores al contenedor
(función miembro pública)
asigna valores al contenedor
(función miembro pública)
(C++23)
asigna un rango de valores al contenedor
(función miembro pública)
devuelve el asignador asociado
(función miembro pública)
Acceso a elementos
acceder al elemento especificado con verificación de límites
(función miembro pública)
acceder al elemento especificado
(función miembro pública)
acceder al primer elemento
(función miembro pública)
acceder al último elemento
(función miembro pública)
acceso directo al almacenamiento contiguo subyacente
(función miembro pública)
Iteradores
(C++11)
devuelve un iterador al inicio
(función miembro pública)
(C++11)
devuelve un iterador al final
(función miembro pública)
(C++11)
devuelve un iterador inverso al principio
(función miembro pública)
(C++11)
devuelve un iterador inverso al final
(función miembro pública)
Capacidad
verifica si el contenedor está vacío
(función miembro pública)
devuelve el número de elementos
(función miembro pública)
devuelve el número máximo posible de elementos
(función miembro pública)
reserva almacenamiento
(función miembro pública)
devuelve el número de elementos que pueden almacenarse en la memoria actualmente asignada
(función miembro pública)
( DR* )
reduce el uso de memoria liberando memoria no utilizada
(función miembro pública)
Modificadores
borra el contenido
(función miembro pública)
inserta elementos
(función miembro pública)
(C++23)
inserta un rango de elementos
(función miembro pública)
(C++11)
construye elementos in situ
(función miembro pública)
elimina elementos
(función miembro pública)
agrega un elemento al final
(función miembro pública)
(C++11)
construye un elemento in situ al final
(función miembro pública)
(C++23)
agrega un rango de elementos al final
(función miembro pública)
elimina el último elemento
(función miembro pública)
cambia el número de elementos almacenados
(función miembro pública)
intercambia los contenidos
(función miembro pública)

Funciones no miembro

(eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (C++20)
compara lexicográficamente los valores de dos vector s
(plantilla de función)
especializa el algoritmo std::swap
(plantilla de función)
(C++20)
elimina todos los elementos que cumplen criterios específicos
(plantilla de función)

Guías de deducción

(desde C++17)

Notas

Macro de prueba de características Valor Estándar Característica
__cpp_lib_containers_ranges 202202L (C++23) Construcción e inserción de rangos para contenedores
__cpp_lib_ranges_reserve_hint 202502L (C++26) ranges::approximately_sized_range , ranges::reserve_hint , y cambios en std::vector

Ejemplo

Ejecutar este código 
#include <iostream>
#include <vector>
int main()
{
    // Crear un vector que contiene enteros
    std::vector<int> v = {8, 4, 5, 9};
    // Añadir dos enteros más al vector
    v.push_back(6);
    v.push_back(9);
    // Sobrescribir elemento en posición 2
    v[2] = -1;
    // Imprimir el vector
    for (int n : v)
        std::cout << n << ' ';
    std::cout << '\n';
}

Salida: 

8 4 -1 9 6 9

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 69 C++98 no se requería la contigüidad del almacenamiento para elementos de vector requerida
LWG 230 C++98 T no se requería que fuera CopyConstructible
(un elemento de tipo T podría no poder construirse) 		T también se requiere que
sea CopyConstructible
LWG 464 C++98 el acceso al almacenamiento subyacente de un vector vacío resultaba en UB se proporciona la función data

Véase también

(C++26)
vector redimensionable, capacidad fija, array contiguo in situ
(plantilla de clase)
(C++11)
array contiguo in situ de tamaño fijo
(plantilla de clase)
cola de doble extremo
(plantilla de clase)