Bibliothèque C++ : conteneur vector

© D. Mathieu     mathieu@romarin.univ-aix.fr
I.U.T.d'Aix en Provence - Département Informatique
Créé le 11/01/2001  - Dernière mise à jour : 16/01/2001

Sommaire

Introduction
Constructeurs
Constructeur par défaut
Constructeur par recopie
Accesseurs/modifieurs d'un vector
Accesseurs/modifieurs des éléments d'un vector
Affectation et assign()
Fonctions et opérateurs non membres applicables à un vector : comparaisons et swap()

Itérateurs

Classes d'itérateurs
Accès à un élément désigné par un itérateur
Valeurs particulières d'itérateurs
Fonctions et opérateurs utilisant les itérateurs
Constructeur
Modifieurs
Voir aussi :

Introduction

    Il faut utiliser le fichier entête <vector>. La classe vector est assez complexe et, comme la classe string étudiée précédemment, sera présentée à travers de nombreux exemples et par difficultés croissantes. Sera passée sous silence l'utilisation des allocateurs, dont seules les valeurs par défaut seront utilisées.

Sommaire

Constructeurs

Constructeur par défaut

    Le conteneur générique vector peut être instancié par n'importe quel type ou classe à condition     Quelques exemples d'utilisation du constructeur par défaut :
 
class CPoint;                      // déclaration d'une classe CPoint supposée
                                   //    définie par ailleurs;
vector <int>     VInt;             // définition d'un vecteur d'int     (type anonyme)
vector <CPoint>  VCPoint;          // définition d'un vecteur de CPoint (type anonyme)

typedef vector <int>    CVInt;     // défintion d'un type de vecteur d'int     (type nommé)
typedef vector <CPoint> CVCPoint;  // défintion d'un type de vecteur de CPoint (type nommé)

CVInt    VectInt;                  // définition d'un vecteur d'int
CVCPoint VectCPoint;               // définition d'un vecteur de CPoint

    Comme le montrent ces exemples, l'instanciation de la classe vector nécessite un seul [1] paramètre de généricité (entre <>). Il et vivement conseillé de définir un type nommé dès qu'une instanciation est nécessaire. Nous n'utiliserons plus que les deux types CVInt et VectCPoint définis ci-dessus dans tous les exemples qui suivent.

    Le constructeur utilisé ci-dessus est le constructeur par défaut (qui peut être appelé sans paramètre), qui crée un vecteur vide (aucun élément). Cependant  le conteneur vide existe : il occupe un espace mémoire.

    Il est possible de construire un vecteur de taille non nulle :
 
CVInt    VectCpt    (10);
CVCPoint VectCPoint ( 5); 

    VectCpt est un vecteur de 10 éléments entiers initialisés chacun par le constructeur par défaut du type int, qui correspond à une valeur nulle. En d'autres termes, les 10 compteurs du vecteur sont initialisés à 0.

    CVCPoint est un vecteur de 5 points initialisés chacun par le constructeur par défaut de la classe CPoint, qui peut par exemple initialiser à 0 les coordonnées du point à 0.

    De façon générale, l'utilisation de ce constructeur nécessite que le type des éléments du vecteur possède un constructeur par défaut qui sera utilisé pour initialiser chacun des éléments du vector.

    Il est possible d'intialiser tous les éléments du vecteur à valeur particulière, en utilisant le second paramèter du constructeur :
 
CVInt    VectCpt    (10, 5);             // initialisation des 10 éléments du vecteur à 5
CVCPoint VectCPoint (CPoint (10, 10));   // initialisation des 5 éléments du vecteur à 
                                         //    par un point de coordonnées {10, 10}

Sommaire

Constructeur par recopie

    Il peut être utilisé comme tout constructeur par recopie :
 
CVInt  NewVectCpt (VectCpt);

Sommaire

Accesseurs/modifieurs d'un vector

    La classe conteneur vector dispose des mêmes accesseurs/modifieurs que les classes conteneurs (string, stack, etc.), à savoir size(), max_size(), resize(), capacity(), empty(), clear() et reserve(), qui ont la même sémantique que ceux de la classe string.

Remarque : Si la nouvelle taille du vector indiquée par la fonction resize() est supérieure à la taille courante, le vecteur est allongé du nombre d'éléments supplémentaires et le constructeur par défaut du type de ces éléments est appelé pour chacun d'eux. Il est donc nécessaire que la classe des éléments du vector ait un constructeur par défaut.

Sommaire

Accesseurs/modifieurs des éléments d'un vector

front() renvoie la valeur du premier élément du vecteur
back() renvoie la valeur du dernier élément du vecteur
[n] accède à l'élément de rang n (en lecture ou en écriture)
at(n)[2] accède à l'élément de rang n (en lecture ou en écriture)
push_back (x) ajoute la valeur x en fin de vecteur
pop_back () supprime le dernier élément du vecteur
Sommaire

Affectation et assign()

    L'affectation d'un vecteur à un autre est possible soit par l'opérateur =, soit par la fonction membre assign() :
 
VCPoint = VectPoint;

ou
 
VCPoint.assign (VectPoint);

Sommaire

Fonctions et opérateurs non membres applicables à un vector : comparaisons et swap()

    L'ensemble des opérateurs booléens de comparaison est applicable à un vector.
 
