Conteneurs séquentiels

N'hésitez pas à donner vos avis par rapport à ce tutoriel : Commentez Donner une note à l'article (0)

Article lu   fois.

L'auteur

Profil Pro

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

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> :

 
Sélectionnez
#include <array>

I-A-1. Template, constructeurs, destructeurs

Le template est le suivant :

 
Sélectionnez
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 :

 
Sélectionnez
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.

 
Sélectionnez
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.

 
Sélectionnez
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 :

 
Sélectionnez
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.

 
Sélectionnez
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é.

 
Sélectionnez
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.

 
Sélectionnez
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.

 
Sélectionnez
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

III. Remerciements

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

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

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.