Introducción a los iteradores en C++

un iteradores un objeto (como un puntero) que apunta a un elemento dentro del contenedor. Podemos usar iteradores para movernos por el contenido del contenedor. Se pueden visualizar como algo similar a un puntero que apunta a alguna ubicación y podemos acceder al contenido en esa ubicación en particular usándolos. Los iteradores juegan un papel fundamental en la conexión del algoritmo con los contenedores junto con la manipulación de los datos almacenados dentro de los contenedores. La forma más obvia de un iterador es un puntero. Un puntero puede apuntar a elementos en una array y puede iterar a través de ellos usando el operador de incremento (++). Pero no todos los iteradores tienen una funcionalidad similar a la de los punteros. Dependiendo de la funcionalidad de los iteradores, se pueden clasificar en cinco categorías,

Ahora, cada uno de estos iteradores no es compatible con todos los contenedores en STL, diferentes contenedores admiten diferentes iteradores, como los vectores admiten iteradores de acceso aleatorio , mientras que las listas admiten iteradores bidireccionales. La lista completa es la siguiente: Tipos de iteradores : según la funcionalidad de los iteradores, se pueden clasificar en cinco categorías principales:

1. Iteradores de entrada : son los más débiles de todos los iteradores y tienen una funcionalidad muy limitada. Solo se pueden utilizar en algoritmos de un solo paso, es decir, aquellos algoritmos que procesan el contenedor de forma secuencial, de modo que no se accede a ningún elemento más de una vez.
2. Iteradores de salida : al igual que los iteradores de entrada , también tienen una funcionalidad muy limitada y solo se pueden usar en algoritmos de un solo paso, pero no para acceder a elementos, sino para que se les asignen elementos.
3. Iterador directo : están más arriba en la jerarquía que los iteradores de entrada y salida , y contienen todas las características presentes en estos dos iteradores. Pero, como sugiere el nombre, también pueden moverse solo en una dirección hacia adelante y también un paso a la vez.
4. Iteradores bidireccionales : tienen todas las características de los iteradores directos además del hecho de que superan el inconveniente de los iteradores directos , ya que pueden moverse en ambas direcciones, por eso su nombre es bidireccional.
5. Iteradores de acceso aleatorio : son los iteradores más potentes. No se limitan a moverse secuencialmente, como su nombre indica, pueden acceder aleatoriamente a cualquier elemento dentro del contenedor. Son aquellos cuya funcionalidad es la misma que la de los punteros.

El siguiente diagrama muestra la diferencia en su funcionalidad con respecto a varias operaciones que pueden realizar.

Beneficios de los iteradores

Ciertamente, hay bastantes formas que muestran que los iteradores son extremadamente útiles para nosotros y nos alientan a usarlos profundamente. Algunos de los beneficios de usar iteradores se enumeran a continuación:

• Conveniencia en la programación: es mejor usar iteradores para iterar a través del contenido de los contenedores como si no usáramos un iterador y accediéramos a los elementos usando el operador [], entonces siempre debemos preocuparnos por el tamaño del contenedor, mientras que con los iteradores simplemente podemos usar la función miembro end() e iterar a través de los contenidos sin tener que tener nada en cuenta. 

// C++ program to demonstrate iterators
 
#include <iostream>
#include <vector>
using namespace std;
int main()
{
    // Declaring a vector
    vector<int> v = { 1, 2, 3 };
 
    // Declaring an iterator
    vector<int>::iterator i;
 
    int j;
 
    cout << "Without iterators = ";
     
    // Accessing the elements without using iterators
    for (j = 0; j < 3; ++j)
    {
        cout << v[j] << " ";
    }
 
    cout << "\nWith iterators = ";
     
    // Accessing the elements using iterators
    for (i = v.begin(); i != v.end(); ++i)
    {
        cout << *i << " ";
    }
 
    // Adding one more element to vector
    v.push_back(4);
 
    cout << "\nWithout iterators = ";
     
    // Accessing the elements without using iterators
    for (j = 0; j < 4; ++j)
    {
        cout << v[j] << " ";
    }
 
    cout << "\nWith iterators = ";
     
    // Accessing the elements using iterators
    for (i = v.begin(); i != v.end(); ++i)
    {
        cout << *i << " ";
    }
 
    return 0;
}

Producción:

Without iterators = 1 2 3
With iterators = 1 2 3
Without iterators = 1 2 3 4
With iterators = 1 2 3 4

Explicación: como se puede ver en el código anterior, sin usar iteradores, necesitamos realizar un seguimiento de los elementos totales en el contenedor. Al principio solo había tres elementos, pero después de que se insertó un elemento más en él, en consecuencia, el bucle for también tuvo que modificarse, pero usando iteradores, ambos el tiempo que el bucle for permaneció igual. Entonces, el iterador facilitó nuestra tarea.

• Reutilización de código: Ahora considere si hacemos v una lista en lugar de un vector en el programa anterior y si no estuviéramos usando iteradores para acceder a los elementos y solo usando el operador [ ], entonces en ese caso esta forma de acceso no servía para list (ya que no admiten iteradores de acceso aleatorio ). Sin embargo, si estuviéramos usando iteradores para que los vectores accedan a los elementos, simplemente cambiar el vector a la lista en la declaración del iterador habría cumplido el propósito, sin hacer nada más. Entonces, los iteradores admiten la reutilización del código, ya que se pueden usar para acceder a elementos de cualquier contenedor.
• Procesamiento dinámico del contenedor: los iteradores nos brindan la capacidad de agregar o eliminar dinámicamente elementos del contenedor cuando queramos con facilidad. 

// C++ program to demonstrate iterators
 
#include <iostream>
#include <vector>
using namespace std;
int main()
{
    // Declaring a vector
    vector<int> v = { 1, 2, 3 };
 
    // Declaring an iterator
    vector<int>::iterator i;
 
    int j;
 
    // Inserting element using iterators
    for (i = v.begin(); i != v.end(); ++i) {
        if (i == v.begin()) {
            i = v.insert(i, 5);
            // inserting 5 at the beginning of v
        }
    }
     
    // v contains 5 1 2 3
 
    // Deleting a element using iterators
    for (i = v.begin(); i != v.end(); ++i) {
        if (i == v.begin() + 1) {
            i = v.erase(i);
            // i now points to the element after the
            // deleted element
        }
    }
     
    // v contains 5 2 3
 
    // Accessing the elements using iterators
    for (i = v.begin(); i != v.end(); ++i) {
        cout << *i << " ";
    }
 
    return 0;
}

Producción:

5 2 3

Explicación: como se ve en el código anterior, podemos agregar y eliminar elementos del contenedor de manera fácil y dinámica usando el iterador; sin embargo, hacer lo mismo sin usarlos habría sido muy tedioso, ya que requeriría cambiar los elementos cada vez antes de la inserción y después. supresión.

Este artículo es una contribución de Mrigendra Singh . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.