std:: array

std::array es un contenedor que encapsula arreglos de tamaño fijo.

Este contenedor es un tipo agregado con la misma semántica que una estructura que contiene un array estilo C T [ N ] como su único miembro de datos no estático. A diferencia de un array estilo C, no se degrada a T * automáticamente. Como tipo agregado, puede inicializarse con inicialización de agregado usando como máximo N inicializadores convertibles a T : std :: array < int , 3 > a = { 1 , 2 , 3 } ; .

La estructura combina el rendimiento y accesibilidad de un array estilo C con las ventajas de un contenedor estándar, como conocer su propio tamaño, soportar asignación, iteradores de acceso aleatorio, etc.

std::array satisface los requisitos de Container y ReversibleContainer excepto que un array construido por defecto no está vacío y que la complejidad del intercambio es lineal, satisface los requisitos de ContiguousContainer , (desde C++17) y satisface parcialmente los requisitos de SequenceContainer .

Existe un caso especial para un array de longitud cero ( N == 0 ). En ese caso, array. begin ( ) == array. end ( ) , que es algún valor único. El efecto de llamar front ( ) o back ( ) en un array de tamaño cero es indefinido.

Un array también puede ser utilizado como una tupla de N elementos del mismo tipo.

Invalidación de iteradores

Como regla general, los iteradores de un array nunca se invalidan durante la vida útil del array. Sin embargo, debe tenerse en cuenta que durante swap , el iterador continuará apuntando al mismo elemento del array, y por lo tanto cambiará su valor.

Parámetros de plantilla

Tipos de miembros

Funciones miembro

Funciones no miembro

Clases auxiliares

Ejemplo

#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
#include <string>
int main()
{
    // La construcción utiliza inicialización por agregado
    std::array<int, 3> a1{{1, 2, 3}}; // Se requieren llaves dobles en C++11 antes de
                                      // la revisión CWG 1270 (no se necesitan en C++11
                                      // después de la revisión y en C++14 y posteriores)
    std::array<int, 3> a2 = {1, 2, 3}; // Las llaves dobles nunca se requieren después de =
    // Se admiten operaciones de contenedor
    std::sort(a1.begin(), a1.end());
    std::ranges::reverse_copy(a2, std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
    // Se admite el bucle for por rangos
    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 array (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 arrays integrados
    [[maybe_unused]] std::array<int, 2> a5; // Sin inicialización por lista, a5[0] y a5[1]
                                            // se inicializan por defecto
    [[maybe_unused]] std::array<int, 2> a6{}; // Inicialización por lista, ambos elementos se
                                              // inicializan por valor, a6[0] = a6[1] = 0
    [[maybe_unused]] std::array<int, 2> a7{1}; // Inicialización por lista, el elemento no especificado se
                                               // inicializa por valor, a7[0] = 1, a7[1] = 0
}

3 2 1
E Ǝ

Véase también