std::array

 

C++

Lenguaje

Archivos de encabezado de la biblioteca estándar

Implementaciones independientes y albergadas

Requerimientos denominados

Biblioteca de soporte del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de utilerías

Biblioteca de cadenas

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca numérica

Biblioteca de entrada/salida

Biblioteca de localizaciones

Biblioteca de expresiones regulares (C++11)

Biblioteca de operaciones atómicas (C++11)

Biblioteca de soporte de hilos (C++11)

Biblioteca de sistema de archivos (C++17)

Especificaciones técnicas

 

Biblioteca de contenedores

array (C++11)

vector

deque

forward_list (C++11)

list

set

multiset

map

multimap

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

stack

queue

priority_queue

span (C++20)

 

std::array

Funciones miembro

Acceso a elementos

array::at

array::operator[]

array::front

array::back

array::data

Iteradores

array::beginarray::cbegin

array::endarray::cend

array::rbeginarray::crbegin

array::rendarray::crend

Capacidad

array::empty

array::size

array::max_size

Modificadores

array::fill

array::swap

Funciones no miembro

get

std::swap

to_array (C++20)

operator==operator!=operator<operator>operator<=operator>=operator<=> (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(C++20)

Clases auxiliares

tuple_size

tuple_element

Guías de deducción(C++17)

 

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 como máximo 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 Container y ReversibleContainer. 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 ContiguousContainer (desde C++17) y satisface parcialmente los requerimientos de SequenceContainer.

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 está indefinido.

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 la vida del array. Observa, sin embargo, que durante swap, el iterador continuará apuntando al mismo elemento del std::array, y consecuentemente cambiará su valor.

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	LegacyRandomAccessIterator y ConstexprIterator (desde C++20)que es un LiteralType (desde C++17)
const_iterator	LegacyRandomAccessIterator constante y ConstexprIterator (desde C++20)que es un LiteralType (desde C++17)
reverse_iterator	std::reverse_iterator<iterator>
const_reverse_iterator	std::reverse_iterator<const_iterator>

Funciones miembro

Funciones miembro implícitamente definidas
(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 correspondiente elemento de otro array (función miembro pública)
Acceso a elementos
at	Accede al elemento especificado con comprobación de límites (función miembro pública)
operator[]	Accede al elemento especificado (función miembro pública)
front	Accede al primer elemento (función miembro pública)
back	Accede al último elemento (función miembro pública)
data	Acceso directo al array subyacente (función miembro pública)
Iteradores
begin cbegin	Devuelve un iterador al principio (función miembro pública)
end cend	Devuelve un iterador al final (función miembro pública)
rbegin crbegin	Devuelve un iterador inverso al principio (función miembro pública)
rend crend	Devuelve un iterador inverso al final (función miembro pública)
Capacidad
empty	Comprueba si el contenedor está vacío (función miembro pública)
size	Devuelve el número de elementos (función miembro pública)
max_size	Devuelve el número máximo posible de elementos (función miembro pública)
Operaciones
fill	Llena el contenedor con el valor especificado (función miembro pública)
swap	Intercambia el contenido (función miembro pública)

Funciones no miembro

operator==operator!=operator<operator<=operator>operator>=operator<=> (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)
std::get(std::array)	accesses an element of an array (plantilla de función)
std::swap(std::array)	Especializa el algoritmo std::swap. (plantilla de función)

Clases auxiliares

std::tuple_size<std::array>	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)
std::tuple_element<std::array>	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)

Ejemplo

Ejecuta este código

#include <string>
#include <iterator>
#include <iostream>
#include <algorithm>
#include <array>
 
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 (no en C++14)
    std::array<int, 3> a2 = {1, 2, 3};  // nunca requerido despues de =
    std::array<std::string, 2> a3 = { std::string("a"), "b" };
 
    // soporta las operaciones de contenedor
    std::sort(a1.begin(), a1.end());
    std::reverse_copy(a2.begin(), a2.end(), 
                      std::ostream_iterator<int>(std::cout, " "));
 
    std::cout << '\n';
 
    // soporta bucle for basado en rangos
    for(const auto& s: a3)
        std::cout << s << ' ';
}

Salida:

3 2 1 
a b

Véase también

make_array

Crea un objeto std::array cuyo tamaño y opcionalmente tipo de elemento se deducen a partir de los argumentos. (plantilla de función)