C++
std :: matrix

parameters

Opmerkingen

Een std :: array initialiseren

Initialiseren van std::array<T, N> , waarbij T een scalair type is en N het aantal elementen van type T

Als T een scalair type is, kan std::array op de volgende manieren worden geïnitialiseerd:

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

Initialiseren van std::array<T, N> , waarbij T een niet-scalair type is en N het aantal elementen van type T

Als T een niet-scalair type is, kan std::array op de volgende manieren worden geïnitialiseerd:

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 toegang

1. at(pos)

Retourneert een verwijzing naar het element op positie pos met grenzencontrole. Als pos niet binnen het bereik van de container valt, wordt een uitzondering van het type std::out_of_range gegenereerd.

De complexiteit is constant 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]

Retourneert een verwijzing naar het element op positie pos zonder grenzencontrole. Als pos niet binnen het bereik van de container valt, kan een runtime- segmentatiefoutfout optreden. Deze methode biedt elementtoegang gelijk aan klassieke arrays en is efficiënter dan at(pos) .

De complexiteit is constant 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>

Deze niet- lidfunctie retourneert een verwijzing naar het element op compilatie-tijd constante positie pos zonder grenzencontrole. Als pos niet binnen het bereik van de container valt, kan een runtime- segmentatiefoutfout optreden.

De complexiteit is constant 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()

Retourneert een verwijzing naar het eerste element in container. Het aanroepen van front() op een lege container is niet gedefinieerd.

De complexiteit is constant O (1).

Opmerking: voor een container c is de uitdrukking c.front() gelijk aan *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()

Retourneert verwijzing naar het laatste element in de container. Terugbellen back() op een lege container is niet gedefinieerd.

De complexiteit is constant 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()

Retourneert de aanwijzer naar de onderliggende array die dient als elementopslag. De aanwijzer is zodanig dat range [data(); data() + size()) is altijd een geldig bereik, zelfs als de container leeg is ( data() kan in dat geval niet worden verwijderd).

De complexiteit is constant 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;
}

Grootte van de array controleren

Een van de belangrijkste voordelen van std::array ten opzichte van de array in C stijl is dat we de grootte van de array kunnen controleren met de functie size() member

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

Door de array heen lopen

std::array is een STL-container en kan op bereik gebaseerde loop gebruiken die vergelijkbaar is met andere containers zoals vector

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

Alle array-elementen tegelijk wijzigen

De lidfunctie fill() kan op std::array worden gebruikt om de waarden in één keer na initialisatie te wijzigen

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