C++ <array> fonction at

C++ classe conteneur <array>


Parmi toutes les façons d'accéder aux éléments d'un tableau,atest la plus sûre, car elle fournitune vérification des limites。

atest une fonction membre des classes conteneur, utilisée pourrenvoyer l'élément à la position spécifiéetout en effectuant une vérification des limites. Si l'index est hors limites, elle lancestd::out_of_rangeune exception.

atmet en œuvre un accès sécurisé aux éléments, ce qui permet d'intercepter et de gérer les erreurs hors limites à l'exécution.

Définitions de mots: atsignifie « à la position », c'est-à-dire obtient l'élément à la position spécifiée.


Syntaxe de base et paramètres

atest une fonction membre des classes conteneur, vous devez donc d'abord avoir un objet conteneur, puis utiliser l'opérateur point.pour l'appeler.

Format de syntaxe

reference at(size_type pos);
const_reference at(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 (index) de l'élément auquel accéder. L'index commence à 0, et l'index valide maximal estsize() - 1。

Description de la fonction

  • Valeur de retour: renvoie l'élément à la position spécifiéeRéférence. 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. Si l'index est en dehors de la plage valide (pos >= size()), il lèvera une exceptionstd::out_of_rangeune exception.
  • différence par rapport à operator[]: ateffectue une vérification des limites,operator[]n'effectue pas de vérification des limites (le comportement hors limites est indéfini).

Exemple

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

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

Exemple

#include <iostream>
#include <array>
#include <stdexcept>

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 at pour accéder aux éléments
    std::cout << Premier élément (at(0)) : << numbers.at(0) << std::endl;
    std::cout << Deuxième élément (at(1)) : << numbers.at(1) << std::endl;
    std::cout << Troisième élément (at(2)) : << numbers.at(2) << std::endl;
    std::cout << Dernier élément (at(4)) : << numbers.at(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.at(i) << " ";
    }
    std::cout << std::endl;

    return 0;
}

Sortie attendue :

array的大小是: 5
第一个元素 (at(0)): 10
第二个元素 (at(1)): 20
第三个元素 (at(2)): 30
最后一个元素 (at(4)): 50
所有元素: 10 20 30 40 50

Analyse du code :

  1. numbers.at(0)Renvoie le premier élément10(les indices commencent à 0).
  2. numbers.at(4)renvoie le dernier élément50(carsize()vaut 5, les indices valides sont 0-4).
  3. en utilisant des boucles etatpeut parcourir tous les éléments en toute sécurité.

Exemple 2 : intercepter les exceptions hors limites

atLe principal avantage est qu'il peut lever des exceptions, ce qui nous permet de gérer les erreurs hors limites.

Exemple

#include <iostream>
#include <array>
#include <stdexcept>

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

    // Essayer d'accéder à une position hors limites
    try {
        std::cout << Tentative d'accès à at(10)... << std::endl;
        int value = numbers.at(10); // Ceci va lever une exception
        std::cout << Valeur : << value << std::endl;
    }
    catch(const std::out_of_range& e) {
        std::cout << Exception interceptée : << e.what() << std::endl;
    }

    // Accès normal
    try {
        std::cout << Accès à (2) : << numbers.at(2) << std::endl;
    }
    catch(const std::out_of_range& e) {
        std::cout << Exception interceptée : << e.what() << std::endl;
    }

    return 0;
}

Sortie attendue :

尝试访问 at(10)...
捕获到异常: array::at: __pos (which is 10) >= _Nm (which is 3)
访问 at(2): 30

Analyse du code :

  • Lors de l'accèsat(10)lorsque, parce que l'indice est hors limites, il lève une exceptionstd::out_of_rangeune exception.
  • catch(const std::out_of_range& e)Intercepter l'exception,e.what()renvoie la description de l'exception.
  • l'accès normal par index ne lève pas d'exceptions.

Exemple 3 : Modification de la valeur d'un élément

atIl renvoie une référence, de sorte qu'il peut ê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.at(i) << " ";
    }
    std::cout << std::endl;

    // Utilisez at() pour obtenir une référence et modifier l'élément
    numbers.at(0) = 100;
    numbers.at(1) = 200;
    numbers.at(2) = 300;

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

    return 0;
}

Sortie attendue :

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

Analyse du code :

  • numbers.at(0) = 100;Grâce à la référence, la valeur du premier élément a été modifiée.
  • Cela démontreat()renvoie une référence lvalue modifiable.

C++ classe conteneur <array>

autres extensions