Un  iterador en C++  es un objeto similar a un puntero que apunta a un elemento del contenedor STL. Generalmente se utilizan para recorrer el contenido del contenedor STL en C++. La principal ventaja de los iteradores STL es que hacen que los algoritmos STL sean independientes del tipo de contenedor utilizado. Podemos simplemente pasar el iterador a los elementos del contenedor en lugar del propio contenedor a los algoritmos STL.

Declaración de iterador

Cada contenedor en C++ STL tiene su propio iterador. Entonces tenemos que declarar un iterador como:

<type>::iterator it; 

dónde

• tipo: Tipo de contenedor para el que se declara el iterador.
• él: Nombre asignado al objeto iterador.

Luego podemos inicializarlo asignando algún iterador válido. Si ya tenemos un iterador para asignar en el momento de la declaración, entonces podemos omitir la declaración de tipo usando el auto palabra clave.

auto it = iter 

dónde iterar es el iterador asignado al iterador it recién creado.

Nuestro Curso C++ cubre el uso de iteradores en STL, lo que garantiza que comprenda cómo atravesar diferentes tipos de contenedores.

Ejemplo de iteradores

El siguiente programa ilustra cómo utilizar el iterador para atravesar el contenedor de vectores:

#include    using namespace std; int main() {  vector<int> v = {1 2 3 4 5};  // Defining an iterator pointing to  // the beginning of the vector  vector<int>::iterator first =  v.begin();  // Defining an iterator pointing  // to the end of the vector  vector<int>::iterator last =  v.end();    // Iterating the whole vector  while(first != last) {  cout << *first << ' ';  first++;  }  return 0; } 

1 2 3 4 5 

Como habrás notado, hemos utilizado vector::comienzo() y vector::fin() función. Estas funciones son las funciones miembro de std::vector que devuelven el iterador al primer elemento y un elemento después del último elemento del vector. Usamos el retorno de iteradores de estas funciones para iterar los vectores.

Funciones de iterador de contenedor

C++ STL proporciona algunas funciones miembro en Contenedor STL que devuelven los iteradores al menos al primer y al último elemento. Estas funciones miembro están definidas en casi todo el contenedor STL (dejando algunos contenedores de acceso limitado como pila cola ) con el mismo nombre por coherencia.

La siguiente tabla enumera todos los métodos que devuelven el iterador a los contenedores:

Por ejemplo si una cosa es el nombre del vector, entonces podemos usar los métodos anteriores como se muestra a continuación:

vec.begin() vec.rbegin() vec.cbegin() vec.crbegin() vec.end() vec.rend()  vec.cend() vec.crend() 

Operaciones de iteradores

Al igual que la aritmética de punteros, hay algunas operaciones que están permitidas en los iteradores de C++. Se utilizan para proporcionar diferentes funcionalidades que aumentan la importancia de los iteradores. Hay 5 válidos operaciones de iterador en C++ :

• Iteradores de desreferenciación
• Iteradores incrementales/decrementantes
• Sumar/Restar números enteros a iteradores
• Restando otro iterador
• Comparando iteradores

Iteradores de desreferenciación

La operación de desreferenciación permite a los usuarios acceder o actualizar el valor del elemento señalado por el iterador. Usamos el (*) operador de indirección para desreferenciar iteradores como si fueran punteros.

// Access *it; // Update *it = new_val;  

dónde nuevo_val es el nuevo valor asignado al elemento señalado por el iterador él .

Iteradores incrementales/decrementantes

Podemos incrementar o disminuir el iterador en 1 usando Operadores (++) o (--) respectivamente. La operación de incremento mueve el iterador al siguiente elemento en el contenedor mientras que la operación de decremento mueve el iterador al elemento anterior.

it++; // post-increment ++it; // pre-increment it--; // post-decrement --it; // pre-decrement 

Sumar/Restar números enteros a iteradores

También podemos sumar o restar un valor entero de los iteradores. Aumentará la posición anterior o siguiente del iterador según el valor entero agregado.

// Addition it + int_val;  // Subtraction it - int_val;  

dónde valor_int son los valores enteros que se suman o restan del iterador él .

Restando otro iterador

Podemos restar un iterador de otro para encontrar la distancia (o el número de elementos) entre la memoria a la que apuntan.

it1 - it2 

Comparando iteradores

También podemos probar los dos iteradores del mismo tipo entre sí para encontrar la relación entre ellos. Podemos usar operadores relacionales como (==) igualdad y (!=) desigualdad junto con otros operadores relacionales como< > <= >=.

