C ++ Vector Clear vs cancella

Il vettore C ++ ha molte funzioni dei membri. Due di loro lo sono clear () e cancella (). chiaro() "Rimuove" tutti gli elementi del vettore. cancella () "rimuove" un singolo elemento o una serie di elementi. Esistono due varianti sovraccarichi della funzione membro di cancellazione () per il vettore.

Il titolo di questo articolo è in realtà "Funzione membro vector clear () rispetto alla funzione membro vettoriale (), in C ++". Questo è un confronto tra le funzioni a due membri. Si occupa di quando usare quali, come usare quale e in quali condizioni vengono utilizzate.

Per utilizzare un vettore in un programma C ++, il programma dovrebbe iniziare con:

#includere
#includere
Utilizzo dello spazio dei nomi std;

Contenuto dell'articolo

• Vector clear ()
• Cancella vettoriale
• Pop_back
• Distruggere un vettore
• Conclusione

Vector clear ()

La funzione membro Clear () "rimuove" tutti gli elementi del vettore. La sua sintassi è:

void chiaro ()

Restituisce vuoto. Il seguente programma ne illustra l'uso, con l'espressione, “VTR.chiaro();":

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

vettore vtr = 'p', 'q', 'r', 's', 't', 'u';
per (vettore:: iterator it = vtr.inizio(); Esso != vtr.FINE(); It ++)
cout << *it << ";
cout << endl;
VTR.chiaro();
per (vettore:: iterator it = vtr.inizio(); Esso != vtr.FINE(); It ++)
cout << *it << ";
cout << endl;
restituzione 0;

L'output è l'unica riga:

P Q r s t u

Se il vettore non fosse stato cancellato, l'output sarebbe stata due righe della stessa sequenza. Nessuna seconda riga è stata visualizzata perché tutti gli elementi sono stati cancellati.

const vector e clear ()

Quando una dichiarazione vettoriale è preceduta da const, significa che gli elementi del vettore non possono essere eliminati o modificati. Se un'espressione tenta di cambiare o eliminare uno qualsiasi degli elementi, il programma non compilerà. Prova il seguente programma e nota che non si compila:

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

const vector vtr = 'p', 'q', 'r', 's', 't', 'u';
per (vettore:: const_iterator it = vtr.inizio(); Esso != vtr.FINE(); It ++)
cout << *it << ";
cout << endl;
VTR.chiaro();
per (vettore:: const_iterator it = vtr.inizio(); Esso != vtr.FINE(); It ++)
cout << *it << ";
cout << endl;
restituzione 0;

Se il programma fosse testato, sarebbe stato emesso un messaggio di errore e non ci sarebbe stata alcuna compilazione. Poiché il vettore è stato dichiarato costante, la funzione clear () non ha potuto funzionare, risultando in un messaggio di errore dal compilatore.

Nota: Clear () elimina tutti gli elementi del vettore. In realtà, segna tutti gli elementi cancellati, in modo tale che altri codici possano occupare le loro posizioni di memoria. Se la posizione della memoria di qualsiasi elemento non è stata ancora assorbita da un altro codice, l'elemento può comunque essere riutilizzato per conto dello stesso vettore.

Cancella vettoriale

Le sintassi semplificate per le funzioni dei due membri Cancella () sono:

UN.Cancella (Q)
E
UN.Cancella (Q1, Q2)

dove a è il nome del vettore.

Iterator Erase (posizione const_iterator)

Questa è la sintassi completa per "a.Cancella (Q) ". Restituisce un iteratore che punta all'elemento, che era proprio dietro quello cancellato. L'argomento, Q è un iteratore che punta all'elemento da cancellare. Il seguente programma illustra questo:

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

