array Classe (libreria standard C++)

Descrive un oggetto che controlla una sequenza di elementi di tipo Ty lunghezza N. La sequenza viene archiviata come matrice di Ty, contenuta nell'oggetto array<Ty, N>.

Sintassi

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

Parametri

Ty
Tipo di un elemento.

N
Numero di elementi.

Membri

Definizione del tipo Descrizione
const_iterator Tipo di un iteratore costante per la sequenza controllata.
const_pointer Tipo di un puntatore costante a un elemento.
const_reference Tipo di un riferimento costante a un elemento.
const_reverse_iterator Tipo di un iteratore inverso costante per la sequenza controllata.
difference_type Tipo di una distanza Signed tra due elementi.
iterator Tipo di un iteratore per la sequenza controllata.
pointer Tipo di un puntatore a un elemento.
reference Tipo di un riferimento a un elemento.
reverse_iterator Tipo di un iteratore inverso della sequenza controllata.
size_type Tipo di una distanza Unsigned tra due elementi.
value_type Tipo di un elemento.
Funzione membro Descrizione
array Costruisce un oggetto di matrice.
assign (Obsoleto. Usare fill.) Sostituisce tutti gli elementi.
at Accede a un elemento in una posizione specificata.
back Accede all'ultimo elemento.
begin Indica l'inizio della sequenza controllata.
cbegin Restituisce un iteratore const ad accesso casuale al primo elemento nella matrice.
cend Restituisce un iteratore const ad accesso casuale che punta appena oltre la fine della matrice.
crbegin Restituisce un iteratore const che punta al primo elemento di una matrice invertita.
crend Restituisce un iteratore const alla fine di una matrice invertita.
data Ottiene l'indirizzo del primo elemento.
empty Verifica se sono presenti elementi.
end Designa la fine della sequenza controllata.
fill Sostituisce tutti gli elementi con un valore specificato.
front Accede al primo elemento.
max_size Conta il numero di elementi.
rbegin Indica l'inizio della sequenza controllata inversa.
rend Indica la fine della sequenza controllata inversa.
size Conta il numero di elementi.
swap Scambia il contenuto di due contenitori.
Operatore Descrizione
array::operator= Sostituisce la sequenza controllata.
array::operator[] Accede a un elemento in una posizione specificata.

Osservazioni:

Il tipo ha un costruttore predefinito array() e un operatore di assegnazione predefinito operator= e soddisfa i requisiti per un aggregate. Pertanto, gli oggetti di tipo array<Ty, N> possono essere inizializzati usando un inizializzatore di aggregazione. ad esempio:

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

crea l'oggetto ai contenente quattro valori interi, inizializza i primi tre elementi sui valori 1, 2 e 3 rispettivamente e inizializza il quarto elemento su 0.

Requisiti

Intestazione: <array>

Spazio dei nomi: std

array::array

Costruisce un oggetto di matrice.

array();

array(const array& right);

Parametri

right
Oggetto o un intervallo da inserire.

Osservazioni:

Il costruttore predefinito array() lascia la sequenza controllata non inizializzata (o inizializzata per impostazione predefinita). Viene usato per specificare una sequenza controllata non inizializzata.

Il costruttore di copia array(const array& right) inizializza la sequenza controllata con la sequenza [right.begin(), right.end()). Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dall'oggetto rightmatrice .

Esempio

#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

Obsoleto in C++11, sostituito da fill. Sostituisce tutti gli elementi.

array::at

Accede a un elemento in una posizione specificata.

reference at(size_type off);

constexpr const_reference at(size_type off) const;

Parametri

off
Posizione dell'elemento a cui accedere.

Osservazioni:

Le funzioni membro restituiscono un riferimento all'elemento della sequenza controllata nella posizione off. Se tale posizione non è valida, la funzione genera un oggetto della classe out_of_range.

Esempio

#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

Accede all'ultimo elemento.

reference back();

constexpr const_reference back() const;

Osservazioni:

Le funzioni membro restituiscono un riferimento all'ultimo elemento della sequenza controllata, che non deve essere vuoto.

