Iteratori di input

Input Iterator è un iteratore usato per leggere i valori dal contenitore. Gli iteratori di input sono i «più deboli» tra tutti gli iteratori perché hanno funzionalità limitate. Tuttavia, questo li rende semplici e facili da capire.
Vengono usati soprattutto nelle operazioni di input sequenziali, in cui ogni valore viene indicato dall’iteratore una sola volta e poi l’iteratore viene incrementato, molto spesso usando l’operatore ++ per incrementare l’iteratore di uno.

Come possiamo vedere, l’iteratore forward, l’iteratore bidirezionale e l’iteratore ad accesso casuale sono tutti iteratori di input validi.

Impareremo quindi le caratteristiche di un Input Iterator.

• Operatore di uguaglianza/disuguaglianza
  Un iteratore di input può essere confrontato usando un operatore di uguaglianza o disuguaglianza. I due iteratori sono uguali solo quando puntano entrambi alla stessa posizione. 

A == B // Uguaglianza
A != B // Disuguaglianza

Vediamo un esempio in cui verificheremo se due iteratori puntano alla stessa posizione.

vector<int> numbers = {1, 2, 3, 4, 5};
vector<int>::iterator it1, it2;

it1 = numbers.begin();
it2 = numbers.begin() + 1;

if(it1 == it2)
	cout << "Both iterators are equal.";
else
	cout << "Both iterators are not equal.";

Output:
Both iterators are not equal.

Nell’esempio precedente, dichiariamo gli iteratori chiamati it1 e it2 usando vector<int>::iterator. In seguito assegniamo loro dei valori. L’iteratore it1 contiene la posizione del primo elemento tramite il metodo begin(). L’iteratore it2 contiene invece la posizione del secondo elemento, perché abbiamo incrementato di uno il valore restituito dal metodo begin(). Ecco perché l’output del programma indica che i due iteratori non sono uguali.

• Dereferenziazione
  Un iteratore di input può essere dereferenziato usando l’operatore *. Se visualizziamo il valore dereferenziato dell’iteratore, otteniamo il valore effettivo dell’elemento a cui punta l’iteratore.

*A // Dereferenzia con *

vector<int> numbers = {1, 2, 3, 4, 5};
vector<int>::iterator it1, it2;

it1 = numbers.begin();
it2 = numbers.begin() + 1;

cout << *it1 << endl;
cout << *it2;

Output:
1
2

Nell’esempio precedente abbiamo esattamente lo stesso caso del primo. L’iteratore it1 punta al primo elemento del vettore e l’iteratore it2 punta al secondo elemento del vettore. Quando visualizziamo i valori dereferenziati degli iteratori, otteniamo i valori effettivi del primo e del secondo elemento del vettore.
Quindi, se vogliamo visualizzare il valore della variabile o dell’elemento a cui punta l’iteratore, usiamo l’operatore *

• Incrementabile
  Un iteratore di input può essere incrementato, così da riferirsi all’elemento successivo della sequenza dopo l’incremento. A questo scopo usiamo l’operatore ++

A++ // Operatore di post-incremento
++A // Operatore di pre-incremento

vector<int> numbers = {1, 2, 3, 4, 5};
vector<int>::iterator it1;

it = numbers.begin();
cout << "First value is: " << *it << " ";

it++;
cout << "Second value is: " << *it << " ";

++it;
cout << "Third value is: " << *it;

Output:
1 2 3

Nell’esempio precedente dichiariamo un iteratore it, che punta al primo elemento del vettore. Visualizziamo il primo elemento del vettore e poi incrementiamo l’iteratore di uno, in modo che punti al secondo elemento, e così via.

• Scambiabile
  È possibile scambiare due iteratori che puntano a posizioni diverse. Possiamo farlo usando una variabile temporanea, come mostrato di seguito.

vector<int> numbers = {1, 2, 3, 4, 5};
vector<int>::iterator it1, it2, temp;

it1 = numbers.begin();
it2 = numbers.begin() + 1;

cout << *it1 << " " << *it2 << endl;

temp = it1;
it1 = it2;
it2 = temp;

cout << *it1 << " " << *it2 << endl;

Output:
1 2
2 1

Nell’esempio precedente dichiariamo i due iteratori e assegniamo la posizione del primo elemento al primo iteratore e quella del secondo elemento al secondo iteratore. Visualizziamo i due elementi e scambiamo i valori degli iteratori. Di conseguenza, il primo iteratore punta al secondo elemento e il secondo iteratore punta al primo, come si può vedere nell’output.