Conteneurs séquentiels

Auteur

Frédéric Drouillon

N'hésitez pas à donner vos avis par rapport à ce tutoriel : Commentez

- Titre : Conteneurs séquentiels

- Auteur : Frédéric Drouillon

- Parution : 11 décembre 2014

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2014 Frédéric Drouillon. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Conteneurs séquentiels

- I-A. La classe array

- I-A-1. Template, constructeurs, destructeurs

- I-A-2. Accès éléments, itérateurs

- I-A-3. Opérations de liste

- I-A-4. Taille et capacité

- I-A-5. Comparaisons

- II. Conclusion

- III. Remerciements

I - Conteneurs séquentiels

I-A - La classe array

Cette classe donne des méthodes pour la gestion d'un tableau à taille fixe. Pour l'utiliser,

il faut inclure la Bibliothèque <array> :

#include <array>

I-A-1 - Template, constructeurs, destructeurs

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

I-A-2 - Accès éléments, itérateurs

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;

I-A-3 - Opérations de liste

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;

I-A-4 - Taille et capacité

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

I-A-5 - Comparaisons

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.

c++

0

1

array<int,5> a = {1,2,3,4,5};
array<int,5> b = {2,2,3,4,5};
cout << (a == b ? « oui » : « non ») << '\n'; // non
cout << (a != b ? « oui » : « non ») << '\n'; // oui
cout << (a < b ? « oui » : « non ») << '\n'; // oui
cout << (a <= b ? « oui » : « non ») << '\n'; // oui
cout << (a > b ? « oui » : « non ») << '\n'; // non
cout << (a >= b ? « oui » : « non ») << '\n'; // non

II - Conclusion

Ce tutoriel est extrait du livre Du C au C++ - De la programmation procédurale à l'objet de Frédéric Drouillon.

Commandez Du C au C++ - De la programmation procédurale à l'objet sur Amazon

III - Remerciements

Je tiens sincèrement à remercier Vincent VIALE pour la mise au gabarit et Claude LELOUP pour la relecture orthographique.