`array` Třída (standardní knihovna jazyka C++)

Článek
10/12/2023

Popisuje objekt, který řídí posloupnost délky N prvků typu Ty. Sekvence je uložena jako pole Ty, obsažené v objektu array<Ty, N> .

Syntaxe

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

Parametry

Ty
Typ prvku

N
Počet prvků.

Členové

Definice typu	Popis
`const_iterator`	Typ konstantního iterátoru řízené sekvence
`const_pointer`	Typ konstantního ukazatele na prvek
`const_reference`	Typ konstantního odkazu na prvek
`const_reverse_iterator`	Typ konstantního zpětného iterátoru pro řízenou sekvenci.
`difference_type`	Typ vzdálenosti se znaménkem mezi dvěma prvky
`iterator`	Typ iterátoru řízené sekvence
`pointer`	Typ ukazatele na prvek
`reference`	Typ odkazu na prvek
`reverse_iterator`	Typ zpětné iterátoru pro řízenou sekvenci.
`size_type`	Typ vzdálenosti bez znaménka mezi dvěma prvky
`value_type`	Typ prvku

Členská funkce	Popis
`array`	Vytvoří objekt pole.
`assign`	(zastaralé. Použít `fill`.) Nahradí všechny prvky.
`at`	Přistupuje k prvku na zadané pozici.
`back`	Přistupuje k poslednímu prvku.
`begin`	Určuje začátek řízené sekvence.
`cbegin`	Vrátí iterátor const náhodného přístupu k prvnímu prvku v poli.
`cend`	Vrátí iterátor const s náhodným přístupem, který odkazuje těsně za koncem pole.
`crbegin`	Vrátí iterátor const na první prvek v obráceném poli.
`crend`	Vrátí konstantní iterátor na konec obráceného pole.
`data`	Získá adresu prvního prvku.
`empty`	Testuje, zda jsou přítomny prvky.
`end`	Určuje konec řízené sekvence.
`fill`	Nahradí všechny prvky zadanou hodnotou.
`front`	Přistupuje k prvnímu prvku.
`max_size`	Spočítá počet prvků.
`rbegin`	Určuje začátek obrácené řízené sekvence.
`rend`	Určuje konec obrácené řízené sekvence.
`size`	Spočítá počet prvků.
`swap`	Zamění obsah dvou kontejnerů.

Operátor	Popis
`array::operator=`	Nahradí řízenou sekvenci.
`array::operator[]`	Přistupuje k prvku na zadané pozici.

Poznámky

Typ má výchozí konstruktor array() a výchozí operátor operator=přiřazení a splňuje požadavky pro objekt aggregate. Objekty typu array<Ty, N> lze inicializovat pomocí agregační inicializátoru. Příklad:

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

vytvoří objekt ai , který obsahuje čtyři celočíselné hodnoty, inicializuje první tři prvky na hodnoty 1, 2 a 3 v uvedeném pořadí a inicializuje čtvrtý prvek na 0.

Požadavky

Záhlaví: <array>

Obor názvů: std

`array::array`

Vytvoří objekt pole.

array();

array(const array& right);

Parametry

right
Objekt nebo oblast, které chcete vložit.

Poznámky

Výchozí konstruktor array() ponechá řízenou sekvenci neinicializovanou (nebo výchozí inicializovanou). Použijete ho k určení neinicializované řízené sekvence.

Konstruktor array(const array& right) kopírování inicializuje řízenou sekvenci [vpravo.begin(), vpravo.end()). Slouží k určení počáteční řízené sekvence, která je kopií sekvence řízené objektem rightpole .

Příklad

#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`

Zastaralé v jazyce C++11 nahrazeno znakem fill. Nahradí všechny prvky.

`array::at`

Přistupuje k prvku na zadané pozici.

reference at(size_type off);

constexpr const_reference at(size_type off) const;

Parametry

off
Pozice prvku pro přístup.

Poznámky

Členské funkce vrací odkaz na prvek řízené sekvence na pozici off. Pokud je tato pozice neplatná, funkce vyvolá objekt třídy out_of_range.

Příklad

#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`

Přistupuje k poslednímu prvku.

reference back();

constexpr const_reference back() const;

Poznámky

Členské funkce vrací odkaz na poslední prvek řízené sekvence, která musí být neprázdná.

Příklad

#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`

Určuje začátek řízené sekvence.

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

Poznámky

