Iteratori vettoriali C ++

I principali iteratori in C ++ sono iteratore di input, iteratore di uscita, iteratore in avanti, iteratore bidirezionale e iteratore di accesso casuale. L'iteratore inverso non è proprio un iteratore; è un adattatore iteratore. Ci sono alcune varianti per gli iteratori, come un iteratore costante.

Un iteratore è un puntatore elaborato. Come un puntatore, indica oggetti dello stesso tipo in memoria in momenti diversi. Tutti gli iteratori sono dereferenziabili, ad eccezione dell'iteratore di uscita che è dereferenciabile solo per un insieme di tipi. Dereferenceable significa che il valore indicato dal puntatore o dall'iteratore può essere ottenuto usando l'operatore indirezione, *. Un numero intero può essere aggiunto ad alcuni iteratori allo stesso modo e per lo stesso scopo, l'intero verrebbe aggiunto a un puntatore.

Le domande per questo articolo sono: quali sono questi iteratori? Quali di questi iteratori sono usati con il vettore C ++? Come vengono utilizzati questi iteratori con il vettore C ++? Questo articolo risponde a tutte queste domande in modo semplificato. Alla fine di questo articolo, quando sarebbe stata data risposta a tutte queste domande, gli iteratori vettoriali C ++ saranno intuitivi e naturali (per il lettore).

Contenuto dell'articolo

• Riepilogo degli iteratori C ++
• Costruzione e accesso vettoriali
• Accesso a portata
• Inserire iteratori
• Sposta iteratore
• Conclusione

Riepilogo degli iteratori C ++

Iteratore di ingresso

L'idea di Iteratore input è che un programma riceva valore input. A differenza dell'iteratore di output, l'iteratore di input è sempre dereferenciabile. Per due iteratori di input, A e B, "A == B" non implica "++ A == ++ B".

Iteratore di output
L'idea di output iterator è per un programma per rilasciare il valore di output. A differenza dell'iteratore di input, l'iteratore di output non è sempre dereferenciabile. È dereferenciabile solo per una serie di tipi.

Iteratore in avanti
L'iteratore in avanti può scansionare il vettore dall'inizio alla fine, uno per uno (incremento). Ha tutti i requisiti dell'iteratore di input, oltre a requisiti aggiuntivi. Può sostituire un iteratore di input. Per due iteratori in avanti, A e B, "A == B" implica "++ A == ++ B".

Iteratore bidirezionale
L'iteratore bidirezionale può scansionare il vettore dall'inizio alla fine, uno ad uno. Dalla fine all'inizio, uno per uno (decremento). Ha tutti i requisiti dell'iteratore in avanti, oltre a requisiti aggiuntivi. Può sostituire un iteratore in avanti. Per due iteratori bidirezionali, A e B,

"A == B" implica "++ A == ++ B"
E
"-A == -b" implica "A == B".

Iteratore ad accesso casuale

L'iteratore di accesso casuale ha tutti i requisiti dell'iteratore bidirezionale, oltre a requisiti aggiuntivi. Può sostituire un iteratore bidirezionale. L'iteratore ad accesso casuale ha il vantaggio che se attualmente sta puntando al primo elemento e è richiesto il quarto elemento, salverebbe il secondo e il terzo elementi e indicherebbe il quarto elemento. Il retro che salta verso il basso è vero.

Iteratore inverso

Si noti che C ++ non ha un normale iteratore inverso in quanto ha un iteratore in avanti. Quindi, c'è un adattatore chiamato iteratore inverso. Ci sono altre buone notizie: l'iteratore inverso soddisfa tutti i requisiti di un iteratore bidirezionale.

Iteratore costante

Se si dice che un iteratore sia un cost iteratore, l'elemento in cui punta non può essere modificato.

Costruzione e accesso vettoriali

I contenitori in C ++ sono: Array di classe, Deque, Forward_List, Elenco, Vector, Map, Set, UnOrdered_Map e UnOrdered_Set. Il vettore è un contenitore. Alcuni modelli di funzione nella libreria standard C ++ funzionano con iteratori direttamente o indirettamente. I contenitori C ++, così come il vettore, usano queste funzioni. Queste funzioni possono essere rese disponibili al programma C ++ con una delle seguenti direttive di inclusione:

