Contenedor de secuencia (C++)

En C++ , los contenedores de secuencia o colecciones de secuencia se refieren a un grupo de plantillas de clases de contenedores en la biblioteca estándar que implementan el almacenamiento de elementos de datos. Al ser plantillas , se pueden usar para almacenar elementos arbitrarios, como enteros o clases personalizadas. Una propiedad común de todos los contenedores secuenciales es que se puede acceder a los elementos de forma secuencial. Al igual que todos los demás componentes de la biblioteca estándar, residen en el espacio de nombres .std

Los siguientes contenedores están definidos en la revisión actual del estándar C++:

std::array<T, N>Implementa una matriz no redimensionable en tiempo de compilación .
std::bitset<N>implementa un conjunto de bits en tiempo de compilación .
std::vector<T>Implementa un array con acceso aleatorio rápido y la capacidad de redimensionarse automáticamente al añadir elementos.
std::inplace_vector<T>Implementa una matriz redimensionable con almacenamiento contiguo in situ.
std::deque<T>Implementa una cola de doble extremo con acceso aleatorio relativamente rápido.
std::list<T>Implementa una lista doblemente enlazada .
std::forward_list<T>Implementa una lista enlazada simple .
std::hive<T>implementa un grupo de objetos .

Cada uno de estos contenedores implementa diferentes algoritmos para el almacenamiento de datos, lo que significa que tienen diferentes garantías de velocidad para diferentes operaciones. ^{[ 1 ]}^{[ 2 ]}

También existen versiones de estas colecciones en el espacio de nombres std::pmr(para recursos de memoria polimórficos). Estas versiones especifican el parámetro de plantilla opcional Allocatorcomo std::pmr::polymorphic_allocator.

C++ define además adaptadores de contenedores que envuelven un contenedor de secuencia:

std::stack<T>Implementa una pila con dequecomo contenedor subyacente predeterminado.
std::queue<T>Implementa una cola con dequecomo contenedor subyacente predeterminado.
std::priority_queue<T>Implementa una cola de prioridad (por defecto, montón máximo ) con vectorcomo contenedor subyacente predeterminado.
std::flat_set<T>Implementa un "conjunto plano" (almacena un conjunto ordenado de claves únicas) con vectorcomo contenedor subyacente predeterminado.
std::flat_map<K, V>Implementa un "mapa plano" (almacena un conjunto ordenado de pares clave-valor únicos) con vectorcontenedores subyacentes predeterminados.
std::flat_multiset<T>Implementa un "multiconjunto plano" (almacena un conjunto ordenado de claves) con vectorcomo contenedor subyacente predeterminado.
std::flat_multimap<K, V>Implementa un "mapa múltiple plano" (almacena un conjunto ordenado de pares clave-valor) con vectorcontenedores subyacentes predeterminados.

Las colecciones "planas" ( std::flat_set, std::flat_map, std::flat_multiset, y std::flat_multimap) utilizan std::vectorcomo contenedor subyacente, a diferencia de sus equivalentes "no planos" ( std::set, std::map, std::multiset, y std::multimap), que almacenan datos como árboles rojo-negro (de ahí que sean "planas").

Los tipos de contenedores de vista representan vistas sobre matrices de elementos que no son propietarias:

std::span<T>Implementa una vista sin propiedad sobre una secuencia contigua de objetos.
std::mdspan<T>Implementa una vista sin propiedad sobre una matriz multidimensional.

Dado que cada contenedor necesita poder copiar sus elementos para funcionar correctamente, el tipo de los elementos debe cumplir CopyConstructiblecon Assignableciertos requisitos. ^{[ 3 ]} Para un contenedor dado, todos los elementos deben pertenecer al mismo tipo. Por ejemplo, no se pueden almacenar datos de tipo char e int dentro de la misma instancia de contenedor.

Historia

Originalmente, solo se definieron vector, listy deque. Hasta la estandarización del lenguaje C++ en 1998, formaban parte de la Biblioteca de Plantillas Estándar (STL), publicada por SGI . Alexander Stepanov , el diseñador principal de la STL, lamenta la elección del nombre vector , afirmando que proviene de los lenguajes de programación más antiguos Scheme y Lisp , pero que es inconsistente con el significado matemático del término. ^{[ 4 ]}