<   ==   !=   >   >=   <=

    De même, la fonction non membre swap() permet de permuter efficacement deux vecteurs de même type :
 
swap (V1, V2);

Sommaire

Itérateurs

Classes d'itérateurs

    Rappelons que, de façon générale, les itérateurs sont classés en trois familles :     La classe vector propose quatre classes de "random iterators" : iterator et const_iterator, reverse_iterator et const_reverse_iterator. Le préfixe const_ indique que les éléments du vecteurs accédés par l'itérateur ne peuvent être modifiés. Le préfixe reverse_ indique que les opérations ++ ou + font reculer l'itérateur vers le début du vecteur, alors que les opérateurs -- et - le font avancer vers la fin du vecteur.

    Exemples de déclarations :
 
CVInt::iterator                  IterInt;
CVCPoint::const_reverse_iterator RevIterPoint;

    IterInt est un itérateur susceptible de parcourir un vecteur d'entiers,  RevIterPoint est un itérateur susceptible de parcourir un vecteur de points (sans pouvoir les modifier).

Sommaire

Accès à un élément désigné par un itérateur

    L'utilisation est semblable à celle d'un pointeur :
 
*IterInt;
*RevIterPoint;

pourvu que les deux itérateurs soient initialisés.

Sommaire

Valeurs particulières d'itérateurs

    Un objet de la classe vector dispose de quatre accesseurs suivants :
 
begin() renvoie un (const_) iterator permettant d'accéder au premier élément du vecteur
end() renvoie un (const_) iterator désignant une position au-delà du dernier élément du vecteur
rbegin() envoie un (const_) iterator permettant d'accéder au dernier élément du vecteur
rend() renvoie un (const_) iterator désignant une position en-decà du premier élément du vecteur
Sommaire

Exemple de parcours de vector

for (CVInt::iterator IterInt (VInt.begin());  // Accès au premier élément
     IterInt != VInt.end ();                  // Dépassement du dernier élément
     ++IterInt)                               // Passage à l'élément suivant
    cin >> *IterInt;

ou
 
typedef CVCPoint::const_reverse_iterator CCRIter;

for (CCRIter RevIterPoint (VPoint.rbegin());  // Accès au dernier élément
     RevIterPoint != VInt.rend ();            // Dépassement du premier élément
     ++RevIterPoint)                          // Passage à l'élément précédent
    cout << *RevIterPoint;

Sommaire

Fonctions et opérateurs utilisant les itérateurs

Constructeur

    On peut construire un vector par recopie d'une tranche d'un autre vecteur d'éléments de même type :
 
CVInt NewVect (ItFirst, ItLast);

ItFirst et ItLast doivent être des itérateurs sur le même vecteur ! Les éléments sont recopiés l'un après l'autre dans le nouveau vecteur à partir de ItFirst (inclus) jusqu'à ItLast (exclu).

    Attention : si les itérateurs sont des reverse_iterators, les éléments sont donc rangés dans l'ordre inverse dans le nouveau vecteur.

Sommaire

Modifieurs

    Plusieurs méthodes ont des itérateurs pour paramètres :
 
VInt.insert (IterInt, x);                // {1}
VInt.insert (IterInt, n, x);             // {2}
VInt.insert (IterInt, ItFirst, ItLast);  // {3}

{1} :  insère dans le vecteur VInt la valeur entière x devant l'élément désigné par IterInt et renvoie un itérateur qui désigne la nouvelle valeur
{2}:  insère dans le vecteur VInt n fois la valeur entière x devant l'élément désigné par IterInt et ne renvoie rien
{3} : insère dans le vecteur VInt la tranche d'un vecteur entier désignée par [ ItFirst, ItLast [ devant l'élément désigné par IterInt. ItFirst et ItLast doivent être des itérateurs sur le même vecteur.
 
VInt.erase (IterInt);                  // {4}
VInt.erase (ItFirst, ItLast);          // {5}

{4} : supprime du vecteur VInt l'élément désigné par IterInt et renvoie un itérateur qui désigne l'élément qui suit l'élément supprimé
{5} : supprime du vecteur VInt la tranche du vecteur entier désignée par [ ItFirst, ItLast [ et renvoie un itérateur qui désigne l'élément qui suit la tranche supprimée. ItFirst et ItLast doivent être des itérateurs sur le même vecteur.
 
VInt.assign (ItFirst, ItLast);           // {6}

{6} : affecte au vecteur VInt la tranche d'un vecteur entier désignée par [ ItFirst, ItLast [  et ne renvoie rien.

Sommaire

Voir aussi :

   SGI - Bibliothèque STL : classe vector

   Thinking in C++ - B. Eckel : vector


[1] le dernier paramètre de généricité de ces constructeurs, et de tous les suivants, est un allocateur dont on se contentera d'utiliser la valeur par défaut.

[2] La fonction at(n) a le même effet que l'opérateur [n], mais vérifie en plus la validité de l'indice. En cas d'erreur (n >= nombre d'éléments du vecteur), at() lève l'exception out_of_range. La fonction  at(n) est facultative (un compilateur peut ne pas l'implémenter).

© D. Mathieu     mathieu@romarin.univ-aix.fr
I.U.T.d'Aix en Provence - Département Informatique