Tāds  iterators C ++  ir rādītājam līdzīgs objekts, kas norāda uz STL konteinera elementu. Tos parasti izmanto, lai cilpotu caur STL konteinera saturu C ++. Galvenā STL iteratoru priekšrocība ir tā, ka tie padara STL algoritmus neatkarīgi no izmantotā konteinera veida. Mēs varam vienkārši nodot iteratoru konteinera elementiem, nevis pašam konteineram uz STL algoritmiem.

Iteratora deklarācija

Katram C ++ STL konteineram ir savs iterators. Tāpēc mums ir jāpaziņo iteratoram kā:

<type>::iterator it; 

kur

• Tips: Konteinera tips, par kuru tiek deklarēts iterators.
• tas: Vārds, kas piešķirts iterator objektam.

Pēc tam mēs to varam inicializēt, piešķirot kādu derīgu iteratoru. Ja mums jau ir iterators, kas jāpiešķir Delcaration laikā, mēs varam izlaist tipa deklarāciju, izmantojot auto Atslēgvārds.

auto it = iter 

kur iters ir iterators, kas piešķirts jaunizveidotajam iteratoram.

Mūsu C ++ kurss Ietver iteratoru izmantošanu STL, nodrošinot, ka saprotat, kā šķērsot dažādus konteineru veidus.

Iteratoru piemērs

Zemāk esošā programma parāda, kā izmantot iteratoru, lai šķērsotu vektora konteineru:

#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 

Kā jūs, iespējams, pamanījāt, ka esam izmantojuši Vector :: sākas () un vektors :: beigas () funkcija. Šīs funkcijas ir STD :: vektora locekļu funkcijas, kas atgriež iteratoru pirmajā un vienā elementā pēc vektora pēdējā elementa. Mēs izmantojam iteratoru atgriešanu, ja šīs funkcijas atkārto vektorus.

Konteinera iteratora funkcijas

C ++ STL nodrošina dažas dalībnieku funkcijas STL konteiners Tas atgriež iteratorus vismaz uz pirmo un pēdējo elementu. Šīs locekļu funkcijas ir noteiktas gandrīz visos STL konteinerā (atstājot dažus ierobežotus piekļuves konteinerus, piemēram, kaudze rinda ) ar tādu pašu konsekvences nosaukumu.

Šajā tabulā ir uzskaitītas visas metodes, kas iteratoru atgriež konteineros:

Piemēram, ja lieta ir vektora nosaukums, tad mēs varam izmantot iepriekšminētās metodes, kā parādīts zemāk:

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

Iteratoru operācijas

Tāpat kā rādītāja aritmētika, ir dažas operācijas, kas ir atļautas C ++ iteratoriem. Tos izmanto, lai nodrošinātu dažādas funkcijas, kas palielina iteratoru nozīmi. Ir 5 derīgi iteratora operācijas C ++ :

• Atkārtotie iteratori
• Iteratoru palielināšana/samazināšana
• Iteratoru pievienošana/atņemšana iteratoriem
• Atņemot citu iteratoru
• Salīdzinot iteratorus

Atkārtotie iteratori

Dereferencēšanas operācija ļauj lietotājiem veikt Piekļuve vai atjaunināšana Iteratora norādītā elementa vērtība. Mēs izmantojam (*) Indikācijas operators lai atceltu iteratorus tāpat kā norādes.

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

kur new_val ir jaunā vērtība, kas piešķirta elementam, kuru norāda iterators tas Apvidū

Iteratoru palielināšana/samazināšana

Mēs varam palielināt vai samazināt iteratoru ar 1, izmantojot (++) vai (-) operatori attiecīgi. Palielināšanas darbība pārvieto iteratoru uz nākamo konteinera elementu, kamēr samazināšanas darbība pārvieto iteratoru uz iepriekšējo elementu.

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

Iteratoru pievienošana/atņemšana iteratoriem

No iteratoriem mēs varam arī pievienot vai atņemt veselu skaitli. Tas vairāk būs nākamais iterators vai iepriekšējā pozīcijā saskaņā ar pievienoto veselo skaitli.

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

kur int_val ir veseli skaitļi, kas tiek pievienoti vai atņemti no iteratora tas Apvidū

Atņemot citu iteratoru

