Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies.


Politique de confidentialité
Introduction et syntaxe de base
Pointeurs et fonctions
Programmation OO
Structures de données
La bibliothèque standard (STL)

La classe vector de la bibliothèque STL <vector>

 

La classe vector de la bibliothèque STL <vector>

La classe vector est un conteneur homogène, définie dans l'en-tête <vector>, implémente un conteneur de séquence qui fournit un accès aléatoire rapide à n'importe quel élément et une insertion et une suppression rapide à la queue. Cela signifie que si nous avons besoin d'un conteneur de séquences avec beaucoup d'insertions et de suppressions au début ou au milieu, un vecteur n'est pas le meilleur choix. Un vecteur est une séquence d'éléments avec une extrémité ouverte, comme le montre la figure ci-dessous.

La classe vector est implémentée sous la forme d'un tableau alloué en mémoire tas mais avec des fonctionnalités supplémentaires. Comme un tableau, il dispose d'un mécanisme d'indexation pour accéder à chaque élément. Contrairement à un tableau, un vecteur se redimensionne chaque fois que plus d'éléments sont nécessaires.

En interne, les vecteurs utilisent un tableau alloué dynamiquement pour stocker leurs éléments. Ce tableau peut avoir besoin d'être réaffecté afin d'augmenter sa taille lorsque de nouveaux éléments sont insérés, ce qui implique d'allouer un nouveau tableau et de déplacer tous les éléments vers celui-ci. Il s'agit d'une tâche relativement coûteuse en termes de temps de traitement et, par conséquent, les vecteurs ne sont pas réaffectés à chaque fois qu'un élément est ajouté au conteneur. Par conséquent, par rapport aux tableaux, les vecteurs consomment plus de mémoire en échange de la capacité de gérer le stockage et de croître de manière dynamique et efficace.

Constructeurs et opérateur d'affectation

La classe vector possède un constructeur par défaut, deux constructeurs de paramètres, un constructeur de copie et un opérateur d'affectation. L'exemple suivant montre comment nous utilisons ces fonctions membres.

Exemple 1
vector <T> vec; // Construit un vecteur vide
vector <T> vec(4 , valeur); // Construit un vecteur de 3 éléments de la valeur donnée (valeur)
vector <T> vec[debut,fin); // Construit un vecteur créé à partir d'une autre séquence
vector <T> vec(autreVector); // constructeur par copie
vector <T> vec = autreVector; // opérateur d'affectation
        

La première ligne montre comment créer un vecteur vide. La deuxième ligne montre comment créer un vecteur de quatre éléments, tous de la même valeur. Notez que si le deuxième argument est manquant, il utilise la valeur par défaut (par exemple, zéro pour un entier).

La troisième ligne montre comment copier des éléments d'une autre structure pour créer un vecteur. Les arguments debut et fin sont des itérateurs qui copient ces éléments. Notez que la séquence copiée est une séquence ouverte [debut, fin), ce qui signifie que le debut est dans la séquence, mais pas la fin. La ligne suivante est un constructeur de copie qui crée une copie de autreVector.

Enfin, la dernière ligne est l'opérateur d'affectation, qui fait le même travail que le constructeur de copie mais pour lequel l'objet autreVector doit déjà être instancié.

Size et Capacity

La classe vector a six fonctions membres liées à la taille et à la capacité d'un vecteur. Ce qui suit montre comment nous les utilisons sur une instance de la classe vector (que nous appelons vec).

Exemple 2
vec.size(); // Renvoie la taille actuelle
vec.max_size(); // Renvoie la taille maximale
vec.resize(n, valeur); // Redimensionner le vecteur
vec.empty(); // Renvoie true si le vecteur est vide
vec.capacity(); // Renvoie la taille potentielle ou la capacité de stockage
vec.reserve(n); // Réserve plus d'emplacements de mémoire
        

La fonction size renvoie le nombre d'éléments actuellement dans le vecteur. La fonction max_size définit le nombre maximum d'éléments que le vecteur peut avoir (un grand nombre qui est défini dans la STL). La fonction empty renvoie true si la taille est 0.

La fonction resize(n, valeur) insère des éléments à la queue du vecteur si n > size ; il supprime des éléments à la queue du vecteur si n < size. Si la valeur n'est pas donnée, une valeur par défaut est utilisée.

La fonction capacity renvoie le nombre d'emplacements alloués. En d'autres termes, capacity renvoie la taille potentielle avant que le vecteur ne se redimensionne. La fonction reserve garantit que la capacité est d'au moins n.

Accéder aux éléments

La classe vector fournit les fonctions membres suivantes pour accéder aux éléments déjà présents dans le vecteur.

Exemple 3
vec.front();  // Accéder au premier élément
vec.back(); // Accéder au dernier élément
vec[i];  // Accéder à l'élément à l'indice i
vec.at(i); // Accéder à l'élément à l'indice i
        

Bien que nous puissions utiliser vec[i] ou vec.at(i) pour accéder à un élément à l'indice i, nous recommandons vec.at() car il contrôle la plage et lève une exception lorsque l'indice est hors plage.

Insertion

