Un  Iterator în C ++  este un obiect asemănător pointerului care indică un element al containerului STL. În general, sunt utilizate pentru a se bucura prin conținutul recipientului STL în C ++. Principalul avantaj al iteratorilor STL este că acestea fac ca algoritmii STL să fie independenți de tipul de container utilizat. Putem trece doar iteratorul la elementele containerului în loc de containerul în sine la algoritmii STL.

Declarația iteratorului

Fiecare container din C ++ STL are propriul său iterator. Deci trebuie să declarăm un iterator ca:

<type>::iterator it; 

unde

• tip: Tipul de container pentru care este declarat iteratorul.
• IT: Numele atribuit obiectului iterator.

Îl putem inițializa apoi alocând un iterator valid. Dacă avem deja un iterator care trebuie atribuit în momentul delcarației, atunci putem omite declarația de tip folosind auto Cuvânt cheie.

auto it = iter 

unde iter este iteratorul atribuit iteratorului nou creat.

Noastre Curs C ++ Acoperă utilizarea iteratorilor în STL, asigurându -vă că înțelegeți cum să traversați diferite tipuri de containere.

Exemplu de iteratori

Programul de mai jos ilustrează modul de utilizare a iteratorului pentru a traversa containerul vectorial:

#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 

După cum ați observat că am folosit vector :: begin () și vector :: end () funcţie. Aceste funcții sunt funcțiile de membru la std :: vector care returnează iteratorul la primul și un element după ultimul element al vectorului. Folosim returnarea iteratorilor să fie aceste funcții pentru a itera vectorii.

Funcții de iterator de container

C ++ STL oferă unele funcții de membru în Container STL care returnează iteratorii la cel puțin primul și ultimul element. Aceste funcții de membru sunt definite în aproape tot recipientul STL (lăsând unele containere de acces limitate, cum ar fi stivă coadă ) cu același nume pentru consecvență.

Următorul tabel listează toate metodele care returnează iteratorul în containere:

De exemplu, dacă un lucru este numele vectorului, atunci putem folosi metodele de mai sus, așa cum se arată mai jos:

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

Operațiuni iteratoare

La fel ca aritmetica pointerului, există unele operații care sunt permise pe iteratorii C ++. Sunt folosite pentru a oferi funcționalități diferite care crește importanța iteratorilor. Există 5 valabile Operații iterator în C ++ :

• Dereferința iteratorilor
• Creșterea/decretarea iteratorilor
• Adăugarea/scăderea numărului întreg la iteratori
• Scăzând un alt iterator
• Compararea iteratorilor

Dereferința iteratorilor

Operațiunea de referință permite utilizatorilor acces sau actualizare Valoarea elementului indicat de iterator. Folosim (*) operator de indirecție la iteratori de referință la fel ca indicatorii.

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

unde new_val este noua valoare atribuită elementului indicat de iterator ea .

Creșterea/decretarea iteratorilor

Putem crește sau decreta iteratorul cu 1 folosind (++) sau (-) operatori respectiv. Operația de increment mută iteratorul la următorul element din container în timp ce operația de decrement mută iteratorul la elementul anterior.

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

Adăugarea/scăderea numărului întreg la iteratori

De asemenea, putem adăuga sau scădea o valoare întreagă din iteratori. Acesta va fi mai mult iteratorul următor sau poziția anterioară în funcție de valoarea adăugată a întregului.

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

unde Int_val este valorile întregi care sunt adăugate sau scăzute de la iterator ea .

Scăzând un alt iterator

Putem scădea un iterator de la altul pentru a găsi distanța (sau numărul de elemente) între memoria pe care o indică.

it1 - it2 

Compararea iteratorilor

De asemenea, putem testa cei doi iteratori de același tip unul față de celălalt pentru a găsi relația dintre ele. Putem folosi operatorii relaționali precum (==) egalitate și (! =) Operatori de inegalitate împreună cu alți operatori relaționali, cum ar fi< > <= >=.

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 

Tipuri de iteratori în C ++

Iteratoarele STL pot fi împărțite pe baza operațiunilor care pot fi efectuate pe ele. Există 5 tipuri principale de iteratori în C ++, care sunt enumerate în tabelul de mai jos, împreună cu containerele acceptate și operațiunile de iterator acceptate.

După cum am putut observa din tabelul de mai sus, în afară de iteratorii de intrare și ieșire Pe măsură ce coborâm pe tabel, tipul iterator conține caracteristicile iteratorului de mai sus împreună cu câteva caracteristici noi.

Adaptoare iterator

Adaptoarele de iterator în C ++ sunt tipul special de iteratori care sunt construiți pe iteratori tradiționali pentru a oferi funcționalități specializate. Există multe adaptoare de iterator în C ++ unele dintre ele fiind prezentate mai jos:

Iterator funcții de utilitate în C ++

C ++ STL oferă diverse funcții pentru a simplifica lucrările cu iteratorii. Sunt listate în tabelul de mai jos:

Aplicații de iteratori cu exemple

Iteratoarele sunt utilizate pe scară largă în C ++ în mai multe scopuri diferite, în timp ce lucrați cu containere și algoritmi STL. Urmează câteva aplicații primare ale iteratorilor în C ++ pe care le exemple de cod:

Traversarea containerelor

Traversarea containerelor STL este cea mai de bază aplicație a iteratorilor. În aceasta folosim funcțiile Begin () și End () pentru a obține iteratoarele început și sfârșit pentru a traversa întregul recipient. Practic, continuăm să creștem iteratorul de început până când nu este egal cu sfârșitul.

Exemplu

#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 

Așa cum se arată în codul de mai sus, traversăm containerul set. În mod similar, putem folosi aceeași abordare pentru a traversa orice container.

Inversarea unui container

Iteratoarele inversă vă permit să parcurgeți un recipient de la sfârșit până la început, fără a fi nevoie să gestionați manual inversarea.

Exemplu

#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 

Algoritmi independenți de containere

Iteratoarele permit algoritmilor să funcționeze cu orice tip de container care să facă funcții precum std :: sort () std :: find () și std :: for_each () mai flexibil. Puteți trece iteratori în loc de containerul propriu -zis.

Exemplu

#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

Aplicații suplimentare ale iteratorilor

Există mai multe aplicații de iteratori STL:

• Calculul distanței: Utilizarea iteratorilor std :: distanță () ajută la calcularea numărului de elemente între două poziții într -un container.
• Iterarea fluxului: Iteratoarele de flux vă permit să tratați fluxurile de intrare/ieșire, cum ar fi containerele care facilitează citirea și scrierea la fluxuri folosind algoritmi STL.
• Mutați semantica în algoritmi STL: Move Iterators introduce semantica de mișcare în algoritmii STL, ceea ce ajută la creșterea performanței și eficienței, evitând copierea inutilă. Datele vor fi mutate în conformitate cu regulile semanticii de mișcare.
• Iteratori personalizați pentru structuri de date: Iteratoarele personalizate pot fi implementate pentru structuri de date non-STL, cum ar fi copaci sau grafice, pentru a oferi suportul pentru algoritmi STL și multe alte caracteristici. Este posibil să fie nevoie să urmărim câteva seturi de reguli și convenții pentru a oferi o scădere corespunzătoare și alte operațiuni.