Le template est le suivant :

template < class T, size_t N > class array;

La classe array ne fournit ni constructeur ni destructeur, mais des méthodes pour l'utilisation d'un tableau statique. Le type et le nombre des éléments sont déterminés à la déclaration dans le template :

array<int 1> tab ; // un tableau de 10 int
array<double, 50> d ; // un tableau de 50 double

operator[ ] : opérateur crochet pour l'accès immédiat à chaque élément selon son indice, comme pour tous les tableaux classiques. L'accès n'est pas contrôlé et il y a possibilité de débordement si l'indice est hors tableau.

array<int,10> a;
    for (int i = 0; i < 10; i++) {
        a[i] = i ;
        cout << a[i] << ' '; // 0 1 2 3 4 5 6 7 8 9
    }
    cout << endl;

at() : méthode pour un accès contrôlé à un élément du tableau selon son indice donné en paramètre. En cas de débordement, il est possible de récupérer une erreur de type exception.

array<int,10> a;
    for (int i = 0; i < 10; i++) {
        a.at(i) = i ;
        cout << a.at(i) << ' '; // 0 1 2 3 4 5 6 7 8 9
    }
    cout << endl;

back() : retourne une référence sur le dernier.

front() : retourne une référence sur le premier élément :

array<int,5> a = {1,2,3,4,5};
    cout << "front : " << a.front() << endl; // 1
    cout << "back : " << a.back() << endl; // 5
    a.back() += 50;
    a.front()+= 50 ;
    for ( int& i : a )
        cout << i << ' '; // 51 2 3 4 55
    cout << endl;

data() : retourne un pointeur sur le premier élément du tableau interne au conteneur. Un tableau array est continu en mémoire et il est possible de le parcourir avec un pointeur.

array<int, 5> a = { 10, 20, 30, 40, 50 };
    int *ptr;
    ptr = a.data();
    for (int i = 0; i < a.size(); i++)
        cout << ptr[i] << ' '; // 10 20 30 40 50
    cout << endl;
    for (int i = 0; i < a.size(); i++){
        ptr[i] = rand() % 10;
        cout << ptr[i] << ' '; // valeurs entre 0 et 9 compris
    }
    cout<<endl;

Itérateurs

Le parcours d'un array peut aussi s'effectuer en utilisant des itérateurs (pointeurs) plutôt que le système d'indice. Pour ce faire la classe array contient les méthodes suivantes :

begin() : retourne un itérateur iterator qui pointe sur le premier élément ;

end() : retourne un itérateur iterator qui pointe sur l'élément suivant le dernier (balise de fin, par exemple NULL) ;

rbegin() : retourne un itérateur reverse_iterator qui pointe sur le premier élément de la séquence inverse (le dernier) ;

rend() : retourne un itérateur reverse_iterator qui pointe sur l'élément suivant le dernier dans l'ordre inverse (balise de fin, par exemple NULL) ;

cbegin() : retourne un itérateur const_iterator qui pointe sur le premier élément. L'élément pointé n'est alors accessible qu'en lecture et non en écriture. Il ne peut être modifié ;

cend() : retourne un itérateur const_iterator qui pointe sur ce qui suit le dernier élément (balise de fin, par exemple NULL). L'élément pointé n'est alors accessible qu'en lecture et non en écriture. Il ne peut être modifié ;

crbegin() : retourne un itérateur const_reverse_iterator qui pointe sur le premier élément de la séquence inverse (le dernier). L'élément pointé n'est accessible qu'en lecture et ne peut pas être modifié ;

crend() : retourne un itérateur const_reverse_iterator qui pointe sur la fin de la séquence inverse, avant le premier élément (balise de fin sens inverse, par exemple NULL). L'élément pointé n'est accessible qu'en lecture et ne peut pas être modifié.

array<int,5> a = { 10,20,30,40,50 };
    // begin-end
    for (auto it = a.begin(); it != a.end(); ++it){
        (*it)++;
        cout << *it << ' '; // 11 21 31 41 51
    }
    cout << endl;
    // rbegin-rend
    for (auto it = a.rbegin(); it != a.rend(); ++it){
        (*it)++;
        cout << *it << ' '; // 52 42 32 22 12
    }
    cout << endl;
    // cbegin-cend : pas de modification possible
    for (auto it = a.cbegin(); it != a.cend(); ++it){
        //(*it)++; // erreur *it doit être modifiable
        cout << *it << ' '; // 12 22 32 42 52
    }
    cout << endl;
    // crbegin-crend
    for (auto it = a.crbegin(); it != a.crend(); ++it){
        //(*it)++; // erreur *it doit être modifiable
        cout << *it << ' '; // 52 42 32 22 12
    }
    cout << endl;

fill() : affecte la même valeur à tous les éléments du tableau.

swap() : échange le contenu de deux tableaux de même type d'éléments et de même taille.

array<int, 5> a ;
    array<int, 5> b ;
    // fill
    a.fill(5);
    for (int& x : a) {
        cout << x << ' '; // 5 5 5 5 5
    }
    cout<<endl;
    b.fill(1);
    for (int& x : b) {
        cout << x << ' '; // 1 1 1 1 1
    }
    cout << endl;
    // swap
    a.swap(b);
    for (int& x : a) {
        cout << x << ' '; // 1 1 1 1 1
    }
    cout << endl;
    for (int& x : b) {
        cout << x << ' '; // 5 5 5 5 5
    }
    cout << endl;

max_size() : retourne le nombre maximum d'éléments que peut contenir le tableau, c’est-à-dire la taille demandée pour le tableau dans le template de sa déclaration.

size() : donne le nombre d'éléments dans le tableau, équivaut à max_size().

empty() : retourne un booléen qui indique vrai ou faux selon que le tableau est vide (taille de 0) ou pas.

array<int, 5> a;
    cout << "max_size:"<< a.max_size() << endl; // 5
    cout << "size :" << a.size() << endl; // 5
    cout << "empty :" <<(a.empty()?"oui":"non")<< endl;// non

Les opérateurs de comparaison ==, !=, <, <=, >, >= sont supportés. Pour les notions d'infériorité et de supériorité, c'est un ordre lexicographique qui est pris en compte.