C++ vektoriteratorer

C Vektoriteratorer



De viktigste iteratorene i C++ er Input Iterator, Output Iterator, Forward Iterator, Toveis Iterator og Random Access Iterator. Reverse Iterator er egentlig ikke en iterator; det er en iterator-adapter. Det finnes noen varianter av iteratorer, som en konstant iterator.

En iterator er en forseggjort peker. Som en peker peker den på objekter av samme type i minnet til forskjellige tider. Alle iteratorer er frarefererbare, bortsett fra utdataiteratoren som bare kan frarefereres for et sett med typer. Refererbar betyr at verdien som pekes på av pekeren eller iteratoren kan oppnås ved å bruke indirektionsoperatoren, *. Et heltall kan legges til noen iteratorer på samme måte, og for samme formål vil heltallet bli lagt til en peker.

Spørsmålene til denne artikkelen er: Hva er disse iteratorene? Hvilke av disse iteratorene brukes med C++-vektoren? Hvordan brukes disse iteratorene med C++-vektoren? Denne artikkelen svarer på alle disse spørsmålene på en forenklet måte. På slutten av denne artikkelen, når alle disse spørsmålene ville blitt besvart, vil C++ vektoriteratorer være intuitive og naturlige (for leseren).







Artikkelinnhold

Sammendrag av C++-iteratorer

Input Iterator



Ideen med input iterator er at et program skal motta inngangsverdi. I motsetning til utdata-iteratoren, er input-iteratoren alltid frarefererbar. For to input-iteratorer, a og b, betyr ikke 'a == b' '++a == ++b'.



Output Iterator
Ideen med utdata-iterator er at et program skal frigjøre utdataverdi. I motsetning til input-iteratoren, er ikke utdata-iteratoren alltid frarefererbar. Det kan bare fravises for et sett med typer.





Fremover iterator
Fremover iteratoren kan skanne vektoren fra begynnelsen til slutten, en etter en (inkrementerende). Den har alle kravene til input-iteratoren, pluss tilleggskrav. Den kan erstatte en input-iterator. For to fremre iteratorer, a og b, betyr 'a == b' '++a == ++b'.

Toveis iterator
Den toveis iteratoren kan skanne vektoren fra begynnelsen til slutten, en etter en. Fra slutten til begynnelsen, en etter en (minskende). Den har alle kravene til den fremre iteratoren, pluss tilleggskrav. Den kan erstatte en fremre iterator. For to toveis iteratorer, a og b,



'a == b' betyr '++a == ++b'
og
“–a == –b” betyr “a == b”.

Random Access Iterator

Random Access-iteratoren har alle kravene til den toveis iteratoren, pluss tilleggskrav. Den kan erstatte en toveis iterator. Tilfeldig tilgang-iteratoren kommer med fordelen at hvis den for øyeblikket peker til det første elementet og det fjerde elementet er nødvendig, vil det hoppe over det andre og tredje elementet og peke til det fjerde elementet. Det omvendte hoppet nedover er sant.

Omvendt iterator

Legg merke til at C++ ikke har en normal revers iterator da den har en forover iterator. Så det er en adapter som heter en omvendt iterator. Det er flere gode nyheter: den omvendte iteratoren oppfyller alle kravene til en toveis iterator.

Konstant iterator

Hvis en iterator sies å være en konst iterator, kan ikke elementet den peker på endres.

Vektorkonstruksjon og tilgang

Beholdere i C++ er: class array, deque, forward_list, list, vector, map, set, unordered_map og unordered_set. Vektoren er en beholder. Visse funksjonsmaler i C++ standardbiblioteket opererer med iteratorer direkte eller indirekte. C++-beholdere, så vel som vektoren, bruker disse funksjonene. Disse funksjonene kan gjøres tilgjengelige for C++-programmet med ett av følgende inkluderingsdirektiver:

#inkluder

eller

#inkluder

Inkludering av noen av de andre beholderne vil også gjøre disse funksjonsmalene tilgjengelige. En funksjonsmal er for en funksjon som kan operere med ulike datatyper. Vektoren bruker iteratorer gjennom disse funksjonsmalene. Noen av funksjonsmalene og deres forhold til vektoren er som følger:

Konstruksjon

Malfunksjon:

mal < klasse C > constexpr auto data ( C & c ) - > decltype ( c. data ( ) ) ;

