`array` Klasa (Standardowa biblioteka C++)

Artykuł
10/12/2023

Opisuje obiekt, który kontroluje sekwencję długości N elementów typu Ty. Sekwencja jest przechowywana jako tablica Ty, zawarta array<Ty, N> w obiekcie .

Składnia

template <class Ty, std::size_t N>
class array;

Parametry

Ty
Typ elementu.

N
Liczba elementów.

Członkowie

Definicja typu	opis
`const_iterator`	Typ iteratora stałego dla kontrolowanej sekwencji.
`const_pointer`	Typ stałego wskaźnika do elementu.
`const_reference`	Typ stałego odwołania do elementu.
`const_reverse_iterator`	Typ iteratora stałej odwrotnej dla kontrolowanej sekwencji.
`difference_type`	Typ odległości ze znakiem między dwoma elementami.
`iterator`	Typ iteratora dla kontrolowanej sekwencji.
`pointer`	Typ wskaźnika do elementu.
`reference`	Typ odwołania do elementu.
`reverse_iterator`	Typ iteratora odwrotnego dla kontrolowanej sekwencji.
`size_type`	Typ odległości bez znaku między dwoma elementami.
`value_type`	Typ elementu.

Funkcja elementów członkowskich	opis
`array`	Tworzy obiekt tablicy.
`assign`	(Przestarzałe. Użyj . `fill`) Zastępuje wszystkie elementy.
`at`	Uzyskuje dostęp do elementu na określonej pozycji.
`back`	Uzyskuje dostęp do ostatniego elementu.
`begin`	Określa początek kontrolowanej sekwencji.
`cbegin`	Zwraca iterator const dostępu losowego do pierwszego elementu w tablicy.
`cend`	Zwraca iterator const dostępu losowego, który wskazuje tuż poza końcem tablicy.
`crbegin`	Zwraca iterator const do pierwszego elementu w odwróconej tablicy.
`crend`	Zwraca iterator const na końcu odwróconej tablicy.
`data`	Pobiera adres pierwszego elementu.
`empty`	Sprawdza, czy elementy są obecne.
`end`	Określa koniec kontrolowanej sekwencji.
`fill`	Zamienia wszystkie elementy na określoną wartość.
`front`	Uzyskuje dostęp do pierwszego elementu.
`max_size`	Liczy liczbę elementów.
`rbegin`	Wyznacza początek odwróconej kontrolowanej sekwencji.
`rend`	Wyznacza koniec odwróconej kontrolowanej sekwencji.
`size`	Liczy liczbę elementów.
`swap`	Zamienia zawartości dwóch kontenerów.

Operator	opis
`array::operator=`	Zastępuje kontrolowaną sekwencję.
`array::operator[]`	Uzyskuje dostęp do elementu na określonej pozycji.

Uwagi

Typ ma konstruktor array() domyślny i domyślny operator operator=przypisania , i spełnia wymagania dla elementu aggregate. W związku z tym obiekty typu array<Ty, N> można zainicjować za pomocą inicjatora agregacji. Przykład:

array<int, 4> ai = { 1, 2, 3 };

Tworzy obiekt ai , który zawiera cztery wartości całkowite, inicjuje pierwsze trzy elementy do wartości 1, 2 i 3, i inicjuje czwarty element do 0.

Wymagania

Nagłówka:<array>

Obszaru nazw:std

`array::array`

Tworzy obiekt tablicy.

array();

array(const array& right);

Parametry

right
Obiekt lub zakres do wstawienia.

Uwagi

Domyślny konstruktor array() pozostawia niezainicjowaną kontrolowaną sekwencję (lub domyślną zainicjowaną). Służy do określania niezainicjowanej kontrolowanej sekwencji.

Konstruktor array(const array& right) kopiowania inicjuje kontrolowaną sekwencję z sekwencją [po prawej, prawo.begin().end()). Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej przez obiekt righttablicy .

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    Myarray c1(c0);

    // display contents " 0 1 2 3"
    for (const auto& it : c1)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0 1 2 3

`array::assign`

Przestarzałe w języku C++11 zastąpione przez fill. Zastępuje wszystkie elementy.

`array::at`

Uzyskuje dostęp do elementu na określonej pozycji.

