An  iteratorius C ++  yra į rodyklę panašus objektas, nukreipiantis į STL konteinerio elementą. Paprastai jie naudojami per STL konteinerio turinį C ++. Pagrindinis STL iteratorių pranašumas yra tas, kad jie daro STL algoritmus nepriklausomai nuo naudojamo konteinerio tipo. Mes galime tiesiog perduoti iteratorių į konteinerio elementus, o ne patį konteinerį į STL algoritmus.

Iteratoriaus deklaracija

Kiekvienas konteineris C ++ STL turi savo iteratorių. Taigi mes turime paskelbti iteratorių kaip:

<type>::iterator it; 

Kur

• tipas: Konteinerio tipas, kuriam deklaruojamas iteratorius.
• tai: Vardas, priskirtas „Iterator“ objektui.

Tada galime jį inicijuoti priskirdami galiojantį iteratorių. Jei jau turime iteratorių, kuris bus priskirtas delcaracijos metu automatinis Raktinis žodis.

auto it = iter 

Kur iter Ar iteratorius, priskirtas naujai sukurtam IT iTeratoriui.

Mūsų C ++ kursas Apima Iteratorių naudojimą STL, užtikrinant, kad suprantate, kaip pereiti įvairius konteinerių tipus.

Iteratorių pavyzdys

Žemiau esanti programa iliustruoja, kaip naudoti iteratorių, norint apeiti vektoriaus konteinerį:

#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 

Kaip galbūt pastebėjote, mes naudojome vektorius :: Pradėti () ir vektorius :: pabaiga () funkcija. Šios funkcijos yra „STD :: Vector“ elemento funkcijos, kurios grąžina iteratorių į pirmąjį ir vieną elementą po paskutinio vektoriaus elemento. Mes naudojame iteratorių grąžą, kad būčiau šios funkcijos, kad pakartotumėte vektorius.

Konteinerio iteratoriaus funkcijos

C ++ STL teikia kai kurias narių funkcijas STL konteineris kurie grąžina iteratorius bent į pirmąjį ir paskutinį elementą. Šios narių funkcijos yra apibrėžtos beveik visame STL talpykloje (paliekant keletą ribotų prieigos konteinerių, pavyzdžiui, krūva eilutė ) su tuo pačiu nuoseklumo pavadinimu.

Šioje lentelėje pateikiami visi metodai, kurie grąžina iteratorių į konteinerius:

Pavyzdžiui, jei dalykas yra vektoriaus pavadinimas, tada mes galime naudoti aukščiau pateiktus metodus, kaip parodyta žemiau:

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

Iteratorių operacijos

Kaip ir rodyklės aritmetika, yra keletas operacijų, kurios leidžiamos C ++ iteratoriuose. Jie naudojami teikiant skirtingas funkcijas, kurios padidina iteratorių svarbą. Yra 5 galiojantys iteratoriaus operacijos C ++ :

• Iteratorių panaikinimas
• Papildymas/mažinimas iteratoriai
• Sveikojo skaičiaus pridėjimas/atimimas prie pakartojimų
• Atimti kitą iteratorių
• Palyginus iteratorius

Iteratorių panaikinimas

Nenusivertinimo operacija leidžia vartotojams Prieiga arba atnaujinimas Iteratoriaus nurodytos elemento vertė. Mes naudojame (*) Indirekcijos operatorius Norėdami panaikinti iteratorius, kaip ir rodyklės.

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

Kur new_val yra naujoji vertė, priskirta elementui, kurį nurodo iteratorius Tai .

Papildymas/mažinimas iteratoriai

Mes galime padidinti ar sumažinti iteratorių 1, naudodami (++) arba (-) operatoriai atitinkamai. Padidėjimo operacija perkelia iteratorių į kitą konteinerio elementą, o sumažinimo operacija perkelia iteratorių į ankstesnį elementą.

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

Sveikojo skaičiaus pridėjimas/atimimas prie pakartojimų

Taip pat galime pridėti ar atimti sveiką vertę iš iteratorių. Tai labiau pakartoja kitą ar ankstesnę poziciją pagal pridėtinę sveiką skaičių vertę.

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

Kur int_val yra sveiko skaičiaus vertės, kurios pridedamos arba atimamos iš iteratoriaus Tai .

Atimti kitą iteratorių

