Classes de conteneurs C++<vector>

Introduction

La bibliothèque de modèles standard (STL) de C++ est une partie importante de C++, fournissant un ensemble de classes et de fonctions de modèles génériques pour la gestion de collections de données.<vector>C'est une classe conteneur de la STL, utilisée pour stocker des tableaux de taille dynamique.

<vector>C'est un conteneur de séquence qui permet aux utilisateurs d'ajouter ou de supprimer rapidement des éléments à la fin du conteneur. Comparé aux tableaux,<vector>il offre davantage de fonctionnalités, telles que le redimensionnement automatique, l'accès aléatoire, etc.

Syntaxe

En C++, en utilisant<vector>Il faut inclure le fichier d'en-tête<<vector>>. Voici quelques éléments de syntaxe de base :

  • Déclarer unvector：

    std::vector<int> myVector;

  • Ajouter des éléments :

    myVector.push_back(10);

  • Accéder aux éléments :

    int firstElement = myVector[0];

  • Obtenir le nombre d'éléments :

    size_t size = myVector.size();

  • Clairvector：

    myVector.clear();

Déclaration et initialisation

<vector>Le type d'élément doit être spécifié, et il peut être initialisé de plusieurs manières :

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec1;                  // 空的vector
    std::vector<int> vec2(5);               // 长度为5的vector，元素默认初始化
    std::vector<int> vec3(5, 10);           // 长度为5的vector，元素值为10
    std::vector<int> vec4 = {1, 2, 3, 4};   // 使用初始化列表初始化

    return 0;
}

Exemple

Ce qui suit est un cas d'utilisation<vector>d'un exemple simple, incluant les résultats de sortie.

Exemple

#include <iostream>
#include <vector>

int main() {
    // Déclarer un vector qui stocke des entiers
    std::vector<int> numbers;

    // Ajouter des éléments
    numbers.push_back(10);
    numbers.push_back(20);
    numbers.push_back(30);

    // Afficher les éléments du vector
    std::cout << "Le vecteur contient : ";
    for (int i = 0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    // Ajouter d'autres éléments
    numbers.push_back(40);
    numbers.push_back(50);

    // Afficher à nouveau les éléments du vecteur
    std::cout << "Après avoir ajouté d'autres éléments, le vecteur contient : ";
    for (int i = 0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    // Accéder à un élément spécifique
    std::cout << "Le premier élément est : " << numbers[0] << std::endl;

    // Vider le vecteur
    numbers.clear();

    // Vérifier si le vecteur est vide
    if (numbers.empty()) {
        std::cout << "Le vecteur est maintenant vide." << std::endl;
    }

    return 0;
}

Sortie :

Vector contains: 10 20 30 
After adding more elements, vector contains: 10 20 30 40 50 
The first element is: 10 
The vector is now empty.

Fonctions membres courantes

Les suivantes sont<vector>Quelques fonctions membres couramment utilisées dans :

Fonction Description
push_back(const T& val) Ajouter un élément à la fin
pop_back() Supprimer le dernier élément
at(size_t pos) Renvoie l'élément à la position spécifiée, avec vérification des limites
operator[] Renvoie l'élément à la position spécifiée, sans vérification des limites
front() Renvoie le premier élément
back() Renvoie le dernier élément
data() Retourne un pointeur vers le tableau sous-jacent
size() Retourne le nombre actuel d'éléments
capacity() Retourne la capacité actuellement allouée
reserve(size_t n) Réserve au moinsnEspace de stockage pour les éléments
resize(size_t n) Redimensionne le nombre d'éléments àn
clear() Effacer tous les éléments
insert(iterator pos, val) Insère un élément à la position spécifiée
erase(iterator pos) Supprime l'élément à la position spécifiée
begin() / end() Retourne les itérateurs begin/end

Exemple

1. Opérations de base

Exemple

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // Affiche tous les éléments
    std::cout << "Éléments du vecteur : ";
    for (int i = 0; i < vec.size(); ++i) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;

    // Obtenir les premier et dernier éléments
    std::cout << "Premier élément : " << vec.front() << std::endl;
    std::cout << "Dernier élément : " << vec.back() << std::endl;

    return 0;
}

2. Ajout et suppression dynamiques d'éléments

Exemple

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);

    std::cout << "Taille du vecteur : " << vec.size() << std::endl;
    std::cout << "Capacité du vecteur : " << vec.capacity() << std::endl;

    // Supprimer le dernier élément
    vec.pop_back();
    std::cout << "Après pop_back, taille : " << vec.size() << std::endl;

    return 0;
}

3. Vérification des limites et accès sécurisé

Exemple

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3};

    try {
        std::cout << vec.at(2) << std::endl;  // Sortie normale
        std::cout << vec.at(5) << std::endl;  // Hors limites, lève une exception
    } catch (const std::out_of_range& e) {
        std::cout << "Exception : " << e.what() << std::endl;
    }

    return 0;
}

4. Préallouer la capacité

Exemple

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;
    vec.reserve(10);  // Réserver de la capacité pour éviter les allocations mémoire fréquentes

    for (int i = 0; i < 10; ++i) {
        vec.push_back(i);
        std::cout << "Capacité après push_back(" << i << "): " << vec.capacity() << std::endl;
    }

    return 0;
}

Comparaison avec d'autres conteneurs

Fonctionnalitésstd::vectorstd::arraystd::list
SizeModifiable dynamiquementFixe à la compilationModifiable dynamiquement
Emplacement de stockageMémoire contiguëMémoire contiguëMémoire non contiguë
Performances d'accèsAccès aléatoire rapideAccès aléatoire rapideL'accès aléatoire est lent, adapté à l'accès séquentiel
Performances d'insertion et de suppressionLes opérations en fin ont des performances élevées, les autres positions sont plus lentesNon pris en chargeL'insertion et la suppression à n'importe quelle position sont relativement rapides
Méthode de croissance de la mémoireCroît exponentiellement lorsque la capacité est insuffisanteAucuneAucune

<vector>C'est un conteneur très utile dans la STL C++, offrant une fonctionnalité de tableau dynamique qui rend l'ajout et la suppression d'éléments plus flexibles et pratiques. Grâce aux exemples ci-dessus, les débutants peuvent rapidement comprendre<vector>l'utilisation et les opérations de base de celui-ci. Au fur et à mesure de l'apprentissage, vous découvrirez<vector>ses fonctionnalités puissantes et sa large gamme d'applications en programmation pratique.

autres extensions