El arraycontenedor apareció inicialmente en varios libros con distintos nombres. Posteriormente se incorporó a una biblioteca Boost y se propuso su inclusión en la biblioteca estándar de C++. La motivación para su inclusión arrayradicaba en que solucionaba dos problemas de los arrays de estilo C: la falta de una interfaz similar a la STL y la imposibilidad de copiarlo como cualquier otro objeto. Sin embargo, a diferencia de los arrays de estilo C, solo puede declararse en tiempo de compilación, no en tiempo de ejecución. Apareció por primera vez en C++ TR1 y posteriormente se incorporó a C++11 .

El forward_listcontenedor se añadió a C++11 como una alternativa que ahorra espacio listcuando no se necesita la iteración inversa.

En C++20std::formatter , se introdujo la clase para especificar cómo se debe formatear una clase cuando se pasa a std::formato std::print. Esto agregó formato para varios tipos de colecciones. ^{[ 5 ]}

En C++26 , se agregaron dos nuevos contenedores de secuencia: inplace_vectory hive.

Propiedades

arrayy vectortodos dequeadmiten acceso aleatorio rápido a los elementos. listadmite iteración bidireccional, mientras que forward_listsolo admite iteración unidireccional.

arrayno admite la inserción o eliminación de elementos. vectoradmite la inserción o eliminación rápida de elementos al final. Cualquier inserción o eliminación de un elemento que no esté al final del vector necesita que se copien los elementos entre la posición de inserción y el final del vector. Por lo tanto, los iteradores a los elementos afectados se invalidan. De hecho, cualquier inserción puede potencialmente invalidar todos los iteradores. Además, si el almacenamiento asignado en vectores demasiado pequeño para insertar elementos, se asigna una nueva matriz, todos los elementos se copian o mueven a la nueva matriz y se libera la matriz anterior. deque, listy forward_listtodos admiten la inserción o eliminación rápida de elementos en cualquier lugar del contenedor. listy forward_listconserva la validez de los iteradores en dicha operación, mientras que dequelos invalida todos.

Las colecciones vector, deque, listy forward_listtambién tienen un parámetro de plantilla Allocatorque se especifica por defecto como std::allocator<T>(donde Tes el tipo almacenado).

contenedores

Formación

std::array<T, N>Implementa un array no redimensionable . El tamaño N, un entero sin signo, debe determinarse en tiempo de compilación mediante un parámetro de plantilla (y, por lo tanto, no puede declararse en tiempo de ejecución, como los arrays de C). Por diseño, el contenedor no admite asignadores porque es básicamente un envoltorio de array al estilo de C. C++ no admite arrays de longitud variable .

Se declara en el encabezado <array>.

Es esencialmente equivalente a los arrays de lenguajes básicos como Java y .NET o RustT[] . Los arrays tradicionales de C ( ) no almacenan información como la longitud. , a diferencia de , siempre debe especificar su tamaño en la declaración y no puede ser inferido por el compilador (a menos que se utilice la deducción de argumentos de plantilla de clase (CTAD) ). Esto es similar a otra colección, , que actúa como un array de bits cuyo tamaño debe conocerse en tiempo de compilación.[T; N]T[]arrayT[]std::bitset

importar std ;usando std :: array ;array < int , 3 > a = { 1 , 2 , 3 }; // OK array < int > a = { 1 , 2 , 3 }; // no OK: la longitud no se especifica en la declaración array a { 1 , 2 , 3 }; // OK: deduce el tipo como array<int, 3> usando CTAD// Comparar con los arrays de estilo C: int a [ 3 ] = { 1 , 2 , 3 }; // OK: longitud especificada como 3 int a [] = { 1 , 2 , 3 }; // OK: longitud inferida por el compilador

std::spanes un pariente cercano de array, para vistas de matriz no propietarias. std::mdspanes una versión multidimensional de span, sin embargo, estos son contenedores de vista.

Juego de bits

