La classe array, définie dans l'en-tête <array>, est une collection d'éléments du même type stockés dans des emplacements de mémoire contigus. C'est un conteneur de séquence à taille fixe : le nombre d'éléments est déterminé à la compilation et ne peut pas changer à l'exécution.
Quand utiliser array ? En pratique,
array est peu utilisé car la plupart des scénarios réels nécessitent des conteneurs dynamiques (vector, deque…). Il reste utile lorsque la taille est connue et invariante, et que l'on souhaite les avantages des méthodes STL sur un tableau C classique.Syntaxe et construction
array<type_objets, taille> nomTab; // Tableau vide (valeurs indéfinies)
array<type_objets, n> nomTab = {val1, val2, ..., valn}; // Tableau initialiséFonctions membres
Accès aux éléments
nomTab.at(i); // Élément à l'indice i — lève out_of_range si i hors bornes
nomTab[i]; // Élément à l'indice i — sans vérification des bornes
nomTab.front(); // Premier élément
nomTab.back(); // Dernier élémentat() vs [] Préférer
at() en développement : il lève une exception std::out_of_range si l'indice dépasse la taille du tableau, contrairement à [] qui produit un comportement indéfini.Remplissage et échange
nomTab.fill(valeur); // Assigne valeur à tous les éléments
nomTab.swap(autreTab); // Échange le contenu avec autreTab (même type et taille)Contrainte de swap() Les deux tableaux échangés doivent avoir le même type et la même taille. Si l'échange d'un élément lève une exception,
swap() la propage.Taille
nomTab.size(); // Taille du tableau (= taille maximale pour array)
nomTab.max_size(); // Identique à size() pour un conteneur statique
nomTab.empty(); // true si taille == 0Itérateurs
nomTab.begin(); // Itérateur vers le premier élément
nomTab.end(); // Itérateur vers la position après le dernier élément| Fonction | Description | Vérification bornes |
|---|---|---|
at(i) | Accès par indice | Oui — lève out_of_range |
operator[] | Accès par indice | Non |
front() | Premier élément | Non |
back() | Dernier élément | Non |
fill(v) | Remplir tout le tableau avec v | — |
swap(t) | Échanger avec un autre tableau | Même type et taille requis |
size() | Nombre d'éléments | — |
empty() | Teste si vide | — |
begin() / end() | Itérateurs de début / fin | — |
Exemple complet
#include <iostream>
#include <array>
using namespace std;
int main() {
array<int, 5> tab = {1, 5, 8, 9, 10};
array<int, 8> tab2;
array<int, 5> tab3 = {20, 30, 50, 40, 60};
// Affichage avec at()
cout << "Contenu de tab : \n";
for (int i = 0; i < tab.size(); i++)
cout << tab.at(i) << " ";
cout << "\n";
cout << "Taille : " << tab.size() << "\n";
cout << "Taille max : " << tab.max_size() << "\n";
cout << "Premier : " << tab.front() << "\n";
cout << "Dernier : " << tab.back() << "\n\n";
// fill()
tab2.fill(7);
cout << "tab2 après fill(7) : \n";
for (int i = 0; i < tab2.size(); i++)
cout << tab2[i] << " ";
cout << "\n\n";
// swap()
tab.swap(tab3);
cout << "tab après swap avec tab3 : \n";
for (int i = 0; i < tab.size(); i++)
cout << tab.at(i) << " ";
cout << "\n";
cout << "tab3 après swap : \n";
for (int i = 0; i < tab3.size(); i++)
cout << tab3.at(i) << " ";
cout << "\n\n";
// Parcours avec itérateur
cout << "tab via itérateur : \n";
array<int, 5>::iterator it = tab.begin();
while (it < tab.end()) {
cout << *it << " ";
it = next(it);
}
cout << "\n";
return 0;
}Sortie
Contenu de tab : 1 5 8 9 10 Taille : 5 Taille max : 5 Premier : 1 Dernier : 10 tab2 après fill(7) : 7 7 7 7 7 7 7 7 tab après swap avec tab3 : 20 30 50 40 60 tab3 après swap : 1 5 8 9 10 tab via itérateur : 20 30 50 40 60
Discussion (0)
Soyez le premier à laisser un commentaire !
Laisser un commentaire
Votre commentaire sera visible après modération.