auto betyr at returtypen bestemmes ved evaluering av funksjonen. c er objektet i klasse C.

Et eksempel på et vektorobjekt konstruert med dette implisitt er:

vektor < røye > vtr ;

Her er objektet, c, tomt.

Malfunksjon:

mal < klasse OG > constexpr konst OG * data ( initializer_list < OG > De ) ikke unntatt ;

Her er E* en iterator som peker til det første elementet i listen eller beholderen. Bruken med vektoren implisitt vil være med:

vektor < røye > vtr { 'EN' , 'B' , 'C' , 'D' , 'OG' } ;
vektor < røye > :: const_iterator den = vtr. begynne ( ) ;

Malfunksjonen er mer anvendelig for start()-setningen (den andre setningen).

Adgang

Malfunksjon:

mal < klasse C > constexpr auto størrelse ( konst C & c ) - > decltype ( c. størrelse ( ) ) ;

Dette returnerer størrelsen på beholderen. Vektoreksempel:

vektor < røye > vtr { 'EN' , 'B' , 'C' , 'D' , 'OG' } ;
int N = vtr. størrelse ( ) ;
cout << N << endl ;

Utgangen er 5.

Malfunksjon:

mal < klasse OG > [ [ nodiscard ] ] constexpr bool tømme ( initializer_list < OG > De ) ikke unntatt ;

Returnerer sann hvis listen er tom eller usann ellers. Vektoreksempel:

vektor < røye > vtr { 'EN' , 'B' , 'C' , 'D' , 'OG' } ;
bool med = vtr. tømme ( ) ;
cout << med << endl ;

Utgangen er 0 for falsk.

Tilgang til rekkevidde

Det er andre malfunksjoner som bruker iteratorer som vektoren bruker for sine rekkeviddeproblemer. Et område er et påfølgende sett med beholderelementer.

Malfunksjon:

mal < klasse C > constexpr auto begynne ( C & c ) - > decltype ( c. begynne ( ) ) ;

Dette returnerer en iterator som peker til det første elementet i listen. auto betyr her at returverdien bestemmes ved evaluering. Eksempel på vektor:

vektor < røye > vtr { 'EN' , 'B' , 'C' , 'D' , 'OG' } ;
vektor < røye > :: iterator den = vtr. begynne ( ) ;
cout << * den << ' \n ' ;

Utgangen er A. Iteratoren som returneres her er en iterator med tilfeldig tilgang. En konstant tilfeldig tilgang iterator kunne ha blitt returnert – se senere.

Funksjonsmal:

mal < klasse C > constexpr auto slutt ( konst C & c ) - > decltype ( c. slutt ( ) ) ;

Returnerer en konstant iterator som peker til det siste elementet i listen. Vektorkode:

vektor < røye > vtr { 'EN' , 'B' , 'C' , 'D' , 'OG' } ;
vektor < røye > :: const_iterator den = vtr. slutt ( ) ;
-- den ;
cout << * den << ' ' ;
-- den ;
cout << * den << endl ;

Utgangen er 'E D'. En konstant iterator kan økes eller reduseres, men verdien den peker på kan ikke endres. En vanlig iterator med tilfeldig tilgang kunne ha blitt returnert – se senere.

Funksjonsmal:

mal < klasse OG > constexpr reverse_iterator < konst OG * > begynne ( initializer_list < OG > De ) ;

Returnerer den siste verdien i listen. rbegin() peker på det siste elementet i listen og ikke utover det siste elementet i listen, slik end() gjør. Vektoreksempel:

vektor < røye > vtr { 'EN' , 'B' , 'C' , 'D' , 'OG' } ;
vektor < røye > :: reverse_iterator den = vtr. begynne ( ) ;
cout << * den << ' ' ;
++ den ;
cout << * den << endl ;

Utgangen er: E D. Med den omvendte iteratoren har ++ motsatt effekt for den toveis iteratoren.

Funksjonsmal:

mal < klasse OG > constexpr reverse_iterator < konst OG * > gjør at ( initializer_list < OG > De ) ;

Poeng like før det første elementet i listen. Vektoreksempel:

vektor < røye > vtr { 'EN' , 'B' , 'C' , 'D' , 'OG' } ;
vektor < røye > :: reverse_iterator den = vtr. gjør at ( ) ;
-- den ;
cout << * den << ' ' ;
-- den ;
cout << * den << endl ;