std::bitset<N>Implementa un conjunto de bits no redimensionable . El tamaño N, un entero sin signo, debe determinarse en tiempo de compilación como un parámetro de plantilla, al igual que std::array<T, N>. Es mucho más compacto que std::vector<bool>, almacenando solo $N$ bits y una pequeña cantidad de relleno.

Además, admite operaciones bit a bit , así como el acceso y la modificación de bits específicos. Permite la conversión a unsigned longy a cadenas, y la comprobación/consulta del número de bits activos. Sin embargo, a diferencia de otros contenedores, no admite iteradores.

Se declara en el encabezado <bitset>.

Es esencialmente equivalente a java.util.BitSeten Java, System.Collections.BitArrayen .NET, o al anterior std::collections::BitSeten Rust.

Para un conjunto de bits dinámico, las bibliotecas de terceros como Boost proporcionan clases como boost::dynamic_bitset<Block, Allocator>. ^{[ 6 ]} Mientras vector<bool>que almacena bits empaquetados y puede tener un tamaño dinámico, vector<bool>::operator[]devuelve un tipo proxy vector<bool>::reference(en lugar de bool&), y carece de las operaciones bit a bit proporcionadas por bitset.

Vectores

Vector

Los elementos de un vector std::vector<T>se almacenan de forma contigua. ^{[ 7 ]} Al igual que todas las implementaciones de matrices dinámicas , los vectores tienen un bajo consumo de memoria y una buena localidad de referencia y utilización de la caché de datos . A diferencia de otros contenedores STL, como las deques y las listas , los vectores permiten al usuario especificar una capacidad inicial para el contenedor.

Se declara en el encabezado <vector>.

Es esencialmente equivalente a java.util.ArrayListen Java, System.Collections.Generic.Listen .NET o std::vec::Vecen Rust.

Los vectores permiten el acceso aleatorio ; es decir, se puede acceder a un elemento de un vector de la misma manera que a los elementos de los arreglos (mediante sus índices). Por otro lado, las listas enlazadas y los conjuntos no admiten el acceso aleatorio ni la aritmética de punteros.

La estructura de datos vectorial permite asignar de forma rápida y sencilla la memoria necesaria para el almacenamiento de datos específicos, y lo hace en tiempo constante amortizado. Esto resulta especialmente útil para almacenar datos en listas cuya longitud puede desconocerse antes de su creación, pero donde la eliminación de elementos (salvo, quizás, al final) es poco frecuente. Borrar elementos de un vector, o incluso vaciarlo por completo, no libera necesariamente la memoria asociada a dicho elemento.

Capacidad y reasignación

Una implementación típica de vector consiste, internamente, en un puntero a un arreglo asignado dinámicamente ^{[ 1 ]} y posiblemente miembros de datos que almacenan la capacidad y el tamaño del vector. El tamaño del vector se refiere al número real de elementos, mientras que la capacidad se refiere al tamaño del arreglo interno.

Cuando se insertan nuevos elementos, si el nuevo tamaño del vector supera su capacidad, se produce una reasignación . ^{[ 1 ]}^{[ 8 ]} Esto suele provocar que el vector asigne una nueva región de almacenamiento, mueva los elementos previamente almacenados a la nueva región y libere la región anterior.

Debido a que las direcciones de los elementos cambian durante este proceso, cualquier referencia o iterador a elementos en el vector se invalida. ^{[ 9 ]} El uso de una referencia invalidada provoca un comportamiento indefinido .

La reserve()operación puede utilizarse para evitar reasignaciones innecesarias. Tras una llamada a reserve(n), se garantiza que la capacidad del vector sea al menos n. ^{[ 10 ]}

El vector mantiene un cierto orden de sus elementos, de modo que cuando se inserta un nuevo elemento al principio o en medio del vector, los elementos subsiguientes se desplazan hacia atrás en términos de su operador de asignación o constructor de copia . En consecuencia, las referencias e iteradores a elementos posteriores al punto de inserción quedan invalidados. ^{[ 11 ]}

