◐ Shell
clean mode source ↗

std::array - cppreference.com

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

Tipos miembro

Tipo miembro Definición
value_type T [editar]
size_type std::size_t [editar]
difference_type std::ptrdiff_t [editar]
reference value_type& [editar]
const_reference const value_type& [editar]
pointer T*[editar]
const_pointer const T*[editar]
iterator IteradorDeAccesoAleatorioLegado e IteradorConstexpr (desde C++20)que es un TipoLiteral (desde C++17) [editar]
const_iterator IteradorDeAccesoAleatorioLegado constante e IteradorConstexpr (desde C++20)que es un TipoLiteral (desde C++17) [editar]
reverse_iterator std::reverse_iterator<iterator> [editar]
const_reverse_iterator std::reverse_iterator<const_iterator> [editar]

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) [editar]
Accede el elemento especificado.
(función miembro pública) [editar]

(C++11)

 Accede al primer elemento.
(función miembro pública) [editar]

(C++11)

 Accede al último elemento.
(función miembro pública) [editar]

(C++11)

 Acceso directo al array subyacente.
(función miembro pública) [editar]
Iteradores
Devuelve un iterador al principio.
(función miembro pública) [editar]

(C++11)

 Devuelve un iterador al final.
(función miembro pública) [editar]
Devuelve un iterador inverso al principio.
(función miembro pública) [editar]
Devuelve un iterador inverso al final.
(función miembro pública) [editar]
Capacidad

(C++11)

 Comprueba si el contenedor está vacío.
(función miembro pública) [editar]

(C++11)

 Devuelve el número de elementos.
(función miembro pública) [editar]

(C++11)

 Devuelve el número máximo posible de elementos.
(función miembro pública) [editar]
Operaciones
Llena el contenedor con el valor especificado
(función miembro pública) [editar]

(C++11)

 Intercambia el contenido.
(función miembro pública) [editar]

Funciones no miembro

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) [editar]

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) [editar]

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:

Véase también

array contiguo in situ, de capacidad fija y redimensionable dinámicamente
(plantilla de clase) [editar]
Array dinámico contiguo.
(plantilla de clase) [editar]
Cola doblemente terminada (deque).
(plantilla de clase) [editar]
Crea un objeto std::array cuyo tamaño y opcionalmente tipo de elemento se deducen a partir de los argumentos.
(plantilla de función) [editar]