Členské funkce vrací iterátor náhodného přístupu, který odkazuje na první prvek sekvence (nebo těsně za koncem prázdné sekvence).

Příklad

#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 Vrátí iterátor, který řeší první prvek v oblasti.

const_iterator cbegin() const noexcept;

Návratová hodnota

const Iterátor náhodného přístupu, který odkazuje na první prvek oblasti nebo umístění těsně za koncem prázdné oblasti (pro prázdnou oblast, cbegin() == cend()).

Poznámky

Při návratové cbeginhodnotě nelze upravit prvky v oblasti.

Tuto členská funkce můžete použít místo begin() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje begin() a cbegin().

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

// i2 is Container<T>::const_iterator

`array::cend`

const Vrátí iterátor, který řeší umístění za posledním prvkem v rozsahu.

const_iterator cend() const noexcept;

Návratová hodnota

Iterátor pro náhodný přístup, který ukazuje přesně za konec rozsahu.

Poznámky

cend slouží k otestování, zda iterátor předal konec jeho rozsahu.

Tuto členská funkce můžete použít místo end() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje end() a cend().

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

// i2 is Container<T>::const_iterator

Hodnota vrácená cend by neměla být dereferenced.

`array::const_iterator`

Typ konstantního iterátoru řízené sekvence

typedef implementation-defined const_iterator;

Poznámky

Typ popisuje objekt, který může sloužit jako konstantní iterátor náhodného přístupu pro řízenou sekvenci.

Příklad

#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 konstantního ukazatele na prvek

typedef const Ty *const_pointer;

Poznámky

Typ popisuje objekt, který může sloužit jako konstantní ukazatel na prvky sekvence.

Příklad

#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 konstantního odkazu na prvek

typedef const Ty& const_reference;

Poznámky

Typ popisuje objekt, který může sloužit jako konstantní odkaz na prvek řízené sekvence.

Příklad

#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 konstantního zpětného iterátoru pro řízenou sekvenci.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Poznámky

Typ popisuje objekt, který může sloužit jako konstantní reverzní iterátor řízené sekvence.

Příklad

#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`

Vrátí iterátor const na první prvek v obráceném poli.

const_reverse_iterator crbegin() const;

Návratová hodnota

Const reverse random-access iterator adresuje první prvek v obráceném poli nebo adresování toho, co bylo posledním prvkem v nereverzním poli.

Poznámky

S návratovou crbeginhodnotou objektu pole nelze změnit.

Příklad

#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`

Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v obráceném poli.

const_reverse_iterator crend() const noexcept;

Návratová hodnota

Const reverse random-access iterator, který řeší umístění úspěšné poslední prvek v obráceném poli (umístění, které předchází prvnímu prvku v nereverzním poli).

Poznámky

crend se používá s obráceným polem stejně, jako array::cend se používá s polem.

S návratovou crend hodnotou (vhodnou dekrementací) nelze upravit maticový objekt.

crend lze použít k otestování, zda reverzní iterátor dosáhl konce pole.

Hodnota vrácená crend by neměla být dereferenced.

Příklad

#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`

Získá adresu prvního prvku.

Ty *data();

const Ty *data() const;

Poznámky

Členské funkce vrátí adresu prvního prvku v řízené sekvenci.

Příklad

#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 vzdálenosti se znaménkem mezi dvěma prvky

typedef std::ptrdiff_t difference_type;

Poznámky

Typ signed integer popisuje objekt, který může představovat rozdíl mezi adresami libovolných dvou prvků v řízené sekvenci. Je to synonymum pro typ std::ptrdiff_t.

Příklad

#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`

Zkouší, zda nejsou přítomny žádné prvky.

constexpr bool empty() const;

Poznámky

Členová funkce vrátí hodnotu true pouze v případě, že N == 0.

Příklad

#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`

Určuje konec řízené sekvence.

reference end();

const_reference end() const;

Poznámky

Členské funkce vrací iterátor náhodného přístupu, který odkazuje těsně za koncem sekvence.

Příklad

#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`

Vymaže matici a zkopíruje zadané prvky do prázdného pole.

void fill(const Type& val);

Parametry

val
Hodnota prvku, který se vkládá do pole.

Poznámky

fill nahradí každý prvek pole zadanou hodnotou.

Příklad

#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`

Přistupuje k prvnímu prvku.

reference front();

constexpr const_reference front() const;

Poznámky

Členské funkce vrací odkaz na první prvek řízené sekvence, která musí být neprázdná.

Příklad