Los vectores de C++ no admiten la reasignación de memoria in situ por diseño; es decir, al reasignar un vector, la memoria que contenía siempre se copia a un nuevo bloque de memoria mediante el constructor de copia de sus elementos y luego se libera. Esto resulta ineficiente en los casos en que el vector contiene datos simples y hay espacio contiguo adicional disponible para su asignación más allá del bloque de memoria ocupado.

Especialización para bool

La biblioteca estándar define una especialización de la vectorplantilla para bool. La descripción de esta especialización indica que la implementación debe empaquetar los elementos de manera que cada uno boolutilice solo un bit de memoria. ^{[ 12 ]}vector<bool> puede verse como similar a un conjunto de bits dinámico, pero mientras vector<bool>que almacena bits empaquetados y puede tener un tamaño dinámico, <vector<bool>::operator[]devuelve un tipo proxy vector<bool>::reference(en lugar de bool&), y carece de las operaciones bit a bit proporcionadas por bitset. Esto se considera ampliamente un error. ^{[ 13 ]}^{[ 14 ]}vector<bool> no cumple con los requisitos para un contenedor de la biblioteca estándar de C++ . Por ejemplo, un debe ser un lvalueContainer<T>::reference verdadero de tipo . Este no es el caso de , que es una clase proxy convertible a . ^[¹⁵^] De manera similar, no produce un cuando se desreferencia . Existe un consenso general entre el Comité de Estándares de C++ y el Grupo de Trabajo de la Biblioteca de que debería ser descontinuado y posteriormente eliminado de la biblioteca estándar, mientras que la funcionalidad se reintroducirá con un nombre diferente. ^[¹⁶^]Tvector<bool>::referenceboolvector<bool>::iteratorbool&vector<bool>

Si se busca almacenar una lista boolcuyo tamaño se conoce en tiempo de compilación, una std::bitset<N>( matriz de bits ) es la colección más razonable para usar, debido a una menor sobrecarga y a que es en general más eficiente. Sin embargo, bitseta diferencia de vectorno es dinámica.

Vector in situ

std::inplace_vector<T, N>es una matriz redimensionable dinámicamente con almacenamiento contiguo in situ, esencialmente con una capacidad máxima fija y cuyo tamaño real puede crecer y encogerse hasta N. No asigna en el montón.

Se declara en el encabezado <inplace_vector>.

Existen bibliotecas externas como arrayvec para Rust, que implementan ArrayVec<T, N>, así como ArrayString<N>. ^{[ 17 ]} Antes de su inclusión en C++, existían alternativas como boost::container::static_vector^{[ 18 ]} y llvm::StaticVector<T, N>^{[ 19 ]} .

Deque

std::deque<T>es una plantilla de clase de contenedor que implementa una cola de doble extremo . Proporciona una complejidad computacional similar a vectorpara la mayoría de las operaciones, con la notable excepción de que proporciona inserción y eliminación amortizadas en tiempo constante desde ambos extremos de la secuencia de elementos. A diferencia de vector, dequeutiliza bloques de memoria discontinuos y no proporciona ningún medio para controlar la capacidad del contenedor y el momento de la reasignación de memoria. Al igual que vector, dequeofrece soporte para iteradores de acceso aleatorio , y la inserción y eliminación de elementos invalida todos los iteradores de la cola de doble extremo.

Se declara en el encabezado <deque>.

Es esencialmente equivalente a java.util.ArrayDequeen Java o std::collections::VecDequeen Rust.

Listas enlazadas

Lista doblemente enlazada

La std::list<T>estructura de datos implementa una lista doblemente enlazada . Los datos se almacenan de forma no contigua en la memoria, lo que permite que la estructura de datos de lista evite la reasignación de memoria que puede ser necesaria con los vectores cuando se insertan nuevos elementos en la lista.

Se declara en el encabezado <list>.

Es esencialmente equivalente a java.util.LinkedListen Java, System.Collections.Generic.LinkedListen .NET o std::collections::LinkedListen Rust.

La estructura de datos de lista asigna y libera memoria según sea necesario; por lo tanto, no asigna memoria que no esté utilizando en ese momento. La memoria se libera cuando se elimina un elemento de la lista.

Las listas son eficientes al insertar nuevos elementos en la lista; esto es una $O(1)$ Operación . No se requiere desplazamiento como con los vectores.

