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

C++ classe conteneur <array>

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

operator[]est l'opérateur d'indice des classes 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 C normal.

operator[]fournit 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 éléments d'un tableau.

Syntaxe de base et paramètres

operator[]est une fonction membre de la classe conteneur, il suffit de l'utiliser comme 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 valide maximal estsize() - 1。

Description de la fonction

  • Valeur de retour: renvoie laréférencede l'élément à la position spécifiée. Si le conteneur est un conteneur const, une référence const 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 par rapport à at()： operator[]n'effectue pas de vérification des limites, 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 <array>

int main() {
    // 1. Créer un tableau et l'initialiser
    std::array<int, 5> numbers = {10, 20, 30, 40, 50};

    std::cout << "La taille du tableau 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 :

array的大小是: 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(l'indice commence à 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 C.

Exemple 2 : modification des valeurs des éléments

operator[]renvoie une référence, il peut donc être utilisé pour modifier la valeur de l'élément.

Exemple

#include <iostream>
#include <array>

int main() {
    std::array<int, 3> 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 : boucle for basée sur une plage

Vous pouvez utiliser une boucle for basée sur une plage pour parcourir le tableau.

Exemple

#include <iostream>
#include <array>
#include <string>

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

    std::cout << "Tous les éléments : ";
    for(const auto& name : names) {
        std::cout << name << " ";
    }
    std::cout << std::endl;

    return 0;
}

Sortie attendue :

所有元素: Alice Bob Charlie

Analyse du code :

  • La boucle for basée sur une plage est un moyen concis d'accéder aux éléments d'un tableau.
  • etoperator[]par rapport à ..., le code est plus concis et lisible.

Exemple 4 : calcul du produit scalaire de vecteurs

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

Exemple

#include <iostream>
#include <array>

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

int main() {
    std::array<int, 3> v1 = {1, 2, 3};
    std::array<int, 3> 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[]Vous pouvez accéder rapidement aux éléments d'array dans les algorithmes.
  • Le produit scalaire est calculé en multipliant les éléments correspondants puis en les additionnant.

C++ classe conteneur <array>

autres extensions