Requisito previo: Iteradores en STL
Los iteradores son objetos similares a los punteros que se utilizan para iterar sobre una secuencia y manipular los elementos del contenedor. La ventaja de usar un iterador es que reduce las líneas de código a una sola declaración, ya que nos permiten manipular las arrays integradas en el STL usando punteros como iteradores. Un iterador puede ser un iterador constante o no constante/regular.
Iteradores constantes:
Un iterador const apunta a un elemento de tipo constante, lo que significa que el elemento al que apunta un const_iterator no se puede modificar. Aunque todavía podemos actualizar el iterador (es decir, el iterador se puede incrementar o disminuir, pero el elemento al que apunta no se puede cambiar). Solo se puede usar para acceder y no se puede usar para modificar. Si tratamos de modificar el valor del elemento usando const iterator entonces genera un error .
Iteradores regulares:
Un const_iterator normal o no apunta a un elemento dentro del contenedor y puede usarse para modificar el elemento al que apunta. Los iteradores regulares 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 regular 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(++) . Cada tipo de contenedor tiene un tipo de iterador regular específico diseñado para iterar a través de sus elementos.
A continuación se muestra un programa en C++ para demostrar la diferencia en el funcionamiento de los dos iteradores:
C++
// C++ program to demonstrate a regular
// and const_iterator
#include <iostream>
#include <iterator>
#include <vector>
using namespace std;
// Function that demonstrate regular
// iterators
void regularIterator(vector<int>& v)
{
// Declare a regular iterator
// to a vector
vector<int>::iterator i;
// Printing the elements of the
// vector v using regular iterator
for (i = v.begin(); i < v.end(); i++) {
// Update elements of vector
*i += 1;
cout << *i << " ";
}
}
// Function that demonstrate const
// iterators
void constIterator(vector<int>& v1)
{
// Declare a const_itearor
// to a vector
vector<int>::const_iterator ci;
// Printing the elements of the
// vector v1 using regular iterator
for (ci = v1.begin(); ci < v1.end(); ci++) {
// Below line will throw an error
// as we are trying to modify the
// element to which const_iterator
// is pointing
//*ci += 1;
cout << *ci << " ";
}
}
// Driver Code
int main()
{
// Declaring vectors
vector<int> v = { 7, 2, 4 };
vector<int> v1 = { 5, 7, 0 };
// Demonstrate Regular iterator
regularIterator(v);
cout << endl;
// Demonstrate Const iterator
constIterator(v1);
return 0;
}
8 3 5 5 7 0