iterators stl
O prezentare completă a iteratorilor din STL.
În acest tutorial, vom analiza detaliile iteratorilor, tipurile, avantajele și diferitele funcții pe care le acceptă.
Întrebări și răspunsuri de interviuri cu server SQL pentru o experiență de 5 ani
Ce este un Iterator? În general, un iterator este la fel ca orice obiect care indică un anumit element dintr-o gamă de date, cum ar fi o matrice sau un container. Un iterator este la fel ca un indicator în C.
=> Căutați întreaga serie de formare C ++ aici.
Ce veți învăța:
- Prezentare generală
- Tipuri de iteratoare
- Avantajele iteratorilor
- Funcții Iterator
- Concluzie
- Lectură recomandată
Prezentare generală
În STL, un iterator este un obiect care poate fi folosit pentru a traversa sau a parcurge elementele din container utilizând un set de operatori precum operatorul de incrementare (++) sau operatorul de dereferință (*).
Iteratoarele sunt cruciale în programarea STL, deoarece joacă un rol important în conectarea algoritmilor la container, pe lângă accesarea și manipularea datelor stocate în containere.
Tipuri de iteratoare
În funcție de funcționalitatea implementată de iteratori, acestea sunt clasificate după cum urmează:
- Iteratoare de intrare și ieșire : Acestea sunt cele mai simplificate tipuri de iteratori. Sunt cele mai utile în operațiuni secvențiale de intrare-ieșire care conțin o singură trecere.
- Iteratori înainte : Acestea sunt la fel ca iteratoarele de intrare, dar au o direcție, adică direcție înainte, în sensul în care pot fi utilizate pentru a traversa un interval în direcția de redirecționare. Când iteratorii forward nu sunt constanți, pot fi folosiți și ca iteratori de ieșire. Majoritatea containerelor STL standard acceptă cel puțin iteratoarele directe.
- Iteratori bidirecționali : Acestea sunt similare cu iteratorii forward, cu singura diferență că sunt bidirecționale. Aceasta înseamnă că putem folosi acești iteratori bidirecționali pentru a parcurge intervalul atât în direcția înainte, cât și înapoi.
- Iteratoare cu acces aleatoriu : Iteratorii cu acces aleatoriu sunt cei mai puternici dintre toți iteratorii. Acestea sunt iteratoare non-secvențiale. Iteratorii cu acces aleatoriu ne permit să accesăm orice valoare aleatorie prin aplicarea unui offset la valoarea curentă fără a fi nevoie să trecem prin fiecare element secvențial. Acestea prezintă proprietăți similare cu indicii în C.
Un lucru de reținut este că nu toate containerele STL acceptă toți iteratorii. Diferite containere acceptă iteratori diferiți în funcție de cerința funcționalității lor.
Mai jos este lista containerelor care utilizează diferite iteratoare:
Containere | Iteratori |
---|---|
Hartă | Bidirecțional |
Grămadă | Nici un iterator |
Coadă | Nici un iterator |
Coadă prioritară | Nici un iterator |
Listă | Bidirecțional |
Vector | Acces aleatoriu |
și | Acces aleatoriu |
Multimap | Bidirecțional |
A stabilit | Bidirecțional |
Multiset | Bidirecțional |
Avantajele iteratorilor
Iteratoarele sunt extrem de utile mai ales în timpul programării folosind diferite game și containere.
Unele dintre avantajele utilizării iteratorilor în programare pot fi rezumate mai jos:
# 1) Cod reutilizabil
Atâta timp cât folosim iteratori pentru a accesa elemente din programul nostru, putem doar să schimbăm numele containerului din definiția iteratorului și să folosim restul codului într-un mod similar ori de câte ori trebuie să schimbăm containerul.
Acest lucru este util mai ales în scenarii în care intenționăm să înlocuim un container vector folosind un container list. Dacă în locul iteratorilor am folosi operatorul [], codul pentru accesarea elementelor ar fi inutil atunci când schimbăm containerele.
# 2) Ușurința și comoditatea programării
Iteratoarele vin cu diverse funcții încorporate care ne ajută să traversăm și să accesăm conținutul containerului cu ușurință și comoditate.
De exemplu , nu trebuie să continuăm să verificăm sfârșitul listei sau matricea pe care trebuie să o facem în timp ce folosim operatorii [] și trebuie să modificăm codul programului ca atunci când dorim să adăugăm elemente și trebuie să le schimbăm pentru o buclă .
Atunci când folosim iteratori, putem accesa direct funcțiile begin () și end () ale iteratorilor fără a fi nevoie să păstrăm o filă când ajungem la sfârșitul listei și, de asemenea, nu trebuie să le schimbăm pentru o buclă.
# 3) Adăugare / eliminare dinamică
În timpul utilizării iteratorilor, putem adăuga sau elimina cu ușurință și dinamic elementele din container fără a fi nevoie să mutăm elementele așa cum trebuie să facem în [] operatorii.
Să demonstrăm acest lucru cu următorul exemplu:
#include #include using namespace std; int main() { vector vec1 = { 1, 1, 2 }; // Declaring an iterator vector::iterator i; // Inserting element for (i = vec1.begin(); i != vec1.end(); ++i) { if (i == vec1.begin()) { i = vec1.insert(i, 3); // insert 3 at the beginning of vec1 } } // contents of vec1 3 1 1 2 cout<<'Vector contents after addition'; cout< Ieșire:
Conținut vector după adăugare
3 1 1 2
Conținut vectorial după ștergere
3 1 2
După cum se vede în exemplul de mai sus, vedem că folosind iteratoare putem adăuga sau elimina cu ușurință elemente dintr-un container (vector în acest caz), fără a fi nevoie să recurgem la programarea complexă a elementelor de deplasare și restructurarea containerului.
Funcții Iterator
Deoarece iteratorii în sine sunt construcții încorporate, aceștia acceptă diverse operații care pot fi făcute pe obiecte iteratoare. Aceste operații / funcții ne permit să traversăm în mod eficient gama și să manipulăm, de asemenea, elementele din interiorul containerului.
Acum vom vedea câteva operațiuni majore pe care iteratorii le acceptă.
- începe: Returnează prima sau prima poziție a iteratorului.
- Sfârșit: Returnează ultima poziție sau poziția „după sfârșit” a iteratorului.
- prev: Returnează noul iterator după diminuarea numărului de poziții date în argument.
- Următorul: Returnează noul iterator după ce a avansat sau a crescut numărul de poziții date în argument.
- inserator: Inserează elementul în orice poziție dată într-un container.
- avans: Mărește poziția iteratorului la numărul specificat dat în argument.
Vom demonstra utilizarea unora dintre această funcție / operație în următorul program:
#include #include #include using namespace std; int main() { vector v = { 1, 1,2,3,5 }; // declaring iterators to a vector vector::iterator itr1 = v.begin(); vector::iterator itr2 = v.end(); auto it = next(itr1, 2); // displaying iterator position cout << 'Using next() the new iterator is at: '; cout << *it << ' '; cout << endl; auto it1 = prev(itr2, 2); // displaying iterator position cout << 'The position of new iterator using prev() is: '; cout << *it1 << ' '; cout << endl; //advance advance(itr1,3); // displaying iterator position cout << 'After advance operation,itr1 is positioned at: '; cout << *itr1 << ' '; cout << endl; return 0; }
Ieșire:
Folosind next () noul iterator este la: 2
Poziția noului iterator folosind prev () este: 3
După operația avansată, itr1 este poziționat la: 3
Folosind programul de mai sus am demonstrat utilizarea diferitelor operații iteratoare.
Concluzie
Astfel am ajuns la sfârșitul acestui tutorial despre Iteratori.
Până acum am discutat elementele de bază ale STL, începând cu următorul nostru tutorial vom începe cu containerele STL și programarea lor.
=> Verificați aici seria completă de antrenament GRATUIT C ++.
Lectură recomandată
- Coadă prioritară în STL
- Matrice în STL
- 70+ BEST Tutoriale C ++ Pentru a învăța programarea C ++ GRATUIT
- Corzi, perechi și tupluri în STL
- SET IN STL
- Algoritmi în STL
- Cea mai bună serie de tutoriale GRATUITE C #: Ghidul final C # pentru începători
- Biblioteca de șabloane standard (STL): o scurtă introducere