Maîtriser std::vector en C++ : Tableaux dynamiques, itérateurs et exemples pratiques

Qu'est-ce qu'un vector C++ ?

Un vector C++ est un tableau dynamique qui se redimensionne automatiquement quand des éléments sont ajoutés ou supprimés. Ses éléments sont stockés de manière contiguë, permettant un accès indexé rapide et un parcours via itérateurs.

L'insertion se fait à la fin en temps constant amorti. La suppression du dernier élément est aussi en temps constant, tandis que l'insertion ou la suppression au début ou au milieu nécessite le décalage des éléments, résultant en une complexité temporelle linéaire.

Quand utiliser un vector ?

• Quand vous avez besoin d'un conteneur redimensionnable pour des éléments qui changent avec le temps.
• Quand la taille finale de la collection est inconnue à la compilation.

Comment initialiser les vectors en C++

std::vector<type-donnée> nom (taille, valeur); // taille et valeur sont optionnels

• type-donnée spécifie le type d'élément.
• nom est l'identifiant du vector.
• Le paramètre optionnel taille réserve de l'espace ; valeur initialise tous les éléments.

Itérateurs

Les itérateurs fournissent une interface de type pointeur vers les éléments du vector. Les fonctions d'itérateur courantes incluent :

• begin() – premier élément.
• end() – élément après la fin.
• cbegin() – itérateur en lecture seule vers le premier élément.
• cend() – itérateur en lecture seule après le dernier élément.

Modificateurs

Les modificateurs changent le contenu du vector. Les fonctions clés sont :

• push_back() – ajoute un élément à la fin.
• insert() – insère à une position spécifiée.
• pop_back() – supprime le dernier élément.
• erase() – supprime une plage d'éléments.
• clear() – supprime tous les éléments.

Exemple 1 : Itération de base

#include <iostream>
#include <vector>
int main() {
    std::vector<int> nums;
    for (int a = 1; a <= 5; ++a) {
        nums.push_back(a);
    }
    std::cout << "Output from begin and end: ";
    for (auto it = nums.begin(); it != nums.end(); ++it) {
        std::cout << *it << ' ';
    }
    std::cout << "\nOutput from cbegin and cend: ";
    for (auto it = nums.cbegin(); it != nums.cend(); ++it) {
        std::cout << *it << ' ';
    }
    return 0;
}

Sortie :

Exemple 2 : Modificateurs avancés

#include <iostream>
#include <vector>
int main() {
    std::vector<int> nums;
    nums.assign(5, 1); // cinq éléments, tous initialisés à 1
    std::cout << "Vector contents: ";
    for (size_t i = 0; i < nums.size(); ++i) {
        std::cout << nums[i] << ' ';
    }
    nums.push_back(2);
    std::cout << "\nLast element: " << nums.back();
    nums.pop_back();
    std::cout << "\nVector contents: ";
    for (int a : nums) std::cout << a << ' ';
    nums.insert(nums.begin(), 7);
    std::cout << "\nFirst element: " << nums.front();
    nums.clear();
    std::cout << "\nSize after clear(): " << nums.size();
    return 0;
}

Sortie :

Fonctions de capacité

Déterminez et manipulez les caractéristiques de stockage d'un vector avec les fonctions suivantes :

• size() – nombre actuel d'éléments.
• max_size() – nombre maximum théorique d'éléments.
• capacity() – capacité de stockage allouée.
• resize(n) – change le nombre d'éléments à n, ajoutant ou supprimant selon les besoins.
• empty() – vrai si le vector ne contient aucun élément.

Exemple 3 : Exploration de la capacité

#include <iostream>
#include <vector>
int main() {
    std::vector<int> vector1;
    for (int x = 1; x <= 10; ++x) {
        vector1.push_back(x);
    }
    std::cout << "Vector size: " << vector1.size() << std::endl;
    std::cout << "Vector capacity: " << vector1.capacity() << std::endl;
    std::cout << "Maximum size of vector: " << vector1.max_size() << std::endl;
    vector1.resize(5);
    std::cout << "Vector size after resizing: " << vector1.size() << std::endl;
    if (!vector1.empty())
        std::cout << "Vector is not empty" << std::endl;
    else
        std::cout << "Vector is empty" << std::endl;
    return 0;
}

Sortie :

Points clés à retenir

• Un vector C++ est un conteneur hautement efficace, automatiquement redimensionnable.
• Les éléments résident en mémoire contiguë, fournissant un accès aléatoire rapide.
• L'insertion et la suppression à la fin sont en temps constant amorti ; au début ou au milieu sont en temps linéaire.
• Les vectors sont idéaux pour les scénarios avec des tailles de données imprévisibles ou changeantes.