Mes galime atimti vieną iteratorių iš kito, kad rastume atstumą (arba elementų skaičių) tarp atminties, į kurią jie nurodo.

it1 - it2 

Palyginus iteratorius

Mes taip pat galime išbandyti du to paties tipo iteratorius vienas prieš kitą, kad surastume ryšį tarp jų. Mes galime naudoti reliacinius operatorius, tokius kaip (==) lygybė ir (! =) Nelygybės operatoriai kartu su kitais reliaciniais operatoriais, tokiais kaip< > <= >=.

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 

Iteratorių tipai C ++

STL iteratoriai gali būti padalyti remiantis operacijomis, kurias galima atlikti ant jų. „C ++“ yra 5 pagrindiniai iteratorių tipai, kurie išvardyti žemiau esančioje lentelėje kartu su palaikomais konteineriais ir palaikomomis iteratoriaus operacijomis.

Kaip mes galbūt pastebėjome iš aukščiau pateiktos lentelės, išskyrus įvesties ir išvesties iteratorius Eidami žemyn lentele, iteratoriaus tipas turi aukščiau iteratoriaus funkcijas kartu su keliomis naujomis funkcijomis.

Iteratoriaus adapteriai

Iteratoriaus adapteriai C ++ yra specialus iteratorių tipas, pastatytas virš tradicinių iteratorių, kad būtų užtikrintas specializuotas funkcionalumas. „C ++“ yra daug iteratorių adapterių, kurių kai kurie pateikiami žemiau:

Iteratoriaus naudingumo funkcijos C ++

„C ++ STL“ pateikia įvairias funkcijas, kaip supaprastinti darbą su iteratoriais. Jie išvardyti žemiau esančioje lentelėje:

Iteratorių programos su pavyzdžiais

Iteratoriai yra plačiai naudojami C ++ daugeliui skirtingų tikslų dirbant su STL konteineriais ir algoritmais. Toliau pateikiami kai kurie pagrindiniai iteratorių pritaikymai C ++, kurie yra jų kodo pavyzdžiai:

Kelionės konteineriai

STL konteineriai yra patys pagrindiniai iteratorių taikymas. Tuo metu mes naudojame pradžios () ir pabaigos () funkcijas, kad pradėtume ir baigtume iteratorius, kad apvažiuotume visą indą. Iš esmės mes palaikome pradžios iteratorių, kol jis nebus lygus galui.

Pavyzdys

#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 

Kaip parodyta aukščiau esančiame kode, mes einame nustatytą konteinerį. Panašiai mes galime naudoti tą patį požiūrį, kad apvažiuotume bet kurį konteinerį.

Atliekant talpyklą

Atvirkštiniai iteratoriai leidžia pervažiuoti indą nuo galo iki pradžios, nereikia rankiniu būdu tvarkyti atvirkštinio.

Pavyzdys

#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 

Nuo konteinerių nepriklausomi algoritmai

Iteratoriai leidžia algoritmams dirbti su bet kokiu konteinerio tipo gamybos funkcijomis, tokiomis kaip STD :: SOR () std :: Find () ir std :: for_each () lankstesnės. Vietoj tikrojo konteinerio galite perduoti iteratorius.

Pavyzdys

#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

Papildomos pakartojimų taikymo

Yra daugiau STL iteratorių programų:

• Atstumo skaičiavimas: Naudojant std :: Distance () iteratoriai padeda apskaičiuoti elementų skaičių tarp dviejų padėčių talpykloje.
• Srauto iteracija: Srauto iteratoriai leidžia gydyti įvesties/išvesties srautus, pavyzdžiui, konteinerius, todėl jį lengviau skaityti ir rašyti į srautus naudojant STL algoritmus.
• Perkelkite semantiką STL algoritmuose: Judėjimo iteratoriai pristato STL algoritmų judėjimo semantiką, kuri padeda padidinti našumą ir efektyvumą, vengiant nereikalingo kopijavimo. Duomenys bus perkelti pagal judėjimo semantikos taisykles.
• Individualūs duomenų struktūrų iteratoriai: Individualizuoti iteratoriai gali būti įdiegti ne STL duomenų struktūroms, tokioms kaip medžiai ar grafikai, kad būtų palaikoma STL algoritmams ir daugeliui kitų funkcijų. Mums gali tekti laikytis kelių taisyklių ir konvencijų rinkinio, kad būtų galima tinkamai padidinti mažinimą ir kitas operacijas.