C++ <vector> opérateur operator[]

Classe conteneur C++ <vector>

Parmi toutes les façons d'accéder aux éléments d'un vecteur,operator[]est le moyen le plus courant et le plus direct, tout comme l'accès aux éléments d'un tableau.

operator[]est l'opérateur d'indice des classes de conteneurs, utilisé pourrenvoyer l'élément à la position spécifiée, mais il n'effectue pas de vérification des limites. Son utilisation est exactement la même que celle d'un tableau ordinaire.

operator[]offre une capacité d'accès aléatoire de type tableau, vous permettant d'accéder rapidement aux éléments à n'importe quelle position.

Définitions de mots： operator[]est l'opérateur d'indice, et les crochets sont le symbole de l'accès aux tableaux.

Syntaxe de base et paramètres

operator[]est une fonction membre de la classe conteneur. Utilisez-la comme vous le feriez avec un tableau.

Format de syntaxe

reference operator[](size_type pos);
const_reference operator[](size_type pos) const;

Description des paramètres

  • Paramètre： pos
    • Type :size_type(un type entier non signé, généralementsize_t）
    • Description : la position (l'indice) de l'élément à accéder. L'indice commence à 0, et l'indice maximal valide estsize() - 1。

Description de la fonction

  • Valeur de retour: renvoie le ... de l'élément à la position spécifiéeRéférence. Si le conteneur est un conteneur constant, une référence constante est renvoyée.
  • Effet: renvoie l'élément à la position spécifiée. Aucune vérification des limites n'est effectuée ; un accès hors limites entraîne un comportement indéfini.
  • Différence avec at()： operator[]N'effectue pas de vérification des limites, il est donc légèrement plus rapide ;at()effectue une vérification des limites et lève une exception en cas de dépassement.

Exemple

Maîtrisons-le à fond à travers une série d'exemples allant du simple au complexe.operator[]Utilisation.

Exemple 1 : utilisation de base - accès aux éléments

Exemple

#include <iostream>
#include <vector>

int main() {
    // 1. Créer un vecteur et ajouter quelques éléments
    std::vector<int> numbers = {10, 20, 30, 40, 50};

    std::cout << "La taille du vecteur est : " << numbers.size() << std::endl;

    // 2. Utiliser operator[] pour accéder aux éléments
    std::cout << "Premier élément [0] : " << numbers[0] << std::endl;
    std::cout << "Deuxième élément [1] : " << numbers[1] << std::endl;
    std::cout << "Troisième élément [2] : " << numbers[2] << std::endl;
    std::cout << "Dernier élément [4] : " << numbers[4] << std::endl;

    // 3. Utiliser une boucle pour accéder à tous les éléments
    std::cout << "Tous les éléments : ";
    for(size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

Sortie attendue :

vector的大小是: 5
第一个元素 [0]: 10
第二个元素 [1]: 20
第三个元素 [2]: 30
最后一个元素 [4]: 50
所有元素: 10 20 30 40 50

Analyse du code :

  1. numbers[0]Renvoie le premier élément10(les indices commencent à 0).
  2. numbers[4]renvoie le dernier élément50(carsize()est 5, et les indices valides sont 0-4).
  3. en utilisant des boucles etoperator[]peut parcourir tous les éléments, et son utilisation est exactement la même que celle d'un tableau.

Exemple 2 : Modification des valeurs des éléments

operator[]renvoie une référence, elle peut donc être utilisée pour modifier la valeur d'un élément.

Exemple

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {10, 20, 30};

    std::cout << "Avant modification : ";
    for(size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    // Utilisez operator[] pour obtenir une référence et modifier les éléments
    numbers[0] = 100;
    numbers[1] = 200;
    numbers[2] = 300;

    std::cout << "Après modification : ";
    for(size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

Sortie attendue :

修改前: 10 20 30
修改后: 100 200 300

Analyse du code :

  • numbers[0] = 100;La valeur du premier élément a été modifiée via la référence.
  • Cela démontreoperator[]renvoie une référence lvalue modifiable.

Exemple 3 : Utilisation de auto pour déduire automatiquement le type

Combinaisonautomot-clé, pour une utilisation plus pratiqueoperator[]。

Exemple

#include <iostream>
#include <vector>
#include <string>

int main() {
    std::vector<std::string> names = {"Alice", "Bob", "Charlie"};

    // Utiliser auto pour la déduction automatique du type
    for(size_t i = 0; i < names.size(); ++i) {
        auto& name = names[i]; // Déduit comme std::string&
        std::cout << "Tour " << (i + 1) << " personnes : " << name << std::endl;
    }

    return 0;
}

Sortie attendue :

第 1 个人: Alice
第 2 个人: Bob
第 3 个人: Charlie

Analyse du code :

  • auto& name = names[i];Déduit automatiquement commestd::string&, permettant la modification directe de l'élément.

    • Exemple 4 : Différence entre operator[] et at()

    Comparaisonoperator[]etat()Différences de comportement.

    Exemple

    #include <iostream>
    #include <vector>
    #include <stdexcept>

    int main() {
        std::vector<int> numbers = {10, 20, 30};

        // operator[] n’effectue pas de vérification des limites ; un accès hors limites est à vos risques et périls
        // Ici, on accède à numbers[5], mais size() vaut 3, c’est un comportement indéfini
        // Pour la démonstration, nous accédons uniquement à la plage valide

        std::cout << "accès avec operator[] :" << std::endl;
        for(size_t i = 0; i < 3; ++i) {
            std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
        }

        std::cout << "\naccès at() (avec vérification des limites) :" << std::endl;
        for(size_t i = 0; i < 3; ++i) {
            std::cout << "numbers.at(" << i << ") = " << numbers.at(i) << std::endl;
        }

        std::cout << "\nSuggestion : utilisez operator[] lorsque vous êtes sûr que l’indice ne dépassera pas les limites, << std::endl;
        std::cout << " Utilisez at() en cas d’incertitude pour bénéficier d’une protection par exception." << std::endl;

        return 0;
    }

    Analyse du code :

    • operator[]L’accès est plus rapide car aucune vérification des limites n’est effectuée.
    • at()Plus sûr, mais avec un surcoût de gestion des exceptions.
    • Conseil de sélection : si l’indice est garanti sûr (par exemple une variable de boucle entre 0 et size()-1), utilisezoperator[]; si l'indice provient d'une entrée externe ou peut être incertain, utilisezat()。

    Exemple 5 : Calcul du produit scalaire de vecteurs

    Utilisationoperator[]Implémentez les opérations vectorielles.

    Exemple

    #include <iostream>
    #include <vector>

    // Calculer le produit scalaire de deux vecteurs
    int dotProduct(const std::vector<int>& v1, const std::vector<int>& v2) {
        int result = 0;
        for(size_t i = 0; i < v1.size(); ++i) {
            result += v1[i] * v2[i];
        }
        return result;
    }

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

        int result = dotProduct(v1, v2);

        std::cout << "Vector v1: ";
        for(size_t i = 0; i < v1.size(); ++i) {
            std::cout << v1[i] << " ";
        }
        std::cout << std::endl;

        std::cout << "Vector v2: ";
        for(size_t i = 0; i < v2.size(); ++i) {
            std::cout << v2[i] << " ";
        }
        std::cout << std::endl;

        std::cout << "Dot product: " << result << std::endl;
        // 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32

        return 0;
    }

    Sortie attendue :

    向量 v1: 1 2 3
向量 v2: 4 5 6
点积: 32

    Analyse du code :

    • Utilisationoperator[]peut accéder rapidement aux éléments d'un vecteur dans les algorithmes.
    • Le produit scalaire est calculé en multipliant les éléments aux positions correspondantes, puis en les additionnant.

    Classe conteneur C++ <vector>

    autres extensions