iterador de C++ iterador

1. Introducción a los iteradores

En C++, un iterador (iterador) es una abstracción general para atravesar y acceder a elementos en contenedores (p. ej. std::vector, std::list, std::mapetc.). Los iteradores proporcionan una interfaz unificada para que se puedan atravesar y manipular diferentes tipos de contenedores de manera similar.

La mayoría de los contenedores de C++ proporcionan iteradores para recorrer los elementos del contenedor. Por ejemplo, std::vectorproporcione std::dequeiteradores de acceso aleatorio, std::listproporcione iteradores bidireccionales std::sety std::mapproporcione iteradores bidireccionales.

Dos, clasificación de iteradores

Los iteradores son similares a los punteros en que se puede acceder al elemento al que se apunta eliminando la referencia y se puede mover mediante operadores de incremento o decremento. La biblioteca estándar de C++ proporciona varios tipos de iteradores, que se pueden dividir en las siguientes categorías según las operaciones y características admitidas:

1. Iterador de entrada: un iterador de solo lectura que admite el movimiento hacia adelante, la desreferenciación y las comparaciones de igualdad/desigualdad. Algoritmos adecuados para escaneos de un solo paso.
2. Iterador de salida: un iterador de solo escritura que admite el movimiento hacia adelante y la asignación de desreferencia. Algoritmos adecuados para salida de un solo paso.
3. Iterador hacia adelante (Iterador hacia adelante): admite operaciones de lectura y escritura y solo puede avanzar. Algoritmos para escaneos de múltiples pasadas.
4. Iterador bidireccional (iterador bidireccional): admite operaciones de lectura y escritura y puede avanzar y retroceder. Adecuado para algoritmos que requieren recorrido inverso.
5. Iterador de acceso aleatorio (Iterador de acceso aleatorio): admite operaciones de lectura y escritura y puede realizar saltos arbitrarios. Adecuado para algoritmos que requieren acceso aleatorio.

Tercero, el uso de iteradores.

Las clases de contenedor proporcionan métodos para obtener y manipular iteradores, como por ejemplo:

1. begin(): Devuelve un iterador que apunta al primer elemento del contenedor.
2. end(): Devuelve un iterador que apunta al último elemento del contenedor.
3. rbegin(): Devuelve un iterador inverso que apunta al último elemento del contenedor (solo contenedores de iteradores bidireccionales e iteradores de acceso aleatorio).
4. rend(): Devuelve un iterador inverso que apunta al frente del primer elemento del contenedor (solo contenedores de iteradores bidireccionales e iteradores de acceso aleatorio).

Cuando necesitamos atravesar el contenedor, podemos usar estos métodos proporcionados por el contenedor para obtener el iterador y luego usar el iterador para acceder y manipular los elementos en el contenedor.

A continuación se muestra std::vectorun ejemplo de cómo atravesar un contenedor utilizando iteradores:

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用 auto 关键字简化迭代器类型声明
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        std::cout << *it << std::endl; // 输出 numbers 容器中的每个元素
    }

    return 0;
}

En este ejemplo, numbers.begin()se devuelve un iterador que apunta al primer elemento del contenedor y un numbers.end()iterador que apunta más allá del último elemento del contenedor. Al incrementar el iterador ++it, podemos iterar sobre todos los elementos del contenedor.

Cuarto, principio del iterador.

La razón por la que los objetos iteradores están asociados con contenedores radica en el diseño y la implementación de los objetos iteradores. Un objeto iterador generalmente almacena información relacionada con una instancia de contenedor específica, como un puntero a un elemento en el contenedor u otros datos que representan la posición actual. Con esta información, los objetos iteradores pueden localizar y acceder a elementos en el contenedor. Si bien un objeto iterador es autónomo, está estrechamente vinculado a una instancia de contenedor particular porque necesita conocer la estructura interna del contenedor para realizar operaciones de recorrido y acceso.

Cuando obtiene un iterador utilizando las funciones miembro de un contenedor (por ejemplo begin(), , etc.), esas funciones crean un objeto iterador asociado con la instancia del contenedor. end()Este objeto iterador almacena suficiente información para recorrer elementos dentro del contenedor.

Tomemos, std::vectorpor ejemplo , cuando llamas std::vector<T>::begin(), devuelve un iterador que apunta al primer elemento del contenedor. Este iterador suele contener un puntero al primer elemento interior. Cuando incrementa un iterador (como ++it), este puntero se mueve según el diseño y el tipo de elementos en el contenedor para apuntar al siguiente elemento. De esta forma, el iterador puede realizar operaciones de recorrido y acceso según la estructura del contenedor.

Cabe señalar que la asociación del iterador al contenedor se establece en tiempo de ejecución, por lo que el objeto iterador debe mantenerse sincronizado con el contenedor desde el que se creó. Si el contenedor cambia (como agregar, eliminar elementos, etc.) durante la existencia del iterador, puede hacer que el iterador deje de ser válido. En este caso, continuar usando el iterador invalidado puede resultar en un comportamiento indefinido. Por lo tanto, cuando utilice iteradores, asegúrese de manejar estas situaciones correctamente, como actualizar el iterador a tiempo cuando cambie el contenedor.