Diferentes tipos de iteradores de bucle for basados ​​en rango en C++

Los bucles ‘for’ basados ​​en rangos se han incluido en el lenguaje desde C++11. Itera automáticamente (bucles) sobre el iterable (contenedor). Esto es muy eficiente cuando se usa con el contenedor de biblioteca estándar (como se usará en este artículo) ya que no habrá acceso incorrecto a la memoria fuera del alcance de iterable. El bucle comenzará y terminará automáticamente en el lugar correcto. 

Sintaxis:

for ( range_declaration : range_expression ) 
    loop_statement

Hay tres tipos diferentes de iteradores de bucles ‘for’ basados ​​en rangos, que son:

1. Iteradores normales:
en el iterador normal, una variable temporal ordinaria se declara como el iterador, y el iterador obtiene una copia del elemento del bucle actual por valor . Los cambios realizados en la copia temporal no se reflejarán en el iterable original.

Sintaxis:

for (datatype iterator : list)
{
  // operation are performed here 
}

• El iterador utilizado es un iterador normal de cualquier tipo de datos como int, float, double, etc., que se utiliza para iterar sobre cualquier tipo de contenedor.
• list puede ser cualquier tipo de contenedor.

Aquí está la implementación de los iteradores basados ​​en rangos normales:

// C++ program to implements
// normal iterators
 
#include <iostream>
#include <vector>
using namespace std;
 
// Function to implements
// normal iterators
void normal_iterator(vector<int> my_iterable)
{
 
    // Printing the iterable before making
    // any changes
    cout << "Value before modification: ";
    for (int my_iterator : my_iterable) {
        cout << my_iterator << " ";
    }
 
    // Case where the iterator
    // makes a temporary copy
    // of the current loop item
    for (int my_iterator : my_iterable) {
        // changing the value of the iterator
        my_iterator += 1;
    }
 
    cout << "\nValue after modification : ";
 
    // Printing the iterable
    // to see if any changes
    // has been made in the
    // original container or not
    for (int my_iterator : my_iterable) {
        cout << my_iterator << " ";
    }
}
// Driver Code
int main()
{
    // Initialising a standard
    // template container
    vector<int> my_iterable;
    my_iterable.push_back(101);
    my_iterable.push_back(102);
    my_iterable.push_back(103);
    my_iterable.push_back(104);
 
    normal_iterator(my_iterable);
 
    return 0;
}

Value before modification: 101 102 103 104 
Value after modification : 101 102 103 104

2. Iteradores
de referencia: los iteradores de referencia se declaran como una variable de referencia y el iterador obtiene el valor del elemento actual por referencia . Entonces, los cambios realizados dentro del bucle definitivamente se ven afectados en el contenedor original.

Sintaxis:

for (datatype & iterator : list)
{
  // operation are performed here 
}

• El iterador utilizado es un iterador normal de cualquier tipo de datos como int, float, double, etc., que se utiliza para iterar sobre cualquier tipo de contenedor.
• list puede ser cualquier tipo de contenedor.

Aquí está la implementación de los iteradores basados ​​en rangos normales:

// C++ program to implements
// reference iterators
 
#include <iostream>
#include <vector>
using namespace std;
 
// Function to implements
// reference iterators
void reference_iterator(vector<int> my_iterable)
{
 
    // Printing the iterable before
    // making any changes
    cout << "Value before modification: ";
    for (int my_iterator : my_iterable) {
        cout << my_iterator << " ";
    }
 
    // Iterating the container
    // using reference iterator
    // and updating the value
    for (int& my_iterator : my_iterable) {
 
        my_iterator += 1;
    }
 
    cout << "\nValue after modification : ";
    for (int my_iterator : my_iterable) {
        cout << my_iterator << " ";
    }
}
 
// Driver Code
int main()
{
    // Initialising a standard
    // template container
    vector<int> my_iterable;
    my_iterable.push_back(101);
    my_iterable.push_back(102);
    my_iterable.push_back(103);
    my_iterable.push_back(104);
 
    reference_iterator(my_iterable);
 
    return 0;
}

Value before modification: 101 102 103 104 
Value after modification : 102 103 104 105

3. Iteradores
constantes: los iteradores constantes se declaran como una referencia a una constante y, en este caso, no se realizará ninguna copia del elemento del bucle actual, lo que hará que la ejecución sea más rápida en comparación con los dos casos anteriores. Esto es útil en los casos en los que no queremos cambios accidentales en el valor del iterador o si estamos iterando sobre elementos grandes en un contenedor. Si intentaremos modificar el valor existente, el compilador mostrará errores.

Sintaxis:

for (const datatype iterator : list)
{
  // operation are performed here 
}

• El iterador utilizado es un iterador normal de cualquier tipo de datos como int, float, double, etc., que se utiliza para iterar sobre cualquier tipo de contenedor.
• list puede ser cualquier tipo de contenedor.

Aquí está la implementación de los iteradores basados ​​en rangos normales:

// C++ program to implements
// constant iterators
 
#include <iostream>
#include <vector>
using namespace std;
 
// Function to implements
// constant iterators
void reference_iterator(vector<int> my_iterable)
{
 
    // Printing the iterable
    // using constant iterator
    for (const int& my_iterator : my_iterable) {
 
        cout << my_iterator << " ";
 
        // Uncomment below line to see the error
        // my_iterator += 1 ;
    }
}
 
// Driver Code
int main()
{
    // Initialising a standard
    // template container
    vector<int> my_iterable;
    my_iterable.push_back(101);
    my_iterable.push_back(102);
    my_iterable.push_back(103);
    my_iterable.push_back(104);
 
    reference_iterator(my_iterable);
 
    return 0;
}

101 102 103 104