reference at(size_type off);

constexpr const_reference at(size_type off) const;

Parametry

off
Pozycja elementu w celu uzyskania dostępu.

Uwagi

Funkcje składowe zwracają odwołanie do elementu kontrolowanej sekwencji w pozycji off. Jeśli ta pozycja jest nieprawidłowa, funkcja zgłasza obiekt klasy out_of_range.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display odd elements " 1 3"
    std::cout << " " << c0.at(1);
    std::cout << " " << c0.at(3);
    std::cout << std::endl;

    return (0);
}

`array::back`

Uzyskuje dostęp do ostatniego elementu.

reference back();

constexpr const_reference back() const;

Uwagi

Funkcje składowe zwracają odwołanie do ostatniego elementu kontrolowanej sekwencji, który musi być niepusty.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display last element " 3"
    std::cout << " " << c0.back();
    std::cout << std::endl;

    return (0);
}

0 1 2 3
3

`array::begin`

Określa początek kontrolowanej sekwencji.

iterator begin() noexcept;
const_iterator begin() const noexcept;

Uwagi

Funkcje składowe zwracają iterator dostępu losowego, który wskazuje na pierwszy element sekwencji (lub tuż poza końcem pustej sekwencji).

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::iterator it2 = c0.begin();
    std::cout << " " << *it2;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::cbegin`

const Zwraca iterator, który adresuje pierwszy element w zakresie.

const_iterator cbegin() const noexcept;

Wartość zwracana

const Iterator dostępu losowego, który wskazuje pierwszy element zakresu lub lokalizację tuż poza końcem pustego zakresu (dla pustego zakresu, cbegin() == cend()).

Uwagi

Przy zwracanej wartości cbeginelementu nie można modyfikować elementów w zakresie.

Możesz użyć tej funkcji składowej zamiast funkcji składowej begin() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje begin() i cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`array::cend`

Zwraca iterator, który adresuje lokalizację const tuż poza ostatnim elementem w zakresie.

const_iterator cend() const noexcept;

Wartość zwracana

Iterator dostępu swobodnego, który wskazuje tuż za koniec zakresu.

Uwagi

cend służy do testowania, czy iterator przeszedł koniec jego zakresu.

Możesz użyć tej funkcji składowej zamiast funkcji składowej end() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje end() i cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Wartość zwracana przez cend nie powinna być wyłuszczone.

`array::const_iterator`

Typ iteratora stałego dla kontrolowanej sekwencji.

typedef implementation-defined const_iterator;

Uwagi

Typ opisuje obiekt, który może służyć jako stały iterator dostępu losowego dla kontrolowanej sekwencji.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> MyArray;

int main()
{
    MyArray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    std::cout << "it1:";
    for (MyArray::const_iterator it1 = c0.begin();
        it1 != c0.end();
        ++it1) {
        std::cout << " " << *it1;
    }
    std::cout << std::endl;

    // display first element " 0"
    MyArray::const_iterator it2 = c0.begin();
    std::cout << "it2:";
    std::cout << " " << *it2;
    std::cout << std::endl;

    return (0);
}

it1: 0 1 2 3
it2: 0

`array::const_pointer`

Typ stałego wskaźnika do elementu.

typedef const Ty *const_pointer;

Uwagi

Typ opisuje obiekt, który może służyć jako stały wskaźnik do elementów sekwencji.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::const_pointer ptr = &*c0.begin();
    std::cout << " " << *ptr;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::const_reference`

Typ stałego odwołania do elementu.

typedef const Ty& const_reference;

Uwagi

