C++
std :: array

Parámetros

Observaciones

Inicializando un std :: array

Inicializando std::array<T, N> , donde T es un tipo escalar y N es el número de elementos de tipo T

Si T es un tipo escalar, std::array se puede inicializar de las siguientes maneras:

// 1) Using aggregate-initialization
std::array<int, 3> a{ 0, 1, 2 };
// or equivalently
std::array<int, 3> a = { 0, 1, 2 };

// 2) Using the copy constructor
std::array<int, 3> a{ 0, 1, 2 };
std::array<int, 3> a2(a);
// or equivalently
std::array<int, 3> a2 = a;

// 3) Using the move constructor
std::array<int, 3> a = std::array<int, 3>{ 0, 1, 2 };

Inicializando std::array<T, N> , donde T es un tipo no escalar y N es el número de elementos de tipo T

Si T es un tipo no escalar, std::array se puede inicializar de las siguientes maneras:

struct A { int values[3]; }; // An aggregate type

// 1) Using aggregate initialization with brace elision
// It works only if T is an aggregate type!
std::array<A, 2> a{ 0, 1, 2, 3, 4, 5 };
// or equivalently
std::array<A, 2> a = { 0, 1, 2, 3, 4, 5 };

// 2) Using aggregate initialization with brace initialization of sub-elements
std::array<A, 2> a{ A{ 0, 1, 2 }, A{ 3, 4, 5 } };
// or equivalently
std::array<A, 2> a = { A{ 0, 1, 2 }, A{ 3, 4, 5 } };

// 3)
std::array<A, 2> a{{ { 0, 1, 2 }, { 3, 4, 5 } }};
// or equivalently
std::array<A, 2> a = {{ { 0, 1, 2 }, { 3, 4, 5 } }};

// 4) Using the copy constructor
std::array<A, 2> a{ 1, 2, 3 };
std::array<A, 2> a2(a);
// or equivalently
std::array<A, 2> a2 = a;

// 5) Using the move constructor
std::array<A, 2> a = std::array<A, 2>{ 0, 1, 2, 3, 4, 5 };

Acceso a elementos

1. at(pos)

Devuelve una referencia al elemento en la posición pos con comprobación de límites. Si pos no está dentro del rango del contenedor, se lanza una excepción de tipo std::out_of_range .

La complejidad es constante O (1).

#include <array>

int main()
{
    std::array<int, 3> arr;

    // write values
    arr.at(0) = 2;
    arr.at(1) = 4;
    arr.at(2) = 6;
        
    // read values
    int a = arr.at(0); // a is now 2
    int b = arr.at(1); // b is now 4
    int c = arr.at(2); // c is now 6

    return 0;
}

2) operator[pos]

Devuelve una referencia al elemento en la posición pos sin verificación de límites. Si pos no está dentro del rango del contenedor, puede ocurrir un error de violación de segmentación en tiempo de ejecución. Este método proporciona acceso a elementos equivalente a las matrices clásicas y, por lo tanto, más eficiente que at(pos) .

La complejidad es constante O (1).

#include <array>

int main()
{
    std::array<int, 3> arr;

    // write values
    arr[0] = 2;
    arr[1] = 4;
    arr[2] = 6;
        
    // read values
    int a = arr[0]; // a is now 2
    int b = arr[1]; // b is now 4
    int c = arr[2]; // c is now 6

    return 0;
}

3) std::get<pos>

Esta función que no es miembro devuelve una referencia al elemento en la posición constante en tiempo de compilación pos sin verificación de límites. Si pos no está dentro del rango del contenedor, puede ocurrir un error de violación de segmentación en tiempo de ejecución.

La complejidad es constante O (1).

#include <array>

int main()
{
    std::array<int, 3> arr;

    // write values
    std::get<0>(arr) = 2;
    std::get<1>(arr) = 4;
    std::get<2>(arr) = 6;
        
    // read values
    int a = std::get<0>(arr); // a is now 2
    int b = std::get<1>(arr); // b is now 4
    int c = std::get<2>(arr); // c is now 6

    return 0;
}

4) front()

Devuelve una referencia al primer elemento en el contenedor. Llamar a front() en un contenedor vacío no está definido.

La complejidad es constante O (1).

Nota: Para un contenedor c, la expresión c.front() es equivalente a *c.begin() .

#include <array>

int main()
{
    std::array<int, 3> arr{ 2, 4, 6 };

    int a = arr.front(); // a is now 2

    return 0;
}

5) back()

Devuelve la referencia al último elemento en el contenedor. La back() llamada back() en un contenedor vacío no está definido.

La complejidad es constante O (1).

#include <array>

int main()
{
    std::array<int, 3> arr{ 2, 4, 6 };

    int a = arr.back(); // a is now 6

    return 0;
}

6) data()

Devuelve el puntero a la matriz subyacente que sirve como almacenamiento de elementos. El puntero es tal que el range [data(); data() + size()) siempre es un rango válido, incluso si el contenedor está vacío ( data() no se puede descifrar en ese caso).

La complejidad es constante O (1).

#include <iostream>
#include <cstring>
#include <array>

int main ()
{
    const char* cstr = "Test string";
    std::array<char, 12> arr;
    
    std::memcpy(arr.data(), cstr, 12); // copy cstr to arr
    
    std::cout << arr.data(); // outputs: Test string
    
    return 0;
}

Comprobando el tamaño de la matriz

Una de las principales ventajas de std::array en comparación con la matriz de estilo C es que podemos verificar el tamaño de la matriz utilizando la función miembro size()

int main() {
    std::array<int, 3> arr = { 1, 2, 3 };
    cout << arr.size() << endl;
}

Iterando a través de la matriz

std::array es un contenedor STL, puede usar un rango basado en bucle similar a otros contenedores como vector

int main() {
     std::array<int, 3> arr = { 1, 2, 3 };
     for (auto i : arr)
         cout << i << '\n';
}

Cambiando todos los elementos de la matriz a la vez

La función miembro fill() se puede usar en std::array para cambiar los valores a la vez después de la inicialización

int main() {
    
    std::array<int, 3> arr = { 1, 2, 3 };
    // change all elements of the array to 100
    arr.fill(100);
    
}