Come rimuovo un elemento specifico da un vettore in C++?

Il vettore C ++ ha molte funzioni dei membri. Due di queste funzioni membro sono cancellate () e pop_back (). pop_back () rimuove l'ultimo elemento dal vettore. Per rimuovere tutti gli elementi dal vettore, usando pop_back (), la funzione pop_back () deve essere ripetuta il numero di volte in cui ci sono elementi. La funzione cancella () può rimuovere un elemento dall'inizio, all'interno o alla fine del vettore. Al fine di rimuovere tutti gli elementi dal vettore, usando la funzione di cancella (), la funzione Cancella () deve essere ripetuta il numero di volte in cui ci sono elementi, a partire dal primo elemento.

Per rimuovere un elemento specifico dal vettore C ++, l'elemento deve essere identificato. Per quanto riguarda la funzione membro Cancella (), l'elemento è identificato da un iteratore. La prossima domanda è: “Ciò che è un iteratore?" - vedi sotto. Poiché la funzione membro pop_back () rimuove l'ultimo elemento per definizione, l'elemento specifico che deve rimuovere è già stato identificato indirettamente.

Per utilizzare la libreria vettoriale in C ++, il programma deve iniziare:

#includere
#includere
Utilizzo dello spazio dei nomi std;

Questo articolo spiega come rimuovere un elemento specifico dal vettore C ++, a partire dalla spiegazione dell'iteratore principale in C++. Tutto il codice vettoriale per questo articolo è nel corpo funzione principale ().

Contenuto dell'articolo

• Introduzione - Vedi sopra
• Identificazione dell'elemento vettoriale
• Rimozione con cancella ()
• Rimozione con pop_back
• Conclusione

Identificazione dell'elemento vettoriale

Identificazione per riferimento
Considera il seguente vettore:

vector vtr = 'a', 'b', 'c', 'd', 'e';