it1 != it2 // Equal to it1 == it2 // Not equal to it1 > it2 // Greater than it1 < it2 // Less than it1 >= it2 // Greater than equal to it1 <= it2 // Less than equal to 

Tipos de iteradores en C++

Los iteradores STL se pueden dividir según las operaciones que se pueden realizar en ellos. Hay cinco tipos principales de iteradores en C++ que se enumeran en la siguiente tabla junto con los contenedores admitidos y las operaciones de iterador admitidas.

Como habrámos notado en la tabla anterior, aparte de los iteradores de entrada y salida A medida que avanzamos en la tabla, el tipo de iterador contiene las características del iterador anterior junto con algunas características nuevas.

Adaptadores de iterador

Los adaptadores de iterador en C++ son el tipo especial de iteradores que se crean sobre iteradores tradicionales para proporcionar funcionalidad especializada. Hay muchos adaptadores de iterador en C++, algunos de los cuales se detallan a continuación:

Funciones de utilidad iterador en C++

C++ STL proporciona diversas funciones para simplificar el trabajo con iteradores. Se enumeran en la siguiente tabla:

Aplicaciones de iteradores con ejemplos

Los iteradores se utilizan ampliamente en C++ para muchos propósitos diferentes mientras se trabaja con contenedores y algoritmos STL. A continuación se muestran algunas aplicaciones principales de iteradores en C++ cuyos ejemplos de código son:

Atravesando contenedores

Atravesar contenedores STL es la aplicación más básica de los iteradores. En esto usamos las funciones comenzar() y finalizar() para hacer que los iteradores de inicio y fin atraviesen todo el contenedor. Básicamente seguimos incrementando el iterador inicial hasta que no sea igual al final.

Ejemplo

#include    using namespace std; int main() {  set<int> s = {10 20 30   40 50};  // Iterator to the beginning   // of the set  auto it = s.begin();  // Iterating through the   // entire set  while (it != s.end()) {    // Dereferencing iterator   // to access value  cout << *it << ' ';    // Incrementing the   // iterator  it++;  }    return 0; } 

10 20 30 40 50 

Como se muestra en el código anterior, atravesamos el contenedor establecido. De manera similar, podemos utilizar el mismo enfoque para atravesar cualquier contenedor.

Invertir un contenedor

Los iteradores inversos le permiten recorrer un contenedor desde el final hasta el principio sin necesidad de manejar manualmente la inversión.

Ejemplo

#include    using namespace std; int main() {  vector<int> vec = {10 20 30   40 50};  // Defining reverse iterators   // pointing to the reverse   // beginning of vec  auto it = vec.rbegin();  // Iterating the whole   // vector in reverse  while (it != vec.rend()) {  cout << *it << ' ';  it++;  }  return 0; } 

50 40 30 20 10 

Algoritmos independientes del contenedor

Los iteradores permiten que los algoritmos funcionen con cualquier tipo de contenedor, lo que hace que funciones como std::sort() std::find() y std::for_each() sean más flexibles. Puede pasar iteradores en lugar del contenedor real.

Ejemplo

#include    using namespace std; int main() {  vector<int> vec = {30 10 40   10 50};  multiset<int> ms = {10 30 10   20 40 10};  // Using the std::count() algorithm to count  // the number of occurences of 10 in vector  // and multiset using iterator  cout << '10s in Vector: '   << count(vec.begin()  vec.end() 10) << endl;  cout << '10s in Multiset: '   << count(ms.begin()  ms.end() 10);  return 0; } 

10s in Vector: 2 10s in Multiset: 3

Aplicaciones adicionales de iteradores

Hay más aplicaciones de iteradores STL:

• Cálculo de distancia: El uso de iteradores std::distance() ayuda a calcular la cantidad de elementos entre dos posiciones en un contenedor.
• Iteración de flujo: Los iteradores de flujo le permiten tratar flujos de entrada/salida como contenedores, lo que facilita la lectura y escritura de flujos utilizando algoritmos STL.
• Mover semántica en algoritmos STL: Los iteradores de movimiento introducen la semántica de movimiento en los algoritmos STL, lo que ayuda a aumentar el rendimiento y la eficiencia al evitar copias innecesarias. Los datos se moverán según las reglas de la semántica de movimiento.
• Iteradores personalizados para estructuras de datos: Se pueden implementar iteradores personalizados para estructuras de datos que no son STL, como árboles o gráficos, para brindar soporte para algoritmos STL y muchas otras características. Es posible que debamos seguir un conjunto de reglas y convenciones para proporcionar operaciones incrementales, decrementales y otras operaciones adecuadas.