#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 iterátoru řízené sekvence

typedef implementation-defined iterator;

Poznámky

Typ popisuje objekt, který může sloužit jako iterátor náhodného přístupu pro řízenou sekvenci.

Příklad

#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`

Spočítá počet prvků.

constexpr size_type max_size() const;

Poznámky

Členová funkce vrátí N.

Příklad

#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[]`

Přistupuje k prvku na zadané pozici.

reference operator[](size_type off);

constexpr const_reference operator[](size_type off) const;

Parametry

off
Pozice prvku pro přístup.

Poznámky

Členské funkce vrací odkaz na prvek řízené sekvence na pozici off. Pokud je tato pozice neplatná, chování není definováno.

K dispozici je také nečlenská get funkce pro získání odkazu na prvek objektu array.

Příklad

#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=`

Nahradí řízenou sekvenci.

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

Parametry

right
Kontejner, který se má zkopírovat.

Poznámky

Operátor člena přiřadí každý prvek right odpovídající prvek řízené sekvence a pak vrátí *this. Slouží k nahrazení řízené sekvence kopií řízené sekvence v right.

Příklad

#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 ukazatele na prvek

typedef Ty *pointer;

Poznámky

Typ popisuje objekt, který může sloužit jako ukazatel na prvky sekvence.

Příklad

#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`

Určuje začátek obrácené řízené sekvence.

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

Poznámky

Členské funkce vrací reverzní iterátor, který odkazuje těsně za koncem řízené sekvence. Proto označuje začátek zpětné sekvence.

Příklad

#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 odkazu na prvek

typedef Ty& reference;

Poznámky

Typ popisuje objekt, který může sloužit jako odkaz na prvek řízené sekvence.

Příklad

#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`

Určuje konec obrácené řízené sekvence.

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

Poznámky

Členské funkce vrátí reverzní iterátor, který odkazuje na první prvek sekvence (nebo těsně za koncem prázdné sekvence)). Proto určuje konec zpětné sekvence.

Příklad

#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 zpětné iterátoru pro řízenou sekvenci.

typedef std::reverse_iterator<iterator> reverse_iterator;

Poznámky

Typ popisuje objekt, který může sloužit jako reverzní iterátor řízené sekvence.

Příklad

#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`

Spočítá počet prvků.

constexpr size_type size() const;

Poznámky

Členová funkce vrátí N.

Příklad

#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 vzdálenosti bez znaménka mezi dvěma prvky

typedef std::size_t size_type;

Poznámky

Typ celého čísla bez znaménka popisuje objekt, který může představovat délku libovolné řízené sekvence. Je to synonymum pro typ std::size_t.

Příklad

#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`

Prohodí obsah tohoto pole s jiným polem.

void swap(array& right);

Parametry

right
Pole pro prohození obsahu.

Poznámky

Členová funkce prohodí řízené sekvence mezi *this a vpravo. Provádí přiřazení prvků a konstruktor volá proporcionální .N

K dispozici je také nečlenská swap funkce pro prohození dvou array instancí.

Příklad

#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 prvku

typedef Ty value_type;

Poznámky

Typ je synonymem pro parametr Tyšablony .

Příklad

#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

Viz také

<array>

Sdílet prostřednictvím

array Třída (standardní knihovna jazyka C++)

Syntaxe

Parametry

Členové

Poznámky

Požadavky

array::array

Parametry

Poznámky

Příklad

array::assign

array::at

Parametry

Poznámky

Příklad

array::back

Poznámky

Příklad

array::begin

Poznámky

Příklad

array::cbegin

Návratová hodnota

Poznámky

array::cend

Návratová hodnota

Poznámky

array::const_iterator

Poznámky

Příklad

array::const_pointer

Poznámky

Příklad

array::const_reference

Poznámky

Příklad

array::const_reverse_iterator

Poznámky

Příklad

array::crbegin

Návratová hodnota

Poznámky

Příklad

array::crend

Návratová hodnota

Poznámky

Příklad

array::data

Poznámky

Příklad

array::difference_type

Poznámky

Příklad

array::empty

Poznámky

Příklad

array::end

Poznámky

Příklad

array::fill

Parametry

Poznámky

Příklad

array::front

Poznámky

Příklad

array::iterator

Poznámky

Příklad

array::max_size

Poznámky

Příklad

array::operator[]

Parametry

Poznámky

Příklad

array::operator=

Parametry

Poznámky

`array` Třída (standardní knihovna jazyka 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`