Utdata er A B. Med omvendt iterator, — har motsatt effekt for ++ av den toveis iterator.

Det er andre malfunksjoner under denne overskriften – se senere.

Sett inn iteratorer

reverse_iterator er en iteratoradapter, egentlig ikke en iterator. Innsats-iteratoren er også en iterator-adapter. Den tilfredsstiller alle kravene til utdata-iteratoren, pluss dens egne krav. Det finnes i tre former i C++: back_inserter, front_inserter og inserter. Hver av disse har sin egen konstruktør.

back_inserter:

Innlegg bak!
Viktige prototyper:

eksplisitt back_insert_iterator ( Container & x ) ;
back_insert_iterator & operatør = ( typenavn Container :: verdi_type && verdi ) ;

Vektoreksempel:
Vektoren har ingen innsettingselementfunksjon som settes inn på baksiden. Imidlertid kan push_back(t)-medlemsfunksjonen sees slik.

front_inserter

Innsatser foran!
Viktige prototyper:

eksplisitt front_insert_iterator ( Container & x ) ;
front_insert_iterator & operatør = ( typenavn Container :: verdi_type && verdi ) ;

Vektoreksempel:
Vektoren har ingen innsettingselementfunksjon som settes inn foran. Vektoren har ikke også elementfunksjonen push_front(t).

Den gode nyheten er at vektoren har innsettingselementfunksjoner som kan settes inn hvor som helst, i begynnelsen, innenfor eller slutten av vektoren.

innstikker

Denne iteratoren vil sette inn i begynnelsen, innenfor eller slutten av vektoren.

Viktige prototyper:

insert_iterator ( Container & x, typenavn Container :: iterator Jeg ) ;
insert_iterator & operatør = ( typenavn Container :: verdi_type && verdi ) ;

Vektoreksempel:

vektor < røye > vtr { 'EN' , 'B' , 'C' , 'D' , 'OG' } ;
vektor < røye > :: iterator den = vtr. begynne ( ) ;
den = den + 2 ;
vtr. sett inn ( den, 'c' ) ;

til ( int Jeg = 0 ; Jeg < vtr. størrelse ( ) ; Jeg ++ )
cout << vtr [ Jeg ] << ', ' ;
cout << endl ;

Utgangen er:

A, B, c, C, D, E,

Vektorinnskuddsuttrykket er:

vtr. sett inn ( den, 'c' ) ;

Den setter inn elementet rett før pekeren (det) det peker på.

Flytt Iterator

Move_iterator er også en iteratoradapter. Følgende program ligner på eksemplet som er i C++-spesifikasjonen:

#include
#inkluder
#inkluder
ved hjelp av navneområde std ;

int hoved- ( )
{
liste < røye > chs { 'EN' , 'B' , 'C' , 'D' , 'OG' } ;
vektor < røye > vtr ( make_move_iterator ( chs. begynne ( ) ) , make_move_iterator ( chs. slutt ( ) ) ) ;

cout << 'Original listeinnhold:' << endl ;
til ( auto den = chs. begynne ( ) ; den ! = chs. slutt ( ) ; den ++ )
cout << * den << ', ' ;
cout << endl << endl ;

cout << 'Vektorinnhold:' << endl ;
til ( int Jeg = 0 ; Jeg < vtr. størrelse ( ) ; Jeg ++ )
cout << vtr [ Jeg ] << ', ' ;
cout << endl ;

komme tilbake 0 ;
}

Utgangen er:

Opprinnelig listeinnhold:
A, B, C, D, E,

Vektorinnhold:
A, B, C, D, E,

Denne iteratoren konverterer en kildeverdi til en rverdi før den plasseres på destinasjonen.

Konklusjon

De viktigste iteratorene i C++ er Input Iterator, Output Iterator, Forward Iterator, Toveis Iterator og Random-Access Iterator. C++ standardbiblioteket har noen funksjonsmaler som bruker disse iteratorene. Vektoren bruker disse iteratorene gjennom funksjonsmalene. Vektoren har noen forskjellige navn for noen av disse iteratorene. Det finnes også iteratoradaptere, som er: reverse_iterator, iteratoradapter og move_iterator. Noen varianter av iteratorer finnes også. Det er nok å inkludere i et program for å ha alle disse funksjonene. Etter å ha forstått rollen til disse iteratorene, adapterne og funksjonsmalene som bruker dem, blir det intuitivt å bruke iteratorer med vektorer.