Esempio

#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

Indica l'inizio della sequenza controllata.

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

Osservazioni:

Le funzioni membro restituiscono un iteratore di accesso casuale che punta al primo elemento della sequenza (o appena oltre la fine di una sequenza vuota).

Esempio

#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

Restituisce un iteratore const che punta al primo elemento dell'intervallo.

const_iterator cbegin() const noexcept;

Valore restituito

Iteratore ad accesso casuale const che punta al primo elemento dell'intervallo o alla posizione oltre la fine di un intervallo vuoto (per un intervallo vuoto, cbegin() == cend()).

Osservazioni:

Con il valore restituito di cbegin, gli elementi nell'intervallo non possono essere modificati.

È possibile usare questa funzione membro anziché la funzione membro begin() per garantire che il valore restituito sia const_iterator. In genere, viene usato con la parola chiave di deduzione del auto tipo, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta begin() e cbegin().

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

// i2 is Container<T>::const_iterator

array::cend

Restituisce un iteratore const che punta alla posizione oltre l'ultimo elemento di un intervallo.

const_iterator cend() const noexcept;

Valore restituito

Iteratore ad accesso casuale che punta oltre la fine dell'intervallo.

Osservazioni:

cend viene utilizzato per verificare se un iteratore ha superato la fine del relativo intervallo.

È possibile usare questa funzione membro anziché la funzione membro end() per garantire che il valore restituito sia const_iterator. In genere, viene usato con la parola chiave di deduzione del auto tipo, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta end() e cend().

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

// i2 is Container<T>::const_iterator

Il valore restituito da cend non deve essere dereferenziato.

array::const_iterator

Tipo di un iteratore costante per la sequenza controllata.

typedef implementation-defined const_iterator;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come iteratore ad accesso casuale costante per la sequenza controllata.

Esempio

#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

Tipo di un puntatore costante a un elemento.

typedef const Ty *const_pointer;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come puntatore costante a elementi della sequenza.

Esempio

#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

Tipo di un riferimento costante a un elemento.

typedef const Ty& const_reference;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come riferimento costante a un elemento della sequenza controllata.

Esempio

#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

Tipo di un iteratore inverso costante per la sequenza controllata.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come iteratore inverso costante per la sequenza controllata.

Esempio

#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

Restituisce un iteratore const che punta al primo elemento di una matrice invertita.

const_reverse_iterator crbegin() const;

Valore restituito