VTR [0] restituisce 'A'. VTR [1] restituisce 'B'. VTR [2] restituisce 'C'. VTR [3] restituisce 'D'. VTR [4] restituisce 'E'. Questo si identifica per riferimento. Il numero tra parentesi quadrate, è chiamato indice. Può essere fatto in un per loop, come mostra il seguente programma:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
per (int i = 0; icout << vtr[i] << ";
cout << endl;
restituzione 0;

L'output è:

A b c d e

Identificazione per iteratore
Considera il seguente vettore:

vector vtr = 'a', 'b', 'c', 'd', 'e';

it = vtr.inizio (), significa "esso" è un iteratore che indica "a" .

++ punta a 'b'.

++ punta a "c", incrementato dopo che indicava "B".

++ punta a "d", incrementato dopo aver puntato a "c".

++ punta a "e", incrementato dopo aver puntato a "D".

It ++ punta a VTR.end (), che è appena oltre l'ultimo elemento, incrementato dopo aver puntato a "e".

Questo può essere fatto in un per loop, come mostra il seguente programma:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
per (Vector :: iterator IT = VTR.inizio(); Esso != vtr.FINE(); It ++)
cout << *it << ";
cout << endl;
restituzione 0;

L'output è:

A b c d e

Il primo iteratore è stato ottenuto con la dichiarazione:

Vector :: iterator it

dove "esso" è l'identificatore dell'iteratore.

Ancora riferendosi allo stesso vettore,

it = vtr.end (), punti appena oltre l'ultimo elemento "e" .

punta a 'e'.

indica "d", decrementato dopo che indicava "e".

punta a 'c', decrementato dopo aver puntato a 'd'.

punta a 'b', decrementato dopo aver puntato a 'c'.

Indica "A", decrementato dopo che indicava "B".

Questo schema può essere utilizzato per visualizzare il vettore in ordine inverso, come mostra il seguente programma:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
Vector :: iterator IT = VTR.FINE();
per (it = --it; it> = vtr.inizio(); Esso--)
cout << *it << ";
cout << endl;
restituzione 0;

L'output è:

E d c b a

L'iteratore iniziale per il circuito per loop viene decrementato. io.e. "It = -it;". Nota la condizione while per il per loop, io.e. “It> = VTR.inizio();".

Per ottenere il valore indicato dall'iteratore, l'iteratore deve essere dereferato dall'operatore indirezione, *.

Rimozione con cancella ()

La sintassi per cancellare (rimuovere) un elemento da un vettore è:

UN.Cancella (Q)

dove "a" è il nome del vettore e Q è un iteratore che punta all'elemento da rimuovere. Cioè, Q identifica l'elemento specifico da rimuovere. La funzione del membro restituisce un iteratore che indica l'elemento subito dopo che viene rimosso.

Rimozione dalla parte anteriore
La funzione dell'elemento di cancellazione può rimuovere un elemento dalla parte anteriore del vettore. Il seguente programma illustra questo:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
Vector :: iteratore Q = VTR.inizio();
Vector :: iterator P = VTR.cancella (q);
cout << *p << endl;
per (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;
per (Vector :: iterator IT = VTR.inizio(); Esso != vtr.FINE(); It ++)
cout << *it << ";
cout << endl;
restituzione 0;

L'output è:

B
B C D E
B C D E

Le prime due righe del programma includono direttive, comprese le biblioteche necessarie. La riga successiva dichiara che qualsiasi nome utilizzato provenga dallo spazio dei nomi standard se non diversamente indicato.

Nella funzione principale (), la prima istruzione dichiara il vettore. L'istruzione dopo il restituzione di un iteratore, Q, che indica il primo elemento del vettore. La dichiarazione che segue è la dichiarazione di interesse. Rimuove il primo elemento, a cui è indicato da Q. Restituisce un iteratore che indica l'elemento, che è stato subito dopo che l'elemento è stato rimosso. L'istruzione dopo stampa il valore dell'elemento, l'iteratore punta dopo la rimozione. I successivi due segmenti di codice visualizzano i valori rimanenti nel vettore. Il primo di questi segmenti di codice utilizza i riferimenti. Il secondo usa iteratori.

Rimozione dall'interno
Al fine di rimuovere l'elemento di valore, "C", l'iteratore restituito, per inizio () deve essere incrementato due volte per indicare l'elemento di valore, "c". La funzione membro Cancella () può quindi utilizzare l'iteratore per rimuovere l'elemento. Il seguente programma illustra questo:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
Vector :: iteratore Q = VTR.inizio();
Q ++; Q ++;
Vector :: iterator P = VTR.cancella (q);
cout << *p << endl;
per (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;
per (Vector :: iterator IT = VTR.inizio(); Esso != vtr.FINE(); It ++)
cout << *it << ";
cout << endl;
restituzione 0;

L'output è:

D
A b d e
A b d e

Rimozione dalla parte posteriore con cancellazione ()
Al fine di rimuovere l'elemento di valore, "e", l'iteratore restituito, entro la fine () deve essere decrementato una volta, per indicare l'elemento di valore, "e". La funzione membro Cancella () può quindi utilizzare l'iteratore per rimuovere l'elemento. Il seguente programma illustra questo:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
Vector :: iteratore Q = VTR.FINE();
Q--;
Vector :: iterator P = VTR.cancella (q);
cout << *p << endl;
per (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;
per (Vector :: iterator IT = VTR.inizio(); Esso != vtr.FINE(); It ++)
cout << *it << ";
cout << endl;
restituzione 0;

L'output è:

E
A b c d
A b c d

C'è una sfumatura qui. L'iteratore restituito per fine () punta all'elemento, che avrebbe dovuto essere lì, se non fosse stato rimosso.

Rimozione con pop_back

La funzione membro pop_back () rimuove l'ultimo elemento del vettore, per definizione. Quindi il programmatore non ha bisogno di identificare l'ultimo elemento. La sua sintassi è

UN.pop_back ()

dove "a" è il nome del vettore. Non ci vuole argomento; restituisce vuoto. Il seguente programma rimuove l'ultimo elemento di un vettore:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
VTR.pop_back ();
per (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;
per (Vector :: iterator IT = VTR.inizio(); Esso != vtr.FINE(); It ++)
cout << *it << ";
cout << endl;
restituzione 0;

L'output è:

A b c d
A b c d

Conclusione

Il vettore C ++ ha molte funzioni dei membri. Due di queste funzioni membro sono cancellate () e pop_back (). pop_back () rimuove l'ultimo elemento dal vettore. Per rimuovere tutti gli elementi dal vettore, usando pop_back (), la funzione pop_back () deve essere ripetuta il numero di volte in cui ci sono elementi. La funzione cancella () può rimuovere un elemento dall'inizio, all'interno o alla fine del vettore. Al fine di rimuovere tutti gli elementi dal vettore, usando la funzione di cancella (), la funzione Cancella () deve essere ripetuta il numero di volte in cui ci sono elementi, a partire dal primo elemento.

Per rimuovere un elemento specifico dal vettore C ++, l'elemento deve essere identificato. Per la funzione membro Canase (), l'elemento è identificato da un iteratore. Poiché la funzione membro pop_back () rimuove l'ultimo elemento per definizione, l'elemento specifico che deve rimuovere è già stato identificato indirettamente.