C++
std :: array

parametrar

Anmärkningar

Initiera en std :: array

Initiera std::array<T, N> , där T är en skalartyp och N är antalet element av typ T

Om T är en skalartyp kan std::array initieras på följande sätt:

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

Initiera std::array<T, N> , där T är en icke-skalartyp och N är antalet element av typ T

Om T är en icke-skalartyp kan std::array initieras på följande sätt:

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

Elementåtkomst

1. at(pos)

Returnerar en referens till elementet i position pos med gränskontroll. Om pos inte ligger inom behållarens std::out_of_range kastas ett undantag av typen std::out_of_range .

Komplexiteten är 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]

Returnerar en referens till elementet i position pos utan gränskontroll. Om pos inte är inom intervallet av behållaren, kan en runtime segmente kränkning fel uppstå. Denna metod ger elementåtkomst motsvarande klassiska matriser och därav mer effektiv än at(pos) .

Komplexiteten är 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>

Denna icke-medlemsfunktion returnerar en referens till elementet vid kompileringstidens konstantläge pos utan gränskontroll. Om pos inte är inom intervallet av behållaren, kan en runtime segmente kränkning fel uppstå.

Komplexiteten är 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()

Returnerar en referens till det första elementet i behållaren. Samtal front() på en tom behållare är odefinierat.

Komplexiteten är konstant O (1).

Obs: För en behållare c är uttrycket c.front() ekvivalent med *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()

Returnerar referens till det sista elementet i behållaren. Återuppringning back() på en tom behållare definieras inte.

Komplexiteten är 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()

Återger pekaren till den underliggande arrayen som fungerar som elementlagring. Pekaren är sådan att range [data(); data() + size()) är alltid ett giltigt intervall, även om behållaren är tom ( data() är inte i det fallet möjligt).

Komplexiteten är 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;
}

Kontrollera storleken på matrisen

En av de största fördelarna med std::array jämfört med C stil array är att vi kan kontrollera storleken på matrisen med hjälp av funktionen size()

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

Iterating genom Array

std::array är en STL-behållare, kan använda områdebaserade för slinga som liknar andra behållare som vector

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

Ändra alla arrayelement på en gång

fill() kan användas på std::array för att ändra värdena direkt efter initialisering

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