Typ opisuje obiekt, który może służyć jako stałe odwołanie do elementu kontrolowanej sekwencji.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::const_reference ref = *c0.begin();
    std::cout << " " << ref;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::const_reverse_iterator`

Typ iteratora stałej odwrotnej dla kontrolowanej sekwencji.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Uwagi

Typ opisuje obiekt, który może służyć jako stały iterator odwrotny dla kontrolowanej sekwencji.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display last element " 3"
    Myarray::const_reverse_iterator it2 = c0.rbegin();
    std::cout << " " << *it2;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
3

`array::crbegin`

Zwraca iterator const do pierwszego elementu w odwróconej tablicy.

const_reverse_iterator crbegin() const;

Wartość zwracana

Iterator const reverse random-access zwracający się do pierwszego elementu w odwróconej tablicy lub zwracając się do tego, co było ostatnim elementem w niereversed tablicy.

Uwagi

Przy zwracanej wartości crbeginobiektu tablicy nie można modyfikować.

Przykład

#include <array>
#include <iostream>

int main( )
{
   using namespace std;
   array<int, 2> v1 = {1, 2};
   array<int, 2>::iterator v1_Iter;
   array<int, 2>::const_reverse_iterator v1_rIter;

   v1_Iter = v1.begin( );
   cout << "The first element of array is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed array is "
        << *v1_rIter << "." << endl;
}

The first element of array is 1.
The first element of the reversed array is 2.

`array::crend`

Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconej tablicy.

const_reverse_iterator crend() const noexcept;

Wartość zwracana

Iterator const reverse random-access, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconej tablicy (lokalizacja, która poprzedzała pierwszy element w niereversed tablicy).

Uwagi

crend jest używany z odwróconą tablicą tak samo, jak array::cend w przypadku tablicy.

Przy zwracanej wartości crend (odpowiednio zdekrementowanej) nie można zmodyfikować obiektu tablicy.

crend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec tablicy.

Wartość zwracana przez crend nie powinna być wyłuszczone.

Przykład

#include <array>
#include <iostream>

int main( )
{
   using namespace std;
   array<int, 2> v1 = {1, 2};
   array<int, 2>::const_reverse_iterator v1_rIter;

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`array::data`

Pobiera adres pierwszego elementu.

Ty *data();

const Ty *data() const;

Uwagi

Funkcje składowe zwracają adres pierwszego elementu w kontrolowanej sekwencji.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::pointer ptr = c0.data();
    std::cout << " " << *ptr;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::difference_type`

Typ odległości ze znakiem między dwoma elementami.

typedef std::ptrdiff_t difference_type;

Uwagi

Typ liczby całkowitej ze znakiem opisuje obiekt, który może reprezentować różnicę między adresami wszystkich dwóch elementów w kontrolowanej sekwencji. Jest to synonim typu std::ptrdiff_t.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display distance first-last " -4"
    Myarray::difference_type diff = c0.begin() - c0.end();
    std::cout << " " << diff;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
-4

`array::empty`

Sprawdza, czy nie ma żadnych elementów.

constexpr bool empty() const;

Uwagi

Funkcja składowa zwraca wartość true tylko wtedy, gdy N == 0.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display whether c0 is empty " false"
    std::cout << std::boolalpha << " " << c0.empty();
    std::cout << std::endl;

    std::array<int, 0> c1;

    // display whether c1 is empty " true"
    std::cout << std::boolalpha << " " << c1.empty();
    std::cout << std::endl;

    return (0);
}

0 1 2 3
false
true

`array::end`

Określa koniec kontrolowanej sekwencji.

reference end();

const_reference end() const;

Uwagi

Funkcje składowe zwracają iterator dostępu losowego, który wskazuje tuż poza końcem sekwencji.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display last element " 3"
    Myarray::iterator it2 = c0.end();
    std::cout << " " << *--it2;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
3

`array::fill`

Usuwa tablicę i kopiuje określone elementy do pustej tablicy.

void fill(const Type& val);

Parametry

val
Wartość elementu wstawionego do tablicy.

Uwagi

fill Zastępuje każdy element tablicy określoną wartością.

Przykład

#include <array>
#include <iostream>

int main()
{
    using namespace std;
    array<int, 2> v1 = { 1, 2 };

    cout << "v1 = ";
    for (const auto& it : v1)
    {
        std::cout << " " << it;
    }
    cout << endl;

    v1.fill(3);
    cout << "v1 = ";
    for (const auto& it : v1)
    {
        std::cout << " " << it;
    }
    cout << endl;
}

`array::front`

Uzyskuje dostęp do pierwszego elementu.

reference front();

constexpr const_reference front() const;

Uwagi