#includere

O

#includere

L'inclusione di uno qualsiasi degli altri contenitori renderà anche a disposizione questi modelli di funzione. Un modello di funzione è per una funzione che può funzionare con diversi tipi di dati. Il vettore utilizza iteratori attraverso questi modelli di funzione. Alcuni dei modelli di funzione e la loro relazione con il vettore sono i seguenti:

Costruzione

Funzione modello:

modello Contexpr Auto Data (C&C) -> Decltype (C.dati());

auto indica che il tipo di ritorno è determinato alla valutazione della funzione. C è l'oggetto della classe C.

Un esempio di oggetto vettoriale costruito con questo è implicitamente:

vettore VTR;

Qui l'oggetto, c, è vuoto.

Funzione modello:

modello Dati di constExpr const e* (inizializer_list IL) NOExcept;

Qui, E* è un iteratore che indica il primo elemento dell'elenco o del contenitore. Il suo uso con il vettore implicitamente sarebbe con:

vettore vtr 'a', 'b', 'c', 'd', 'e';
vettore:: const_iterator it = vtr.inizio();

La funzione modello è più applicabile all'istruzione iniziale () (la seconda istruzione).

Accesso

Funzione modello:

modello Dimensione automatica costexpr (const C&C) -> Decltype (C.misurare());

Questo restituisce le dimensioni del contenitore. Esempio vettoriale:

vettore vtr 'a', 'b', 'c', 'd', 'e';
int n = vtr.misurare();
cout << N << endl;

L'output è 5.

Funzione modello:

modello [[nodiscard]] costexpr bool vuoto (inizializer_list IL) NOExcept;

Restituisce vero se l'elenco è vuoto o falso altrimenti. Esempio vettoriale:

vettore vtr 'a', 'b', 'c', 'd', 'e';
bool bl = vtr.vuoto();
cout << bl << endl;

L'output è 0 per false.

Accesso a portata

Esistono altre funzioni di modello, che utilizzano iteratori che il vettore utilizza per i suoi problemi di gamma. Un intervallo è un set consecutivo di elementi container.

Funzione modello:

modello costexpr Auto Begin (C&C) -> Decltype (C.inizio());

Questo restituisce un iteratore che punta al primo elemento nell'elenco. auto qui significa che il valore di ritorno è determinato durante la valutazione. Esempio per vettoriale:

vettore vtr 'a', 'b', 'c', 'd', 'e';
vettore:: iterator it = vtr.inizio();
cout << *it << '\n';

L'output è un. L'iteratore restituito qui è un iteratore ad accesso casuale. Un iteratore di accesso casuale costante avrebbe potuto essere restituito - vedi più tardi.

Modello di funzione:

modello costexpr Auto End (const C&C) -> Decltype (C.FINE());

Restituisce un iteratore costante che punta all'ultimo elemento dell'elenco. Codice vettoriale:

vettore vtr 'a', 'b', 'c', 'd', 'e';
vettore:: const_iterator it = vtr.FINE();
--Esso;
cout << *it << ";
--Esso;
cout << *it << endl;

L'output è "e d". Un iteratore costante può essere incrementato o decrementato, ma il valore a cui indica non può essere modificato. Un normale iteratore di accesso casuale avrebbe potuto essere restituito - vedi più avanti.

Modello di funzione:

modello costexpr revers_iterator rbegin (inizializer_list I l);

Restituisce l'ultimo valore nell'elenco. rbegin () indica l'ultimo elemento dell'elenco e non oltre l'ultimo elemento dell'elenco, come end (). Esempio vettoriale:

vettore vtr 'a', 'b', 'c', 'd', 'e';
vettore:: inverse_iterator IT = VTR.rbegin ();
cout << *it << ";
++Esso;
cout << *it << endl;

L'output è: e d. Con l'iteratore inverso, ++ ha l'effetto opposto per l'iteratore bidirezionale.

Modello di funzione:

modello costexpr revers_iterator Rend (inizializer_list I l);