vettore vtr = 'p', 'q', 'r', 's', 't', 'u';
vettore:: iterator iter = vtr.inizio();
++iter; ++ iter;
vettore:: iterator it = vtr.cancella (iter);
per (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
restituzione 0;

L'output è:

P q s t u
S

'R' è stato eliminato. L'iteratore restituito ora punta a "s", che è stato subito dopo "R". La funzione membro, inizio (), restituisce un iteratore che indica il primo elemento del vettore. Nel codice, questo iteratore è stato incrementato due volte per indicare "R". 'R' è stato cancellato con l'espressione, "VTR.cancella (iter) ".

Gamma in vettore

Per l'elenco,

'P', 'q', 'r', 's', 't', 'u'

La sequenza, "Q", "r", "s", "t" è un intervallo. Tuttavia, con i contenitori C ++, l'ultimo elemento, "T" non è considerato parte dell'intervallo. Questo è indicato in termini generali come:

[i, j)
O
[Q1, Q2)

'[' in questo caso, significa che il primo elemento nella sequenza è incluso e ')' significa che l'ultimo elemento non è incluso.

Iterator Erase (const_iterator First, const_iterator Last)

Questa è la sintassi completa per "a.Cancella (Q1, Q2) ". Restituisce un iteratore che punta all'elemento, che era proprio dietro la gamma cancellata. Nota: l'ultimo elemento nell'intervallo non viene cancellato. Quindi, l'iteratore restituito indicherà l'ultimo elemento dell'intervallo. Gli argomenti Q1 e Q2 sono iteratori che indicano il primo e gli ultimi elementi della gamma. Il seguente programma illustra questo:

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

vettore vtr = 'p', 'q', 'r', 's', 't', 'u';
vettore:: iterator ITB = VTR.inizio();
++ITB;
vettore:: iterator ite = vtr.FINE();
--ite; --ite;
vettore:: iterator it = vtr.cancella (ITB, ite);
per (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
restituzione 0;

L'output è:

P t u
T

'Q', 'r', 's' è stato eliminato. L'iteratore restituito ora punta a "t", che era l'ultimo elemento nell'intervallo dei container. La funzione membro, end (), restituisce un iteratore che punta subito dopo l'ultimo elemento del vettore. Nel codice, questo iteratore è stato decrementato due volte per indicare "T", l'ultimo elemento dell'intervallo. 'Q', 'r', 's' sono stati eliminati senza l'ultimo elemento, 't' nell'intervallo, con l'espressione, “VTR.cancella (ITB, ite) ".

const vector e cancella ()

Se la dichiarazione di un vettore è preceduta con const, per costante, allora nessuno dei suoi elementi può essere cancellato. Il seguente programma non si compilerà, emettendo un messaggio di errore per A.Espressione di cancella (Q):

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

const vector vtr = 'p', 'q', 'r', 's', 't', 'u';
vettore:: const_iterator iter = vtr.inizio();
++iter; ++ iter;
vettore:: const_iterator it = vtr.cancella (iter);
per (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
restituzione 0;

Se il lettore provasse il programma, avrebbe ricevuto un messaggio di errore. Il programma non si sarebbe compilato.

Il seguente programma non si compilerà, emettendo un messaggio di errore per A.Cancella (Q1, Q2) espressione:

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

const vector vtr = 'p', 'q', 'r', 's', 't', 'u';
vettore:: const_iterator ITB = VTR.inizio();
++ITB;
vettore:: const_iterator ite = vtr.FINE();
--ite; --ite;
vettore:: const_iterator it = vtr.cancella (ITB, ite);
per (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
restituzione 0;

Nota: cancella () elimina un elemento o una gamma di elementi. In realtà, segna un elemento come cancellato, in modo tale che le loro posizioni di memoria possano essere assunte da altri codici. Se la posizione della memoria di qualsiasi elemento non è stata ancora assorbita da un altro codice, l'elemento può comunque essere riutilizzato per conto dello stesso vettore.

pop_back ()

La funzione del membro vettoriale pop_back () è una sorta di funzione cancella (). Tuttavia, elimina solo l'ultimo elemento del vettore. La sintassi è:

void pop_back ()

Non ci vuole discussione e restituisce vuoto. Il seguente programma ne illustra l'uso:

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

vettore vtr = 'p', 'q', 'r', 's', 't', 'u';
VTR.pop_back ();
per (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
restituzione 0;

L'output è:

P Q R S T

L'ultimo elemento, 'u' è stato rimosso (cancellato).

Distruggere un vettore

Può essere distrutto un vettore? - SÌ! Tuttavia, quando un vettore viene distrutto, tutti i suoi elementi vengono cancellati tranne il suo nome; Significa che la dichiarazione vettoriale può ancora essere riutilizzata, ma con qualche incertezza. La sintassi per distruggere un vettore è:

UN.~ X ()

dove "a" è il nome del vettore. Il seguente programma illustra questo:

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

vettore vtr = 'p', 'q', 'r', 's', 't', 'u';
VTR.~ vector ();
vtr = 'v', 'w', 'x', 'y', 'z';
per (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
VTR.~ vector ();
VTR.push_back ('a');
VTR.push_back ('b');
VTR.push_back ('c');
VTR.push_back ('d');
VTR.push_back ('e');
per (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
restituzione 0;

L'output è:

V w x y z
p ^ t e @ a c d e

dal computer dell'autore, con alcuni caratteri inaffidabili per la seconda riga.

Conclusione

La funzione del membro vettoriale clean () può essere confrontata con la funzione della funzione del membro vettoriale (). Non sono sostituti. Clear () elimina tutti gli elementi del vettore. In realtà, segna tutti gli elementi cancellati, in modo tale che le loro posizioni di memoria possano essere assunte da altri codici. Se la posizione della memoria di qualsiasi elemento non è stata ancora assorbita da un altro codice, l'elemento può comunque essere riutilizzato per conto dello stesso vettore. cancella () elimina un elemento o una serie di elementi. In realtà, segna un elemento come eliminato, in modo tale che la posizione della memoria possa essere assorbita da un altro codice. Se la posizione della memoria di qualsiasi elemento eliminato non è stata ancora assorbita da un altro codice, l'elemento può comunque essere riutilizzato per conto dello stesso vettore. Clear ha una somiglianza con distruggere, ~ x ().