C++ <vector> at-Funktion

C++-Containerklasse <vector>

Unter allen Möglichkeiten, auf Vektorelemente zuzugreifen,atist die sicherste, da sieGrenzprüfung bietet。

atist eine Memberfunktion von Containerklassen, die verwendet wird, umdas Element an der angegebenen Positionzurückzugeben, während sie eine Grenzprüfung durchführt. Wenn der Index außerhalb der Grenzen liegt, wirft sie eine Ausnahmestd::out_of_rangeeine Ausnahme.

atimplementiert sicheren Elementzugriff, sodass Sie Fehler außerhalb der Grenzen zur Laufzeit abfangen und behandeln können.

Wortdefinitionen： atbedeutet "at", d. h., es ruft das Element an der angegebenen Position ab.

Grundlegende Syntax und Parameter

atist eine Memberfunktion der Containerklasse, daher müssen Sie zuerst ein Containerobjekt haben und dann den Punktoperator verwenden., um sie aufzurufen.

Syntaxformat

reference at(size_type pos);
const_reference at(size_type pos) const;

Parameterbeschreibung

  • Parameter： pos
    • Typ:size_type(ein vorzeichenloser Ganzzahltyp, normalerweisesize_t）
    • Beschreibung: Die Position (der Index) des Elements, auf das zugegriffen werden soll. Der Index beginnt bei 0, und der maximal gültige Index istsize() - 1。

Funktionsbeschreibung

  • Rückgabewert: gibt dieReferenzauf das Element an der angegebenen Position zurück. Wenn der Container ein const-Container ist, gibt er eine const-Referenz zurück.
  • Wirkung: Gibt das Element an der angegebenen Position zurück. Wenn der Index außerhalb des gültigen Bereichs liegt (pos >= size()), wird es eine Ausnahme werfenstd::out_of_rangeeine Ausnahme.
  • Unterschied zu operator[]： atführt eine Bereichsprüfung durch,operator[]führt keine Bereichsprüfung durch (das Verhalten außerhalb der Grenzen ist undefiniert).

Beispiel

Lassen Sie uns dies anhand einer Reihe von Beispielen gründlich meistern, von einfach bis komplexatVerwendung.

Beispiel 1: Grundlegende Verwendung - Zugriff auf Elemente

Beispiel

#include <iostream>
#include <vector>
#include <stdexcept> // Enthält Headerdatei für Ausnahmebehandlung

int main() {
    // 1. Erstelle einen Vektor und füge einige Elemente hinzu
    std::vector<int> numbers = {10, 20, 30, 40, 50};

    std::cout << "Die Größe des Vektors ist: " << numbers.size() << std::endl;

    // 2. Verwende at, um auf Elemente zuzugreifen
    std::cout << Erstes Element (at(0)): << numbers.at(0) << std::endl;
    std::cout << Zweites Element (at(1)): << numbers.at(1) << std::endl;
    std::cout << Drittes Element (at(2)): << numbers.at(2) << std::endl;
    std::cout << Letztes Element (at(4)): << numbers.at(4) << std::endl;

    // 3. Verwende eine Schleife, um auf alle Elemente zuzugreifen
    std::cout << "Alle Elemente: ";
    for(size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers.at(i) << " ";
    }
    std::cout << std::endl;

    return 0;
}

Erwartete Ausgabe:

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

Codeanalyse:

  1. numbers.at(0)Das erste Element zurückgeben10(Indizes beginnen bei 0).
  2. numbers.at(4)gibt das letzte Element zurück50(weilsize()ist 5, gültige Indizes sind 0-4).
  3. mit Schleifen undatkann sicher alle Elemente durchlaufen.

Beispiel 2: Abfangen einer Ausnahme bei Bereichsüberschreitung

atDer Hauptvorteil ist, dass es Ausnahmen auslösen kann, sodass wir Fehler außerhalb der Grenzen behandeln können.

Beispiel

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

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

    // Versuch, auf eine Position außerhalb der Grenzen zuzugreifen
    try {
        std::cout << Versuch, auf at(10) zuzugreifen... << std::endl;
        int value = numbers.at(10); // Dies wird eine Ausnahme auslösen
        std::cout << Wert: << value << std::endl;
    }
    catch(const std::out_of_range& e) {
        std::cout << Abgefangene Ausnahme: << e.what() << std::endl;
    }

    // Normaler Zugriff
    try {
        std::cout << Zugriff auf (2): << numbers.at(2) << std::endl;
    }
    catch(const std::out_of_range& e) {
        std::cout << Abgefangene Ausnahme: << e.what() << std::endl;
    }

    return 0;
}

Erwartete Ausgabe:

尝试访问 at(10)...
捕获到异常: vector::_M_range_check: __pos (which is 10) >= this->size() (which is 3)
访问 at(2): 30

Codeanalyse:

  • Beim Zugriff aufat(10)Wenn der Index außerhalb des gültigen Bereichs liegt, wird eine Ausnahme geworfenstd::out_of_rangeeine Ausnahme.
  • catch(const std::out_of_range& e)Ausnahme abfangen,e.what()gibt die Beschreibung der Ausnahme zurück.
  • normaler Indexzugriff löst keine Ausnahmen aus.

Beispiel 3: Vergleich von at und operator[]

Comparisonatundoperator[]Unterschiede im Verhalten.

Beispiel

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

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

    std::cout << Verwende at(), um auf Elemente zuzugreifen: << std::endl;
    // at() führt eine Bereichsprüfung durch
    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 << ) Außerhalb des gültigen Bereichs! << std::endl;
        }
    }

    std::cout << "\nVerwenden Sie operator[], um auf Elemente zuzugreifen: << std::endl;
    // operator[] führt keine Bereichsprüfung durch, das Verhalten außerhalb der Grenzen ist undefiniert
    for(size_t i = 0; i <= numbers.size(); ++i) {
        std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
    }

    return 0;
}

Codeanalyse:

  • at()Es löst eine Ausnahme aus, wenn der Bereich überschritten wird, und Sie können sie abfangen und behandeln.
  • operator[]Das Verhalten bei Bereichsüberschreitung ist undefiniert und kann Müllwerte zurückgeben, abstürzen oder andere unvorhersehbare Ergebnisse liefern.
  • Im Produktionscode wird aus Sicherheitsgründen empfohlen,at()stattdessen zu verwendenoperator[], besonders wenn der Index von Benutzereingaben oder externen Daten stammt.

Beispiel 4: Ändern von Elementwerten

atEs gibt eine Referenz zurück, sodass es verwendet werden kann, um den Wert des Elements zu ändern.

Beispiel

#include <iostream>
#include <vector>

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

    std::cout << "Vor der Änderung: ";
    for(size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers.at(i) << " ";
    }
    std::cout << std::endl;

    // Verwende at(), um eine Referenz zu erhalten und das Element zu ändern
    numbers.at(0) = 100;
    numbers.at(1) = 200;
    numbers.at(2) = 300;

    std::cout << "Nach der Änderung: ";
    for(size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers.at(i) << " ";
    }
    std::cout << std::endl;

    return 0;
}

Erwartete Ausgabe:

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

Codeanalyse:

  • numbers.at(0) = 100;Der Wert des ersten Elements wurde durch die Referenz geändert.
  • Dies zeigtat()gibt eine modifizierbare lvalue-Referenz zurück.

C++-Containerklasse <vector>

Weitere Erweiterungen