Punti appena prima del primo elemento dell'elenco. Esempio vettoriale:

vettore vtr 'a', 'b', 'c', 'd', 'e';
vettore:: inverse_iterator IT = VTR.rend ();
--Esso;
cout << *it << ";
--Esso;
cout << *it << endl;

L'output è una b. Con l'iteratore inverso, - ha l'effetto opposto per ++ dell'iteratore bidirezionale.

Esistono altre funzioni di modello sotto questa intestazione - vedi più avanti.

Inserire iteratori

reverse_iterator è un adattatore iteratore, non in realtà un iteratore. L'iteratore di inserimento è anche un adattatore iteratore. Soddisfa tutti i requisiti dell'iteratore di output, oltre ai propri requisiti. Esiste in tre forme in C ++: il back_inserter, il front_inserter e l'inserter. Ognuno di questi ha il suo costruttore.

back_inserter:

Inserti sul retro!
Prototipi importanti:

esplicito back_insert_iterator (contenitore & x);
back_insert_iterator & operator = (Tylename Container :: value_type && value);

Esempio vettoriale:
Il vettore non ha alcuna funzione del membro di inserimento che inserisce sul retro. Tuttavia, la funzione membro push_back (t) può essere vista così.

front_inserter

Inserti nella parte anteriore!
Prototipi importanti:

esplicito front_insert_iterator (contenitore & x);
front_insert_iterator & operator = (Tylename Container :: value_type && value);

Esempio vettoriale:
Il vettore non ha alcuna funzione del membro di inserimento che inserisce nella parte anteriore. Il vettore non ha anche la funzione membro push_front (t).

La buona notizia è che il vettore ha le funzioni dei membri che possono inserire ovunque, all'inizio, all'interno o alla fine del vettore.

Inserter

Questo iteratore si inserisce all'inizio, all'interno o alla fine del vettore.

Prototipi importanti:

insert_iterator (contenitore e x, container da tipografia :: iteratore i);
Insert_iterator & Operator = (TyleName Container :: value_type && value);

Esempio vettoriale:

vettore vtr 'a', 'b', 'c', 'd', 'e';
vettore:: iterator it = vtr.inizio();
It = It + 2;
VTR.inserire (esso, 'c');
per (int i = 0; icout << vtr[i] << ", ";
cout <

L'output è:

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

L'espressione del vettoriale è:

VTR.inserire (esso, 'c');

Inserisce l'elemento appena prima del puntatore (esso) a cui indica.

Sposta iteratore

Il Move_iterator è anche un adattatore iteratore. Il seguente programma è simile all'esempio che si trova nella specifica C ++:

#includere
#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

elenco chs 'a', 'b', 'c', 'd', 'e';
vettore VTR (make_move_iterator (CHS.inizio ()), make_move_iterator (CHS.FINE()));
cout << "Original list Content:" << endl;
per (auto It = CHS.inizio(); Esso != CHS.FINE(); It ++)
cout << *it << ", ";
cout << endl << endl;
cout << "Vector Content:" << endl;
per (int i = 0; icout << vtr[i] << ", ";
cout << endl;
restituzione 0;

L'output è:

Contenuto dell'elenco originale:
A, B, C, D, E,

Contenuto vettoriale:
A, B, C, D, E,

Questo iteratore converte un valore di origine in un RValue prima di posizionarlo a destinazione.

Conclusione

I principali iteratori in C ++ sono iteratori di input, iteratore di uscita, iteratore in avanti, iteratore bidirezionale e iteratore ad accesso casuale. La libreria standard C ++ ha alcuni modelli di funzioni che utilizzano questi iteratori. Il vettore utilizza questi iteratori attraverso i modelli di funzione. Il vettore ha alcuni nomi diversi per alcuni di questi iteratori. Ci sono anche adattatori iterator, che sono: reverse_iterator, adattatore iteratore e move_iterator. Esistono anche alcune varianti di iteratori. È sufficiente includere in un programma avere tutte queste funzionalità. Dopo aver compreso il ruolo di questi iteratori, adattatori e modelli di funzione che li usano, usando iteratori con vettori diventano intuitivi.