, pero size() es 3; esto es un comportamiento indefinido

C++ 容器类 <vector>C++ clase de contenedor <vector>


Entre todas las formas de acceder a los elementos de un vector,operator[]es la más común y directa, igual que acceder a los elementos de un array.

operator[]es el operador de subíndice de la clase contenedor, utilizado paradevolver el elemento en la posición especificada, pero no realiza comprobación de límites. Su uso es exactamente igual que el de un array normal.

operator[]Proporciona acceso aleatorio estilo array, lo que te permite acceder rápidamente a elementos en cualquier posición.

Definición del término: operator[]es el operador de subíndice; los corchetes son el símbolo de acceso a arrays.


Sintaxis básica y parámetros

operator[]es una función miembro de la clase contenedor; solo úsalo como si fuera un array.

Formato de sintaxis

reference operator[](size_type pos);
const_reference operator[](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; el índice válido máximo essize() - 1。

Descripción de la función

  • Valor de retorno: Devuelvela referencia del elemento en la posición especificada. Si el contenedor es constante, devuelve una referencia constante.
  • Efecto: Devuelve el elemento en la posición especificada. No realiza comprobación de límites; el resultado del acceso fuera de límites es indefinido.
  • Diferencia con at(): operator[]no realiza comprobación de límites, es un poco más rápido;at()sí realiza comprobación de límites y lanza una excepción cuando se sale de los límites.

Ejemplo

A través de una serie de ejemplos de simples a complejos, dominaremos completamenteoperator[]el uso.

Ejemplo 1: Uso básico - Acceder a elementos

Ejemplo

#include <iostream>
#include <vector>

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 operator[] para acceder a los elementos
    std::cout << "Primer elemento << numbers[0] << std::endl;
    std::cout << "Segundo elemento << numbers[1] << std::endl;
    std::cout << "Tercer elemento << numbers[2] << std::endl;
    std::cout << "Último elemento << numbers[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[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

Resultado esperado:

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

Análisis del código:

  1. numbers[0]Devuelve el primer elemento10(el índice comienza en 0).
  2. numbers[4]Devuelve el último elemento50(porquesize()es 5, los índices válidos son 0-4).
  3. Usando un bucle yoperator[]se pueden recorrer todos los elementos; el uso es exactamente igual que con arrays.

Ejemplo 2: Modificar el valor de un elemento

operator[]Devuelve 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[i] << " ";
    }
    std::cout << std::endl;

    // Usar operator[] para obtener una referencia y modificar el elemento
    numbers[0] = 100;
    numbers[1] = 200;
    numbers[2] = 300;

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

    return 0;
}

Resultado esperado:

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

Análisis del código:

  • numbers[0] = 100;Se modificó el valor del primer elemento a través de la referencia.
  • Esto demuestraoperator[]que devuelve una referencia lvalue modificable.

Ejemplo 3: Uso de auto para la deducción automática de tipos

Al combinarautola palabra clave, se puede usar más convenientementeoperator[]。

Ejemplo

#include <iostream>
#include <vector>
#include <string>

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

    // Usar auto para la deducción automática de tipos
    for(size_t i = 0; i < names.size(); ++i) {
        auto& name = names[i]; // Se deduce como std::string&
        std::cout << "Persona " << (i + 1) << ": " << name << std::endl;
    }

    return 0;
}

Resultado esperado:

第 1 个人: Alice
第 2 个人: Bob
第 3 个人: Charlie

Análisis del código:

  • auto& name = names[i];Se deduce automáticamente comostd::string&, se puede modificar el elemento directamente.
  • Ejemplo 4: Diferencia entre operator[] y at()

    Comparandooperator[]yat()las diferencias de comportamiento.

    Ejemplo

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

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

        // operator[] no realiza comprobación de límites; el acceso fuera de límites es bajo tu propio riesgo
        // Aquí se accede a numbers
        // Para demostrarlo, solo accedemos al rango válido

        std::cout << "Acceso con operator[]: " << std::endl;
        for(size_t i = 0; i < 3; ++i) {
            std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
        }

        std::cout << "\n"Acceso con at() (con comprobación de límites):" << std::endl;
        for(size_t i = 0; i < 3; ++i) {
            std::cout << "numbers.at(" << i << ") = " << numbers.at(i) << std::endl;
        }

        std::cout << "\nSugerencia: usa operator[] cuando estés seguro de que el índice no se saldrá de los límites, << std::endl;
        std::cout << " usa at() cuando no estés seguro para obtener protección de excepciones." << std::endl;

        return 0;
    }

    Análisis del código:

    • operator[]El acceso es más rápido porque no realiza comprobación de límites.
    • at()Es más seguro, pero tiene la sobrecarga del manejo de excepciones.
    • Recomendación de elección: si el índice es seguro (por ejemplo, una variable de bucle entre 0 y size()-1), usaoperator[]; si el índice proviene de una entrada externa o puede ser incierto, usaat()。

    Ejemplo 5: Calcular el producto punto de vectores

    Usandooperator[]se implementan operaciones vectoriales.

    Ejemplo

    #include <iostream>
    #include <vector>

    // Calcular el producto punto de dos vectores
    int dotProduct(const std::vector<int>& v1, const std::vector<int>& v2) {
        int result = 0;
        for(size_t i = 0; i < v1.size(); ++i) {
            result += v1[i] * v2[i];
        }
        return result;
    }

    int main() {
        std::vector<int> v1 = {1, 2, 3};
        std::vector<int> 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 << "Producto punto: " << result << std::endl;
        // 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32

        return 0;
    }

    Resultado esperado:

    向量 v1: 1 2 3
    向量 v2: 4 5 6
    点积: 32
    

    Análisis del código:

    • Usandooperator[]se puede acceder rápidamente a los elementos del vector en algoritmos.
    • El cálculo del producto punto consiste en multiplicar los elementos en las posiciones correspondientes y luego sumarlos.

    C++ 容器类 <vector>C++ clase de contenedor <vector>

    Otras extensiones