La classe vector définit plusieurs fonctions membres qui insèrent un ou plusieurs éléments dans le conteneur. L'insertion à la queue est très efficace et ne nécessite pas de déplacement des éléments dans le vecteur. L'insertion au milieu et à l'avant nécessite une réallocation des éléments en mémoire. Ce qui suit montre comment nous pouvons utiliser des fonctions membres pour insérer de nouveaux éléments dans un vecteur. Notez que le dernier exemple copie les éléments du premier à l'avant-dernier élément.

Exemple 4
vec.push_back(valeur);  // Insérer la valeur à la queue
vec.insert(pos, valeur)  // Insérer la valeur avant pos(itérateur)
vec.insert(pos, n, valeur);  // insérer n copies de valeur avant pos
vec.insert(pos, premier, dernier);  // Insérer des éléments [premier, dernier) avant pos
        

Le paramètre pos est la position pointée par l'itérateur défini. Les paramètres premier et dernier sont des itérateurs d'entrée qui définissent la plage [premier, dernier). Ils peuvent être utilisés pour copier les éléments dans le vecteur hôte ou dans un autre conteneur.

Suppression

La classe vector définit plusieurs fonctions membres pour la suppression d'un ou plusieurs éléments dans le conteneur. L'effacement à la queue est très efficace et ne nécessite aucun déplacement d'objets. La suppression depuis le milieu ou depuis l'avant nécessite une réallocation de mémoire et doit être évitée. Ce qui suit montre les fonctions membres que nous pouvons utiliser pour supprimer des éléments d'un vecteur.

Exemple 5
vec.pop_back();  // Supprimer le dernier élément
vec.erase(pos); // Supprimer l'élément pointé par pos
vec.erase(premier, dernier);  // Supprimer les éléments de la plage [premier, dernier)
vec.clear();  // Supprimer tous les éléments
        

Les arguments premier et dernier sont des itérateurs.

Exemple complet

Exemple 6
#include<iostream>
#include<string>
#include<vector> // classe vecteur (conteneur)

using namespace std;  


int main ( ){

    // définir un vecteur
    vector<string> etd;

    etd.push_back("Mostafa");
    etd.push_back("Omar");
    etd.push_back("Sara");
    etd.push_back("Mohamed");
    etd.push_back("Moneim");

    cout<< "La taille est : "<< etd.size()<<endl;
    cout<< "La taille maximale est : "<< etd.max_size()<<endl;
    cout<< "La capacite est : "<< etd.capacity()<<endl;

    etd.reserve(20);
    cout<< "Nouvelle capacite est : "<< etd.capacity()<<endl;

    // afficher les éléments 

    vector::iterator it;
    it=etd.begin();
    cout<< "Voici la liste des etudiants : "<<endl;
    while(it < std::end(etd)){
        cout<< *it << '\t';
        it=std::next(it);
    }
    cout<< '\n';
    it=etd.begin();
    etd.insert(it+2, "Dounia"); // insérer Dounia deux pas après l'élément pointé par l'itérateur it.
    cout<< '\n';
    
    it=etd.begin();
    cout<< "Voici la liste des etudiants apres insertion : "<<endl;
    while(it < std::end(etd)){
        cout<< *it << '\t';
        it=std::next(it);
    }

    cout<< '\n';
    cout<< '\n';

    cout<< "Le premier element est : "<< etd.front() <<endl;
    cout<< "Le dernier element est : "<< etd.back() <<endl;
    cout<< "Le 3eme element est : "<< etd.at(2) <<endl;

    cout<< '\n';
    cout<< '\n';

    etd.pop_back();
    it=etd.begin();
    cout<< "Voici la liste des etudiants apres suppression du dernier element : "<<endl;
    while(it < std::end(etd)){
        cout<< *it << '\t';
        it=std::next(it);
    }

    cout<< '\n';
    cout<< '\n';
    it=etd.begin();
    vector::iterator premier,dernier; // itérateurs à accès aléatoire

    premier=it+1; // pointer sur le 2eme element (Omar)
    dernier=it+3; // pointer sur le 4eme element (Sara)

    etd.erase(premier,dernier); // supprimer les éléments entre Omar et Sara (exclure)
    cout<< "Voici la liste des etudiants apres suppression du dernier element : "<<endl;
    while(it < std::end(etd)){
        cout<< *it << '\t';
        it=std::next(it);
    }
    return 0;
}
        
Résultat
La taille est : 5
La taille maximale est : 288230376151711743    
La capacite est : 8
Nouvelle capacite est : 20
Voici la liste des etudiants :
Mostafa Omar    Sara    Mohamed Moneim

Voici la liste des etudiants apres insertion : 
Mostafa Omar    Dounia  Sara    Mohamed Moneim 

Le premier element est : Mostafa
Le dernier element est : Moneim
Le 3eme element est : Dounia


Voici la liste des etudiants apres suppression du dernier element :
Mostafa Omar    Dounia  Sara    Mohamed

Voici la liste des etudiants apres suppression du dernier element :
Mostafa Sara    Mohamed

Partager ce cours avec tes amis :
Rédigé par ESSADDOUKI Mostafa
ESSADDOUKI
The education of the 21st century opens up opportunities to not merely teach, but to coach, mentor, nurture and inspire.