C++ <vector> función at

C++ 容器类 <vector>C++ clase contenedora <vector>


Entre todas las formas de acceder a los elementos de un vector,ates la más segura, ya que proporcionacomprobación de límites。

ates una función miembro de la clase contenedora, utilizada paradevolver el elemento en la posición especificaday realiza comprobación de límites. Si el índice está fuera de rango, se lanza unastd::out_of_rangeexcepción.

atImplementa un acceso seguro a los elementos, lo que te permite capturar y manejar errores de fuera de rango en tiempo de ejecución.

Significado de la palabra: atIndica "en la posición...", es decir, obtener el elemento en la posición especificada.


Sintaxis básica y parámetros

ates una función miembro de la clase contenedora, por lo tanto necesitas primero tener un objeto contenedor, y luego mediante el operador punto.llamarla.

Formato de sintaxis

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

Descripción de parámetros

  • Parámetro: pos
    • Tipo:size_type(tipo entero sin signo, normalmentesize_t)
    • Descripción: La posición (índice) del elemento a acceder. El índice comienza en 0, y el índice máximo válido essize() - 1。

Descripción de la función

  • Valor de retorno: Devuelve la referenciadel elemento en la posición especificada.. Si el contenedor es constante, devuelve una referencia constante.
  • Efecto: Devuelve el elemento en la posición especificada. Si el índice está fuera del rango válido (pos >= size()), se lanzará unastd::out_of_rangeexcepción.
  • Diferencia con operator[]: atrealiza comprobación de límites,operator[]no realiza comprobación de límites (el comportamiento fuera de rango no está definido).

Ejemplo

Vamos a dominar completamente, a través de una serie de ejemplos de simples a complejos,atsu uso.

Ejemplo 1: Uso básico - Acceso a elementos

Ejemplo

#include <iostream>
#include <vector>
#include <stdexcept> // Incluye el encabezado para manejo de excepciones

int main() {
    // 1. Crear un vector y agregar algunos elementos
    std::vector<int> numbers = {10, 20, 30, 40, 50};

    std::cout << "El tamaño del vector es: " << numbers.size() << std::endl;

    // 2. Usar at para acceder a los elementos
    std::cout << "El primer elemento (at(0)): " << numbers.at(0) << std::endl;
    std::cout << "El segundo elemento (at(1)): " << numbers.at(1) << std::endl;
    std::cout << "El tercer elemento (at(2)): " << numbers.at(2) << std::endl;
    std::cout << "El último elemento (at(4)): " << numbers.at(4) << std::endl;

    // 3. Usar un bucle para acceder a todos los elementos
    std::cout << "Todos los elementos: ";
    for(size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers.at(i) << " ";
    }
    std::cout << std::endl;

    return 0;
}

Resultado esperado:

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

Análisis del código:

  1. numbers.at(0)Devuelve el primer elemento10(el índice comienza en 0).
  2. numbers.at(4)Devuelve el último elemento50(porquesize()el tamaño es 5, el índice válido es 0-4).
  3. Usando un bucle yat`at`, se pueden recorrer todos los elementos de forma segura.

Ejemplo 2: Capturar excepciones fuera de rango

atLa principal ventaja de `at` es que puede lanzar una excepción, lo que nos permite manejar errores de fuera de rango.

Ejemplo

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

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

    // Intentar acceder a una posición fuera de rango
    try {
        std::cout << "Intentando acceder a at(10)..." << std::endl;
        int value = numbers.at(10); // Esto lanzará una excepción
        std::cout << "Valor: " << value << std::endl;
    }
    catch(const std::out_of_range& e) {
        std::cout << "Excepción capturada: " << e.what() << std::endl;
    }

    // Acceso normal
    try {
        std::cout << "Accediendo a at(2): " << numbers.at(2) << std::endl;
    }
    catch(const std::out_of_range& e) {
        std::cout << "Excepción capturada: " << e.what() << std::endl;
    }

    return 0;
}

Resultado esperado:

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

Análisis del código:

  • Cuando se accede aat(10)`at(10)`, debido a que el índice está fuera de rango, se lanzó unastd::out_of_rangeexcepción.
  • catch(const std::out_of_range& e)Se captura la excepción,e.what()y se devuelve la información descriptiva de la excepción.
  • El acceso normal a un índice no lanza una excepción.

Ejemplo 3: Comparación entre at y operator[]

Comparación deatyoperator[]las diferencias de comportamiento entre `at` y `operator[]`.

Ejemplo

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

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

    std::cout << "Accediendo a elementos con at():" << std::endl;
    // at() realiza comprobación de límites
    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 << ") ¡Fuera de rango!" << std::endl;
        }
    }

    std::cout << "\n"Accediendo a elementos con operator[]:" << std::endl;
    // operator[] no realiza comprobación de límites; el comportamiento fuera de rango no está definido.
    for(size_t i = 0; i <= numbers.size(); ++i) {
        std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
    }

    return 0;
}

Análisis del código:

  • at()Cuando el índice está fuera de rango, lanza una excepción; puedes elegir capturarla y manejarla.
  • operator[]Cuando está fuera de rango, el comportamiento no está definido; puede devolver un valor basura, provocar un fallo u otros resultados impredecibles.
  • En código de producción, por seguridad, se recomienda usar `at`at()en lugar de `operator[]`operator[], especialmente cuando el índice proviene de la entrada del usuario o de datos externos.

Ejemplo 4: Modificar el valor de un elemento

atDevuelve una referencia, por lo que se puede usar para modificar el valor del elemento.

Ejemplo

#include <iostream>
#include <vector>

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

    std::cout << "Antes de modificar: ";
    for(size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers.at(i) << " ";
    }
    std::cout << std::endl;

    // Usar at() para obtener una referencia y modificar el elemento
    numbers.at(0) = 100;
    numbers.at(1) = 200;
    numbers.at(2) = 300;

    std::cout << "Después de modificar: ";
    for(size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers.at(i) << " ";
    }
    std::cout << std::endl;

    return 0;
}

Resultado esperado:

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

Análisis del código:

  • numbers.at(0) = 100;Se modificó el valor del primer elemento mediante la referencia.
  • Esto demuestraat()que `at` devuelve una referencia lvalue modificable.

C++ 容器类 <vector>C++ clase contenedora <vector>

Otras extensiones