Las listas no tienen capacidad de acceso aleatorio como los vectores ( ⁠ $O(1)$ ⁠ operación). Acceder a un nodo en una lista es una ⁠ $O(n)$ Operación que requiere recorrer una lista para encontrar el nodo al que se necesita acceder.

Con tipos de datos pequeños (como ints), la sobrecarga de memoria es mucho más significativa que la de un vector. Cada nodo (de tipo Tocupa . Los punteros suelen ser de una palabra (normalmente cuatro bytes en sistemas operativos de 32 bits), lo que significa que una lista de enteros de cuatro bytes ocupa aproximadamente tres veces más memoria que un vector de enteros.sizeof(T) + 2 * sizeof(T*)

Lista enlazada simple

La std::forward_list<T>estructura de datos implementa una lista enlazada simple .

Se declara en el encabezado <forward_list>.

Pocos lenguajes tienen un tipo de lista enlazada simple distinto como forward_list, sin embargo existen bibliotecas externas como fwdlist para Rust. ^{[ 20 ]}

Colmena

std::hive<T>Es una colección que reutiliza la memoria de los elementos borrados. Se puede considerar similar a un grupo de objetos . Utiliza otra clase std::hive_limitspara almacenar información de diseño sobre los límites de capacidad de los bloques. A diferencia de otras clases vectorque almacenan datos en un único bloque de memoria contiguo, esta los almacena en una cadena de varios bloques. Permite almacenar y borrar elementos de forma eficiente y garantiza la estabilidad del iterador.

La búsqueda, la eliminación y la iteración son $O(1)$ mientras que la inserción se amortiza $O(1)$ .

Se basa en la clase plf::colonyde la plfbiblioteca. ^{[ 21 ]}

Se declara en el encabezado <hive>.

Es esencialmente equivalente a Microsoft.Extensions.ObjectPool.ObjectPoolen .NET. Existen bibliotecas externas como colony para Rust, que implementan Colony<T>. ^{[ 22 ]}

adaptadores de contenedores

Un adaptador de contenedor en C++ sirve para encapsular tipos de colecciones de secuencias en una interfaz alternativa. Cada tipo de colección tiene un parámetro de plantilla Containerque se especifica por defecto, pero que puede configurarse según sea necesario. ^{[ 2 ]}

Pila

La std::stack<T>estructura de datos implementa una pila (estructura de último en entrar, primero en salir). Su tipo de colección subyacente predeterminado es deque.

Se declara en el encabezado <stack>.

Es esencialmente equivalente a java.util.Stack(sin embargo, se considera obsoleto y se prefiere usar en su lugar java.util.ArrayDeque) en Java o System.Collections.Generic.Stacken .NET.

Cola

La std::queue<T>estructura de datos implementa una cola (estructura primero en entrar, primero en salir). Su tipo de colección subyacente predeterminado es deque.

Se declara en el encabezado <queue>.

Es similar a la interfaz de Java java.util.Queueo System.Collections.Generic.Queuea la de .NET.

Cola de prioridad

La std::priority_queue<T>estructura de datos implementa una cola de prioridad , que por defecto está ordenada mediante un objeto de funciónstd::less<T> (un montón máximo ). Su tipo de colección subyacente por defecto es vector.

Se declara en el encabezado <queue>.

Es esencialmente equivalente a java.util.PriorityQueueen Java (aunque se trata de un min-heap), System.Collections.Generic.PriorityQueueen .NET o std::collections::BinaryHeapen Rust.

Juego plano

La std::flat_set<T>estructura de datos implementa un "conjunto plano", que almacena una colección de claves únicas, que por defecto está ordenada mediante el objeto de función std::less<T>. Su tipo de colección subyacente por defecto es vector.

Se declara en el encabezado <flat_set>.

Mapa plano

La std::flat_map<K, V>estructura de datos implementa un "mapa plano", que almacena una colección de pares clave-valor únicos, que por defecto está ordenado mediante el objeto de función std::less<K>. Tiene dos colecciones subyacentes (para las claves y los valores), ambas por defecto vector.

Se declara en el encabezado <flat_map>.

Conjunto múltiple plano

La std::flat_multiset<T>estructura de datos implementa un "multiconjunto plano", que almacena una colección de claves, la cual está ordenada por defecto mediante un objeto de función std::less<T>. Permite múltiples claves con valores equivalentes. Su tipo de colección subyacente por defecto es vector.

Se declara en el encabezado <flat_set>.

Mapa plano múltiple

La std::flat_multimap<K, V>estructura de datos implementa un "mapa múltiple plano", que almacena una colección de pares clave-valor, que por defecto está ordenada mediante un objeto de función std::less<K>. Permite múltiples entradas con claves equivalentes. Tiene dos colecciones subyacentes (para las claves y los valores), ambas por defecto vector.

Se declara en el encabezado <flat_map>.

Vistas

En C++, un contenedor de vista se utiliza para interactuar con varios arreglos de elementos que no son de propiedad. ^{[ 2 ]}

Durar

La std::span<T>estructura de datos implementa una vista sin propiedad sobre una secuencia contigua unidimensional de objetos.

Se declara en el encabezado <span>.

Es similar a las clases java.niojava.nio.Buffer y sus descendientes (que son vistas no propietarias sobre matrices primitivas) en Java, System.Spanen .NET o &[T]( &mut [T]slices) en Rust.

Alcance multidimensional

La std::mdspan<T>estructura de datos implementa una vista sin propiedad sobre una matriz multidimensional.

Se declara en el encabezado <mdspan>.

Descripción general de las funciones

Los contenedores se definen en encabezados que llevan el nombre de los contenedores, por ejemplo, vectorse define en el encabezado <vector>. Todos los contenedores satisfacen los requisitos del concepto de Contenedor , lo que significa que tienen los métodos , , , , , y .begin()end()size()max_size()empty()swap()

Funciones de los miembros

Hay otras operaciones que están disponibles como parte de la clase lista y hay algoritmos que forman parte de la STL de C++ ( Algoritmo (C++) ) que se pueden usar con la clase listy :forward_list

Operaciones

list::mergey forward_list::merge- Combina dos listas ordenadas
list::splicey forward_list::splice_after- Mueve elementos de otra lista
list::removey forward_list::remove- Elimina los elementos iguales al valor dado.
list::remove_ify forward_list::remove_if- Elimina elementos que cumplen criterios específicos
list::reversey forward_list::reverse- Invierte el orden de los elementos
list::uniquey forward_list::unique- Elimina elementos duplicados consecutivos
list::sorty forward_list::sort- Ordena los elementos

Funciones que no son miembros

Ejemplo de uso

El siguiente ejemplo demuestra varias técnicas que involucran un vector y algoritmos de la biblioteca estándar de C++ (con C++20std::ranges ), en particular la mezcla , la ordenación , la búsqueda del elemento más grande y el borrado de un vector utilizando el modismo de borrado-eliminación .

importar std ;using std :: array ; using std :: mt19937 ; using std :: random_device ; using std :: vector ;int main ( int argc , char * argv []) { array < int , 4 > arr { 1 , 2 , 3 , 4 };// inicializa un vector a partir de un array vector < int > numbers ( arr . cbegin (), arr . cend ());// Insertar más números en el vector numbers.push_back ( 5 ); numbers.push_back ( 6 ); numbers.push_back ( 7 ); numbers.push_back ( 8 ) ; // El vector actualmente contiene {1 , 2 , 3 , 4, 5, 6, 7, 8}// Mezcla aleatoriamente los elementos random_device rd ; // Semilla para el generador de números aleatorios mt19937 g ( rd ()); // Motor de números aleatorios Mersenne Twister std :: ranges :: shuffle ( numbers , g );// localiza el elemento más grande, O(n) int largest = std :: ranges :: max_element ( numbers ); int indexOfLargest = std :: ranges :: distance ( numbers . cbegin (), largest );std :: println ( "El número más grande es {}, ubicado en el índice {}" , largest , indexOfLargest );// ordenar los elementos std :: ranges :: sort ( numbers );// encuentra la posición del número 5 en el vector int five = std :: ranges :: lower_bound ( numbers , 5 ); int indexOfFive = std :: ranges :: distance ( numbers . cbegin (), five );std :: println ( "El número 5 se encuentra en el índice {}" , indexOfFive );// Borra todos los elementos mayores que 4 numbers.erase ( std :: ranges :: remove_if ( numbers , [ ]( int n ) constexpr- > bool { return n > 4 ; } ), numbers.end ( ) ) ;// Imprimir todos los números restantes for ( int element : numbers ) { std :: print ( "{}" , element ); } }

El resultado será el siguiente:

El número más grande es 8 Se encuentra en el índice 6 (depende de la implementación). El número 5 se encuentra en el índice 4. 1 2 3 4

Véase también

Referencias

William Ford, William Topp. Estructuras de datos con C++ y STL , Segunda edición. Prentice Hall, 2002. ISBN 0-13-085850-1Capítulo 4: La clase Vector, págs. 195 – 203.
Josuttis, Nicolai M. (1999). La biblioteca estándar de C++ . Addison-Wesley. ISBN 0-201-37926-0.

Notas

1 2 3 Josuttis, Nicolai (1999). Biblioteca estándar de C++: un tutorial y referencia . Addison-Wesley.
1 2 3 "Biblioteca de contenedores - cppreference" . cppreference.com . cppreference . Consultado el 14 de octubre de 2025 .
↑ ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.1 Requisitos del contenedor [lib.container.requirements] párr. 4
↑ Stepanov, Alexander A. (2015). De las matemáticas a la programación genérica . Daniel E. Rose. Upper Saddle River, NJ. ISBN 978-0-13-349179-1OCLC 898036481 {{cite book}}: CS1 mantenimiento: falta el editor de ubicación ( enlace )
↑ cppreference.com. "std::formatter - cppreference.com" . cppreference.com . cppreference.com . Consultado el 6 de diciembre de 2025 .
↑ Bibliotecas Boost C++. "dynamic_bitset<Block, Allocator>" . boost.org/doc . Bibliotecas Boost C++ . Consultado el 6 de diciembre de 2025 .
↑ ISO/IEC 14882 ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.4 Plantilla de clase vector (lib.vector) párrafo.1 (PDF) (Informe técnico). ISO / IEC . 2003. p. 489. Archivado del original (PDF) el 25 de febrero de 2022. Los elementos de un vector se almacenan de forma contigua, lo que significa que si v es un vector donde T es algún tipo distinto de bool, entonces obedece la identidad &v[n] == &v[0] + n para todo 0 <= n < v.size().
↑ ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.4.3 Modificadores de vector [lib.vector.modifiers] párr. 1
↑ ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.4.2 capacidad vectorial [lib.vector.capacity] párr. 5
↑ ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.4.2 capacidad vectorial [lib.vector.capacity] párr. 2
↑ ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.4.3 Modificadores de vector [lib.vector.modifiers] párr. 3
↑ ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.5 Clase vector<bool> [lib.vector.bool] párr. 1
↑ "vector<bool>: Más problemas, mejores soluciones" (PDF) . Agosto de 1999. Consultado el 28 de noviembre de 2017 .
↑ "Una especificación para desaprobar vector<bool>" . Marzo de 2007. Consultado el 28 de noviembre de 2017 .
↑ ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.5 Clase vector<bool> [lib.vector.bool] párr. 2
↑ "96. Vector<bool> no es un contenedor" . Consultado el 28 de junio de 2018 .
↑ Bluss (17 de agosto de 2024). "Caja arrayvec" . docs.rs. docs.rs.
↑ Bibliotecas Boost C++ (1 de abril de 2026). "Plantilla de clase static_vector" . boost.org . Bibliotecas Boost C++.
↑ Proyecto LLVM (14 de marzo de 2026). "Referencia de plantilla de clase llvm::SmallVector<T, N>" . llvm.org . Proyecto LLVM.
↑ François-Xavier Bourlet (3 de abril de 2019). "Lista de cajas fwdlist" . docs.rs. docs.rs.
↑ Matthew Bentley (1 de diciembre de 2025). "PLF Library - colony" . plflib.org . plflib.
↑ LlewVallis (4 de agosto de 2023). "Colonia de cajas" . docs.rs. docs.rs.

[josuttis-1] 1 2 3 Josuttis, Nicolai (1999). Biblioteca estándar de C++: un tutorial y referencia . Addison-Wesley.

[cppreferencecontainers-2] 1 2 3 "Biblioteca de contenedores - cppreference" . cppreference.com . cppreference . Consultado el 14 de octubre de 2025 .

[C++03_23.1/4-3] ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.1 Requisitos del contenedor [lib.container.requirements] párr. 4

[4] Stepanov, Alexander A. (2015). De las matemáticas a la programación genérica . Daniel E. Rose. Upper Saddle River, NJ. ISBN 978-0-13-349179-1OCLC 898036481 {{cite book}}: CS1 mantenimiento: falta el editor de ubicación ( enlace )

[5] reference.com. "std::formatter - cppreference.com" . cppreference.com . cppreference.com . Consultado el 6 de diciembre de 2025 .

[6] Bibliotecas Boost C++. "dynamic_bitset<Block, Allocator>" . boost.org/doc . Bibliotecas Boost C++ . Consultado el 6 de diciembre de 2025 .

[C++03_23.2.4/1-7] ISO/IEC 14882 ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.4 Plantilla de clase vector (lib.vector) párrafo.1 (PDF) (Informe técnico). ISO / IEC . 2003. p. 489. Archivado del original (PDF) el 25 de febrero de 2022. Los elementos de un vector se almacenan de forma contigua, lo que significa que si v es un vector donde T es algún tipo distinto de bool, entonces obedece la identidad &v[n] == &v[0] + n para todo 0 <= n < v.size().

[C++03_23.2.4.3/1-8] ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.4.3 Modificadores de vector [lib.vector.modifiers] párr. 1

[C++03_23.2.4.2/5-9] ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.4.2 capacidad vectorial [lib.vector.capacity] párr. 5

[C++03_23.2.4.2/2-10] ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.4.2 capacidad vectorial [lib.vector.capacity] párr. 2

[C++03_23.2.4.3/3-11] ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.4.3 Modificadores de vector [lib.vector.modifiers] párr. 3

[C++03_23.2.5/1-12] ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.5 Clase vector<bool> [lib.vector.bool] párr. 1

[13] "vector<bool>: Más problemas, mejores soluciones" (PDF) . Agosto de 1999. Consultado el 28 de noviembre de 2017 .

[14] "Una especificación para desaprobar vector<bool>" . Marzo de 2007. Consultado el 28 de noviembre de 2017 .

[C++03_23.2.5/2-15] ISO / IEC (2003). ISO/IEC 14882:2003(E): Lenguajes de programación - C++ §23.2.5 Clase vector<bool> [lib.vector.bool] párr. 2

[16] "96. Vector<bool> no es un contenedor" . Consultado el 28 de junio de 2018 .

[17] Bluss (17 de agosto de 2024). "Caja arrayvec" . docs.rs. docs.rs.

[18] Bibliotecas Boost C++ (1 de abril de 2026). "Plantilla de clase static_vector" . boost.org . Bibliotecas Boost C++.

[19] Proyecto LLVM (14 de marzo de 2026). "Referencia de plantilla de clase llvm::SmallVector<T, N>" . llvm.org . Proyecto LLVM.

[20] François-Xavier Bourlet (3 de abril de 2019). "Lista de cajas fwdlist" . docs.rs. docs.rs.

[21] Matthew Bentley (1 de diciembre de 2025). "PLF Library - colony" . plflib.org . plflib.

[22] LlewVallis (4 de agosto de 2023). "Colonia de cajas" . docs.rs. docs.rs.

[ 1 ]

[ 2 ]

[ 3 ]

[ 4 ]

[ 5 ]

[ 6 ]

[ 7 ]

[ 8 ]

[ 9 ]

[ 10 ]

[ 11 ]

[ 12 ]

[ 13 ]

[ 14 ]

[

[

[ 17 ]

[ 18 ]

[ 19 ]

[ 20 ]

[ 21 ]

[ 22 ]