C++
std :: array

Parameter

Bemerkungen

Initialisieren eines std :: -Arrays

Initialisierung von std::array<T, N> , wobei T ein Skalartyp und N die Anzahl der Elemente vom Typ T

Wenn T ein Skalartyp ist, kann std::array auf folgende Weise initialisiert werden:

// 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 };

Initialisierung von std::array<T, N> , wobei T ein nicht skalarer Typ ist und N die Anzahl der Elemente vom Typ T

Wenn T ein nicht-skalarer Typ ist, kann std::array auf folgende Weise initialisiert werden:

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 };

Elementzugriff

1. at(pos)

Gibt einen Verweis auf das Element an Position pos mit Begrenzungsprüfung zurück. Wenn pos nicht im Bereich des Containers liegt, wird eine Ausnahme vom Typ std::out_of_range ausgelöst.

Die Komplexität ist konstant 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]

Gibt einen Verweis auf das Element an der Position pos ohne Prüfung der Grenzen zurück. Wenn pos nicht im Bereich des Containers liegt, kann ein Fehler bei der Segmentierungsverletzung der Laufzeit auftreten. Diese Methode bietet einen Elementzugriff, der klassischen Arrays entspricht und effizienter ist als at(pos) .

Die Komplexität ist konstant 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>

Diese Nicht-Member- Funktion gibt einen Verweis auf das Element an der konstanten Position pos Kompilierungszeit zurück, ohne dass eine Prüfung der Grenzen erfolgt. Wenn pos nicht im Bereich des Containers liegt, kann ein Fehler bei der Segmentierungsverletzung der Laufzeit auftreten.

Die Komplexität ist konstant 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()

Gibt einen Verweis auf das erste Element im Container zurück. Das Aufrufen von front() auf einem leeren Container ist undefiniert.

Die Komplexität ist konstant O (1).

Hinweis: Für einen Container c entspricht der Ausdruck c.front() *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()

Gibt den Verweis auf das letzte Element im Container zurück. Rückruf back() eines leeren Containers ist undefiniert.

Die Komplexität ist konstant 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()

Gibt einen Zeiger auf das zugrunde liegende Array zurück, das als Elementspeicher dient. Der Zeiger ist so, dass der range [data(); data() + size()) ist immer ein gültiger Bereich, auch wenn der Container leer ist ( data() ist in diesem Fall nicht dereferenzierbar).

Die Komplexität ist konstant 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;
}

Größe des Arrays überprüfen

Einer der Hauptvorteile von std::array im Vergleich zu einem C Stil-Array besteht darin, dass wir die Größe des Arrays mithilfe der Mitgliedsfunktion size() überprüfen können

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

Iteration durch das Array

std::array ist ein STL-Container und kann eine bereichsbasierte Schleife verwenden, die anderen Containern wie vector ähnelt

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

Alle Array-Elemente auf einmal ändern

Die Memberfunktion fill() kann für std::array um die Werte nach der Initialisierung sofort zu ändern

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