Funkcje składowe zwracają odwołanie do pierwszego elementu kontrolowanej sekwencji, który musi być niepusty.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    std::cout << " " << c0.front();
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::iterator`

Typ iteratora dla kontrolowanej sekwencji.

typedef implementation-defined iterator;

Uwagi

Typ opisuje obiekt, który może służyć jako iterator dostępu losowego dla kontrolowanej sekwencji.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> MyArray;

int main()
{
    MyArray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    std::cout << "it1:";
    for (MyArray::iterator it1 = c0.begin();
        it1 != c0.end();
        ++it1) {
        std::cout << " " << *it1;
    }
    std::cout << std::endl;

    // display first element " 0"
    MyArray::iterator it2 = c0.begin();
    std::cout << "it2:";
    std::cout << " " << *it2;
    std::cout << std::endl;

    return (0);
}

it1: 0 1 2 3

it2: 0

`array::max_size`

Liczy liczbę elementów.

constexpr size_type max_size() const;

Uwagi

Funkcja składowa zwraca wartość N.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display (maximum) size " 4"
    std::cout << " " << c0.max_size();
    std::cout << std::endl;

    return (0);
}

0 1 2 3
4

`array::operator[]`

Uzyskuje dostęp do elementu na określonej pozycji.

reference operator[](size_type off);

constexpr const_reference operator[](size_type off) const;

Parametry

off
Pozycja elementu w celu uzyskania dostępu.

Uwagi

Funkcje składowe zwracają odwołanie do elementu kontrolowanej sekwencji w pozycji off. Jeśli pozycja jest nieprawidłowa, zachowanie jest niezdefiniowane.

Dostępna jest również funkcja nieczłonkowa get umożliwiająca uzyskanie odwołania do elementu elementu array.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display odd elements " 1 3"
    std::cout << " " << c0[1];
    std::cout << " " << c0[3];
    std::cout << std::endl;

    return (0);
}

0 1 2 3
1 3

`array::operator=`

Zastępuje kontrolowaną sekwencję.

array<Value> operator=(array<Value> right);

Parametry

right
Kontener do skopiowania.

Uwagi

Operator elementu członkowskiego przypisuje każdy element right do odpowiedniego elementu kontrolowanej sekwencji, a następnie zwraca wartość *this. Służy do zastępowania kontrolowanej sekwencji kopią kontrolowanej sekwencji w pliku right.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    Myarray c1;
    c1 = c0;

    // display copied contents " 0 1 2 3"
        // display contents " 0 1 2 3"
    for (auto it : c1)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0 1 2 3

`array::pointer`

Typ wskaźnika do elementu.

typedef Ty *pointer;

Uwagi

Typ opisuje obiekt, który może służyć jako wskaźnik do elementów sekwencji.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::pointer ptr = &*c0.begin();
    std::cout << " " << *ptr;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::rbegin`

Wyznacza początek odwróconej kontrolowanej sekwencji.

reverse_iterator rbegin()noexcept;
const_reverse_iterator rbegin() const noexcept;

Uwagi

Funkcje składowe zwracają iterator odwrotny, który wskazuje tuż poza koniec kontrolowanej sekwencji. W związku z tym wyznacza początek sekwencji odwrotnej.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display last element " 3"
    Myarray::const_reverse_iterator it2 = c0.rbegin();
    std::cout << " " << *it2;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
3

`array::reference`

Typ odwołania do elementu.

typedef Ty& reference;

Uwagi