Mēs varam atņemt vienu iteratoru no otra, lai atrastu attālumu (vai elementu skaitu) starp atmiņu, uz kuru viņi norāda.

it1 - it2 

Salīdzinot iteratorus

Mēs varam arī pārbaudīt abus viena veida iteratorus viens pret otru, lai atrastu attiecības starp tiem. Mēs varam izmantot relāciju operatorus, piemēram, (==) vienlīdzību un (! =) Nevienlīdzības operatorus kopā ar citiem relāciju operatoriem, piemēram,< > <= >=.

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 

Iteratoru veidi C ++

STL iteratorus var sadalīt, pamatojoties uz operācijām, kuras var veikt. C ++ ir 5 galvenie iteratoru veidi, kas uzskaitīti zemāk esošajā tabulā kopā ar atbalstītajiem konteineriem un atbalstītām iteratora operācijām.

Kā mēs, iespējams, pamanījām no iepriekš minētās tabulas, izņemot ieejas un izvades iteratorus Kad mēs ejam pa tabulu, iteratora tips satur virs iteratora funkcijas, kā arī dažas jaunas funkcijas.

Iteratora adapteri

Iterator adapteri C ++ ir īpašs iteratoru veids, kas veidots virs tradicionālajiem iteratoriem, lai nodrošinātu specializētu funkcionalitāti. C ++ ir daudz iteratora adapteru, no kuriem daži ir norādīti zemāk:

Iteratora lietderības funkcijas C ++

C ++ STL nodrošina dažādas funkcijas, lai vienkāršotu darbu ar iteratoriem. Tie ir uzskaitīti zemāk esošajā tabulā:

Iteratoru pielietojumi ar piemēriem

Iteratori tiek plaši izmantoti C ++ daudzos dažādos mērķos, strādājot ar STL konteineriem un algoritmiem. Tālāk ir daži galvenie iteratoru pielietojumi C ++, kuru koda piemēri:

Šķērsojot konteinerus

Pārejot STL konteinerus, ir visvienkāršākais iteratoru pielietojums. Šajā sakarā mēs izmantojam sākuma () un beigu () funkcijas, lai sāktu un gala iteratorus, lai šķērsotu visu konteineru. Būtībā mēs turpinām palielināt sākuma iteratoru, līdz tas nav vienāds ar beigām.

Piemērs

#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 

Kā parādīts iepriekš minētajā kodā, mēs šķērsojam komplekta konteineru. Līdzīgi mēs varam izmantot to pašu pieeju, lai šķērsotu jebkuru konteineru.

Konteinera apvēršana

Reversie iteratori ļauj jums šķērsot konteineru no beigām līdz sākumam, manuāli rīkojoties ar apgriezienu.

Piemērs

#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 

No konteineriem neatkarīgi algoritmi

Iteratori ļauj algoritmiem strādāt ar jebkurām konteineru tipa veidošanas funkcijām, piemēram, std :: sort () std :: find () un std :: for_each () elastīgāka. Faktiskā konteinera vietā varat nodot iteratorus.

Piemērs

#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

Iteratoru papildu pielietojumi

Ir vairāk STL iteratoru pielietojumu:

• Attāluma aprēķins: Izmantojot std :: attālumu () iteratori, palīdz aprēķināt elementu skaitu starp divām pozīcijām konteinerā.
• Straumes iterācija: Straumes iteratori ļauj ārstēt ievades/izvades plūsmas, piemēram, konteinerus, padarot to vieglāku lasīšanu no straumēm un rakstīt, izmantojot STL algoritmus.
• Pārvietojiet semantiku STL algoritmos: Pārvietot iteratorus ievieš STL algoritmos SIT semantiku, kas palīdz palielināt veiktspēju un efektivitāti, izvairoties no nevajadzīgas kopēšanas. Dati tiks pārvietoti saskaņā ar pārcelšanās semantikas noteikumiem.
• Pielāgoti iteratori datu struktūrām: Pielāgotus iteratorus var ieviest ne-STL datu struktūrām, piemēram, kokiem vai grafikiem, lai sniegtu atbalstu STL algoritmiem un daudzām citām funkcijām. Mums, iespējams, būs jāievēro daži noteikumu un konvenciju kopums, lai nodrošinātu pienācīgu pieaugumu samazināšanu un citas operācijas.