C++ <vector> fonction at

Classe conteneur C++ <vector>

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

atest une fonction membre des classes conteneur, utilisée pourretourner l'élément à la position spécifiée, tout en effectuant une vérification des limites. Si l'indice est en dehors des limites, elle lèvestd::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： atsignifiant "at", c'est-à-dire obtient l'élément à la position spécifiée.

Syntaxe de base et paramètres

atest une fonction membre de la classe 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, elle renvoie une référence const.
  • Effet: Renvoie l'élément à la position spécifiée. Si l'indice 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 parfaitement ceci à travers une série d'exemples, du simple au complexeatUtilisation.

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

Exemple

#include <iostream>
#include <vector>
#include <stdexcept> // Contient le fichier d'en-tête de gestion des exceptions

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 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 :

vector的大小是: 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 : attraper une exception 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 <vector>
#include <stdexcept>

int main() {
    std::vector<int> 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)...
捕获到异常: vector::_M_range_check: __pos (which is 10) >= this->size() (which is 3)
访问 at(2): 30

Analyse du code :

  • Lors de l'accèsat(10)lorsque 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 : comparaison de at et operator[]

Comparaisonatetoperator[]Différences de comportement.

Exemple

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

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

    std::cout << Utilisez at() pour accéder aux éléments : << std::endl;
    // at() effectue une vérification des limites
    for(size_t i = 0; i <= numbers.size(); ++i) {
        try {
            std::cout << "at(" << i << ") = " << numbers.at(i) << std::endl;
        }
        catch(const std::out_of_range& e) {
            std::cout << "at(" << i << ) Hors limites ! << std::endl;
        }
    }

    std::cout << "\nUtilisez operator[] pour accéder aux éléments : << std::endl;
    // operator[] ne vérifie pas les limites, le comportement hors limites est indéfini
    for(size_t i = 0; i <= numbers.size(); ++i) {
        std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
    }

    return 0;
}

Analyse du code :

  • at()Il lève une exception lorsqu'on est hors limites, et vous pouvez choisir de l'intercepter et de la gérer.
  • operator[]le comportement en cas de dépassement de limites est indéfini, et peut renvoyer des valeurs parasites, planter ou produire d'autres résultats imprévisibles.
  • dans le code de production, par sécurité, il est recommandé d'utiliserat()à la placeoperator[], en particulier lorsque l'indice provient d'une entrée utilisateur ou de données externes.

Exemple 4 : modification des valeurs des éléments

atElle retourne une référence, elle peut donc être utilisée pour modifier la valeur de l'é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.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;La valeur du premier élément a été modifiée via la référence.
  • Cela démontreat()renvoie une référence lvalue modifiable.

Classe conteneur C++ <vector>

autres extensions