Typ opisuje obiekt, który może służyć jako odwołanie do elementu kontrolowanej sekwencji.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::reference ref = *c0.begin();
    std::cout << " " << ref;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::rend`

Wyznacza koniec odwróconej kontrolowanej sekwencji.

reverse_iterator rend()noexcept;
const_reverse_iterator rend() const noexcept;

Uwagi

Funkcje składowe zwracają iterator odwrotny, który wskazuje na pierwszy element sekwencji (lub tuż poza końcem pustej sekwencji)). W związku z tym wyznacza koniec sekwencji odwrotnej.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display first element " 0"
    Myarray::const_reverse_iterator it2 = c0.rend();
    std::cout << " " << *--it2;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0

`array::reverse_iterator`

Typ iteratora odwrotnego dla kontrolowanej sekwencji.

typedef std::reverse_iterator<iterator> reverse_iterator;

Uwagi

Typ opisuje obiekt, który może służyć jako iterator odwrotny dla kontrolowanej sekwencji.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display last element " 3"
    Myarray::reverse_iterator it2 = c0.rbegin();
    std::cout << " " << *it2;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
3

`array::size`

Liczy liczbę elementów.

constexpr size_type size() const;

Uwagi

Funkcja składowa zwraca wartość N.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display size " 4"
    std::cout << " " << c0.size();
    std::cout << std::endl;

    return (0);
}

0 1 2 3
4

`array::size_type`

Typ odległości bez znaku między dwoma elementami.

typedef std::size_t size_type;

Uwagi

Typ liczby całkowitej bez znaku opisuje obiekt, który może reprezentować długość dowolnej kontrolowanej sekwencji. Jest to synonim typu std::size_t.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display distance last-first " 4"
    Myarray::size_type diff = c0.end() - c0.begin();
    std::cout << " " << diff;
    std::cout << std::endl;

    return (0);
}

0 1 2 3
4

`array::swap`

Zamienia zawartość tej tablicy na inną tablicę.

void swap(array& right);

Parametry

right
Tablica do zamiany zawartości na.

Uwagi

Funkcja składowa zamienia kontrolowane sekwencje między *this i po prawej stronie. Wykonuje przypisania elementów i konstruktor wywołuje proporcjonalnie do N.

Dostępna jest również funkcja nieczłonkowa swap do zamiany dwóch array wystąpień.

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    Myarray c1 = { 4, 5, 6, 7 };
    c0.swap(c1);

    // display swapped contents " 4 5 6 7"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    swap(c0, c1);

    // display swapped contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    return (0);
}

0 1 2 3
4 5 6 7
0 1 2 3

`array::value_type`

Typ elementu.

typedef Ty value_type;

Uwagi

Typ jest synonimem parametru Tyszablonu .

Przykład

#include <array>
#include <iostream>

typedef std::array<int, 4> Myarray;
int main()
{
    Myarray c0 = { 0, 1, 2, 3 };

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        std::cout << " " << it;
    }
    std::cout << std::endl;

    // display contents " 0 1 2 3"
    for (const auto& it : c0)
    {
        Myarray::value_type val = it;
        std::cout << " " << val;
    }
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0 1 2 3

Zobacz też

<array>

array Klasa (Standardowa biblioteka C++)

Składnia

Parametry

Członkowie

Uwagi

Wymagania

array::array

Parametry

Uwagi

Przykład

array::assign

array::at

Parametry

Uwagi

Przykład

array::back

Uwagi

Przykład

array::begin

Uwagi

Przykład

array::cbegin

Wartość zwracana

Uwagi

array::cend

Wartość zwracana

Uwagi

array::const_iterator

Uwagi

Przykład

array::const_pointer

Uwagi

Przykład

array::const_reference

Uwagi

Przykład

array::const_reverse_iterator

Uwagi

Przykład

array::crbegin

Wartość zwracana

Uwagi

Przykład

array::crend

Wartość zwracana

Uwagi

Przykład

array::data

Uwagi

Przykład

array::difference_type

Uwagi

Przykład

array::empty

Uwagi

Przykład

array::end

Uwagi

Przykład

array::fill

Parametry

Uwagi

Przykład

array::front

Uwagi

Przykład

array::iterator

Uwagi

Przykład

array::max_size

Uwagi

Przykład

array::operator[]

Parametry

Uwagi

Przykład

array::operator=

Parametry

Uwagi

Przykład

`array` Klasa (Standardowa biblioteka C++)

`array::array`

`array::assign`

`array::at`

`array::back`

`array::begin`

`array::cbegin`

`array::cend`

`array::const_iterator`

`array::const_pointer`

`array::const_reference`

`array::const_reverse_iterator`

`array::crbegin`

`array::crend`

`array::data`

`array::difference_type`

`array::empty`

`array::end`

`array::fill`

`array::front`

`array::iterator`

`array::max_size`

`array::operator[]`

`array::operator=`

`array::pointer`

`array::rbegin`

`array::reference`

`array::rend`

`array::reverse_iterator`

`array::size`

`array::size_type`

`array::swap`

`array::value_type`