std::array
| Definido en el archivo de encabezado <array>
|
||
template< class T, std::size_t N > struct array; |
(desde C++11) | |
std::array es un contenedor que encapsula arrays de tamaño fijo.
Este contenedor es un tipo agregado con la misma semántica que una estructura que alberga un array estilo C T[N] como su único miembro no estático. A diferencia de un array estilo C, no decae a T* automáticamente. Como tipo agregado, puede inicializarse con la inicialización de agregado dados a lo sumo N inicializadores que son convertibles a T: std::array<int, 3> a = {1,2,3};.
La estructura combina el rendimiento y la accesibilidad de un array estilo C con los beneficios de un contenedor estándar, tales como el conocimiento de su propio tamaño, soporte de asignación, iteradores de acceso aleatorio, etc.
std::array satisface los requerimientos de Contenedor y ContenedorReversible. Con la excepción que un std::array construido por defecto no está vacio y que la complejidad de intercambio es lineal, satisface los requerimientos de ContenedorContiguo (desde C++17) y satisface parcialmente los requerimientos de ContenedorDeSecuencia.
Hay un caso especial para los std::arrays de longitud cero (N == 0). En tal caso, array.begin() == array.end(), que es un valor único. El efecto de llamar a front() o a back() en un std::array de tamaño cero no está definido.
Un std::array también puede usarse como una tupla de N elementos del mismo tipo.
Invalidación de iteradores
Como regla, los iteradores a un std::array nunca se invalidan durante el tiempo de vida del array. Observa, sin embargo, que durante swap, el iterador continuará apuntando al mismo elemento del std::array, y consecuentemente cambiará su valor.
Parámetros de plantilla
| T | - | element type Debe ser ConstruiblePorMovimiento y AsignablePorMovimiento. |
| N | - | El número de elementos en el array o 0.
|
| Esta sección está incompleta Razón: Completar las descripciones de los parámetros de plantilla. |
Tipos miembro
| Tipo miembro | Definición |
value_type
|
T
|
size_type
|
std::size_t |
difference_type
|
std::ptrdiff_t |
reference
|
value_type&
|
const_reference
|
const value_type&
|
pointer
|
T*
|
const_pointer
|
const T*
|
iterator
|
IteradorDeAccesoAleatorioLegado e IteradorConstexpr (desde C++20)que es un TipoLiteral (desde C++17) |
const_iterator
|
IteradorDeAccesoAleatorioLegado constante e IteradorConstexpr (desde C++20)que es un TipoLiteral (desde C++17) |
reverse_iterator
|
std::reverse_iterator<iterator>
|
const_reverse_iterator
|
std::reverse_iterator<const_iterator>
|
Funciones miembro
Funciones miembro definidas implícitamente | |
(constructor) (implícitamente declarado) |
Inicializa el array siguiendo las reglas de la inicialización de agregado (la inicialización por defecto puede resultar en valores indeterminados para tipos T que no sean clases) (función miembro pública) |
(destructor) (implícitamente declarado) |
Destruye cada elemento del array (función miembro pública) |
operator= (implícitamente declarado) |
Sobrescribe cada elemento del array con el elemento correspondiente de otro array (función miembro pública) |
Acceso a elementos | |
| Accede al elemento especificado con comprobación de límites. (función miembro pública) | |
(C++11) |
Accede el elemento especificado. (función miembro pública) |
(C++11) |
Accede al primer elemento. (función miembro pública) |
(C++11) |
Accede al último elemento. (función miembro pública) |
(C++11) |
Acceso directo al array subyacente. (función miembro pública) |
Iteradores | |
(C++11) |
Devuelve un iterador al principio. (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) |
| Devuelve un iterador inverso al final. (función miembro pública) | |
Capacidad | |
(C++11) |
Comprueba si el contenedor está vacío. (función miembro pública) |
(C++11) |
Devuelve el número de elementos. (función miembro pública) |
(C++11) |
Devuelve el número máximo posible de elementos. (función miembro pública) |
Operaciones | |
| Llena el contenedor con el valor especificado (función miembro pública) | |
(C++11) |
Intercambia el contenido. (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 array. (plantilla de función) |
(C++11) |
Accede a un elemento de un array. (plantilla de función) |
(C++11) |
Especializa el algoritmo std::swap. (plantilla de función) |
(C++20) |
Crea un objeto std::array a partir de un array integrado. (plantilla de función) |
Clases auxiliares
obtiene el tamaño de un array Original: obtains the size of an array The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (especialización de plantilla de clase) | |
se obtiene el tipo de los elementos de array Original: obtains the type of the elements of array The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (especialización de plantilla de clase) |
Guías de deducción |
(desde C++17) |
Ejemplo
#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
#include <string>
int main()
{
// la construcción usa la inicialización de agregado
std::array<int, 3> a1{{1, 2, 3}}; // llaves dobles requeridas en C++11 previo a
// la revisión CWG 1270 (no se necesita en C++11
// después de la revisión y en C++14 y posterior)
std::array<int, 3> a2 = {1, 2, 3}; // nunca se requieren llaves dobles después de =
std::array<std::string, 2> a3 = { std::string("a"), "b" };
// se ofrece apoyo para las operaciones de contenedores
std::sort(a1.begin(), a1.end());
std::ranges::reverse_copy(a2, std::ostream_iterator<int>(std::cout, " "));
std::cout << '\n';
// se ofrece apoyo para bucle for basado en rango
std::array<std::string, 2> a3{"E", "\u018E"};
for (const auto& s : a3)
std::cout << s << ' ';
std::cout << '\n';
// guía de deducción para creación de arrays (desde C++17)
[[maybe_unused]] std::array a4{3.0, 1.0, 4.0}; // std::array<double, 3>
// el comportamiento de elementos no especificados
// es el mismo que con los arrays integrados
[[maybe_unused]] std::array<int, 2> a5; // no inic. de lista, a5[0] y a5[1]
// se inicializan p. defecto
[[maybe_unused]] std::array<int, 2> a6{}; // inic. de lista, ambos elems. se
// inicializan p. valor, a6[0] = a6[1] = 0
[[maybe_unused]] std::array<int, 2> a7{1}; // inic. de lista, elem. no especificado se
// inicializa p. valor, a7[0] = 1, a7[1] = 0
}
Salida:
3 2 1
E Ǝ
Véase también
(C++26) |
array contiguo in situ, de capacidad fija y redimensionable dinámicamente (plantilla de clase) |
| Array dinámico contiguo. (plantilla de clase) | |
Cola doblemente terminada (deque). (plantilla de clase) | |
| Crea un objeto std::array cuyo tamaño y opcionalmente tipo de elemento se deducen a partir de los argumentos. (plantilla de función) |