Iteratore inverso const ad accesso casuale che punta al primo elemento di una matrice invertita (o che punta a quello che era stato l'ultimo elemento nella matrice non invertita).

Osservazioni:

Con il valore restituito di crbegin, l'oggetto matrice non può essere modificato.

Esempio

#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

Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento di una matrice invertita.

const_reverse_iterator crend() const noexcept;

Valore restituito

Iteratore ad accesso casuale const inverso che punta alla posizione successiva all'ultimo elemento in una matrice invertita, ossia la posizione che precedeva il primo elemento nella matrice non invertita.

Osservazioni:

crend viene usato con una matrice invertita esattamente come array::cend viene usata con una matrice.

Con il valore restituito di crend (decrementato in modo adeguato), l'oggetto matrice non può essere modificato.

crend può essere usato per verificare se un iteratore inverso ha raggiunto la fine della relativa matrice.

Il valore restituito da crend non deve essere dereferenziato.

Esempio

#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

Ottiene l'indirizzo del primo elemento.

Ty *data();

const Ty *data() const;

Osservazioni:

Le funzioni membro restituiscono l'indirizzo del primo elemento nella sequenza controllata.

Esempio

#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

Tipo di una distanza Signed tra due elementi.

typedef std::ptrdiff_t difference_type;

Osservazioni:

Il tipo di valore integer con segno descrive un oggetto che può rappresentare la differenza tra gli indirizzi di due elementi qualsiasi della sequenza controllata. Si tratta di un sinonimo del tipo std::ptrdiff_t.

Esempio

#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

Verifica se sono presenti o meno degli elementi.

constexpr bool empty() const;

Osservazioni:

La funzione membro restituisce true solo se N == 0

Esempio

#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

Designa la fine della sequenza controllata.

reference end();

const_reference end() const;

Osservazioni:

Le funzioni membro restituiscono un iteratore di accesso casuale che punta appena oltre la fine della sequenza.

Esempio

#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

Cancella una matrice e copia gli elementi specificati nella matrice vuota.

void fill(const Type& val);

Parametri

val
Valore dell'elemento inserito nella matrice.

Osservazioni:

fill sostituisce ogni elemento della matrice con il valore specificato.

Esempio

#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

Accede al primo elemento.

reference front();

constexpr const_reference front() const;

Osservazioni:

Le funzioni membro restituiscono un riferimento al primo elemento della sequenza controllata, che non deve essere vuoto.

Esempio

#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

Tipo di un iteratore per la sequenza controllata.

typedef implementation-defined iterator;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come iteratore ad accesso casuale per la sequenza controllata.

Esempio

#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

Conta il numero di elementi.

constexpr size_type max_size() const;

Osservazioni:

La funzione membro restituisceN.

Esempio

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

Accede a un elemento in una posizione specificata.

reference operator[](size_type off);

constexpr const_reference operator[](size_type off) const;

Parametri

off
Posizione dell'elemento a cui accedere.

Osservazioni:

Le funzioni membro restituiscono un riferimento all'elemento della sequenza controllata nella posizione off. Se tale posizione non è valida, il comportamento è indefinito.

È disponibile anche una funzione non membro get per ottenere un riferimento a un elemento di un oggetto array.

Esempio

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

Sostituisce la sequenza controllata.

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

Parametri

right
Contenitore da copiare.

Osservazioni:

L'operatore membro assegna ogni elemento di right all'elemento corrispondente della sequenza controllata, quindi restituisce *this. Viene usato per sostituire la sequenza controllata con una copia della sequenza controllata in right.

Esempio

#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

Tipo di un puntatore a un elemento.

typedef Ty *pointer;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come puntatore a elementi della sequenza.

Esempio

#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

Indica l'inizio della sequenza controllata inversa.

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

Osservazioni:

Le funzioni membro restituiscono un iteratore inverso che punta poco oltre la fine della sequenza controllata. Di conseguenza, indica l'inizio della sequenza inversa.

Esempio

#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

Tipo di un riferimento a un elemento.

typedef Ty& reference;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come riferimento a un elemento della sequenza controllata.

Esempio

#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

Indica la fine della sequenza controllata inversa.

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

Osservazioni:

Le funzioni membro restituiscono un iteratore inverso che punta al primo elemento della sequenza (o oltre la fine di una sequenza vuota). Di conseguenza, indica la fine della sequenza inversa.

Esempio

#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

Tipo di un iteratore inverso della sequenza controllata.

typedef std::reverse_iterator<iterator> reverse_iterator;

Osservazioni:

Il tipo descrive un oggetto che può essere usato come iteratore inverso per la sequenza controllata.

Esempio

#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

Conta il numero di elementi.

constexpr size_type size() const;

Osservazioni:

La funzione membro restituisceN.

Esempio

#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

Tipo di una distanza Unsigned tra due elementi.

typedef std::size_t size_type;

Osservazioni:

Il tipo Unsigned Integer descrive un oggetto che può rappresentare la lunghezza di una sequenza controllata. Si tratta di un sinonimo del tipo std::size_t.

Esempio

#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

Scambia il contenuto di questa matrice con un'altra matrice.

void swap(array& right);

Parametri

right
Matrice con cui scambiare il contenuto.

Osservazioni:

La funzione membro scambia le sequenze controllate tra *this e destra. Esegue assegnazioni di elementi e chiamate di costruttore proporzionali a N.

È disponibile anche una funzione non membro swap per lo scambio di due array istanze.

Esempio

#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

Tipo di un elemento.

typedef Ty value_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Ty.

Esempio

#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

Vedi anche

<array>