String C ++ Rimuovere l'ultimo carattere

La classe String C ++ ha molte funzioni dei membri. Due di loro sono le funzioni pop_back () e cancella (). La funzione pop_back () rimuove l'ultimo elemento dalla stringa. La funzione cancella () può cancellare un elemento ovunque nella stringa. Esistono tre varianti della funzione di cancellazione. Differiscono nel tipo di argomenti che prendono. Tali funzioni con lo stesso nome sono chiamate funzioni sovraccarichi.

Le stringhe C ++ possono essere dichiarate in due modi principali: come puntatore costante ai caratteri (array-of-chars) o istanziate dalla classe stringa della libreria di stringhe. Qui, le funzioni pop_back () e cancella () sono dell'oggetto stringa, istanziato dalla classe stringa. L'ultimo elemento di una matrice di camer non può essere rimosso perché una matrice di camer non è un oggetto istanziato.

È vero che una stringa letterale è costituita da valori che sono caratteri. Ogni personaggio è all'interno di un elemento. Quindi la stringa letterale è in realtà consiste in elementi. L'ultimo personaggio viene rimosso con il suo ultimo elemento.

Questo articolo spiega come rimuovere l'ultimo elemento di una stringa, insieme al suo carattere.

Contenuto dell'articolo

• void pop_back ()
• Iterator Erase (const_iterator P)
• Iterator Erase (const_iterator First, const_iterator Last)
• BASIC_STRING & ERASE (size_type pos = 0, size_type n = NPO)
• Conclusione

void pop_back ()

Questa funzione membro della classe stringa rimuove l'ultimo elemento della stringa. La funzione restituisce vuoto. Ciò significa che nulla viene restituito da esso e nessuna variabile può ricevere nulla da esso. L'uso di questa funzione è illustrato nel seguente programma:

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

string str = "lmnopqr";
cout <str.pop_back ();
per (int i = 0; icout <cout <restituzione 0;

L'output è:

Lmnopqr
Lmnopq

L'ultimo personaggio è stato rimosso. Le prime due righe del programma includono le librerie necessarie. Uno di questi, ovviamente, è la libreria di stringhe. La libreria di stringhe deve essere inclusa poiché tutte le stringhe coinvolte sono istanziate dalla classe stringa. La riga successiva è una dichiarazione. Dichiara che tutti i nomi sotto di esso sono dello spazio dei nomi standard se non diversamente indicato.

Il corpo della funzione principale () inizia con la dichiarazione (istanza) dell'oggetto stringa. L'istruzione successiva mostra il letterale di questa stringa recentemente dichiarata all'output. L'istruzione dopo rimuove l'ultimo carattere, usando la funzione membro pop_back (). Il segmento di codice successivo utilizza un per loop con indici per visualizzare tutti i caratteri, che non hanno più l'ultimo, in una sequenza continua.

Iterator Erase (const_iterator P)

Se l'iteratore punta all'ultimo elemento (carattere), la funzione del membro Cancella può rimuovere l'ultimo elemento. Questa funzione restituisce un iteratore che indica l'elemento subito dopo quello rimosso (o subito dopo l'ultimo elemento, se quello rimosso era l'ultimo elemento). Il seguente programma illustra questo:

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

string str = "lmnopqr";
cout <String :: iterator P = STR.FINE();
P--;
String :: iterator IT = STR.Cancella (P);
per (int i = 0; icout <cout <restituzione 0;

L'output è:

Lmnopqr
Lmnopq

Le prime tre righe del programma sono spiegate allo stesso modo del programma precedente. Nel corpo della funzione principale (), la prima istruzione dichiara l'oggetto stringa. L'istruzione successiva mostra il letterale di questa stringa recentemente dichiarata all'output. Questa stampa avrebbe potuto ancora essere eseguita con un percorso per loop. La dichiarazione dopo ottiene un iteratore che punta subito dopo l'ultimo elemento del personaggio. Questo viene fatto con la funzione membro, end (). Nota il modo in cui è stato dichiarato l'iteratore (lato sinistro di, =). Quindi l'iteratore viene decrementato per indicare l'ultimo elemento.

Successivamente, l'ultimo elemento viene rimosso con la funzione del membro Cerase (). Il segmento di codice successivo utilizza un per loop con indici per visualizzare tutti i caratteri, che non hanno più l'ultimo al terminale in una sequenza continua.

Iterator Erase (const_iterator First, const_iterator Last)

Questa funzione membro cancellerebbe una serie di elementi di caratteri fuori dalla stringa. Qui, il primo è un iteratore che indica il primo elemento dell'intervallo. L'iteratore ha restituito punti all'elemento che era lì, subito dopo l'intervallo. Se non ci fossero elementi lì, indicherebbe la fine della stringa. L'ultimo è un iteratore che indica l'ultimo elemento dell'intervallo. Quest'ultimo elemento non è coinvolto nella cancellazione.

Per rimuovere l'ultimo elemento, il trucco è fare "ultimo", puntare appena oltre l'ultimo elemento della stringa; e fai il "primo" punto all'ultimo elemento della stringa. Con tutto ciò, la funzione di cancellazione toglierà l'ultimo elemento. Il seguente programma mostra come viene fatto:

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

string str = "lmnopqr";
cout <String :: iterator P = STR.inizio();
p = p + 6;
String :: iteratore Q = STR.FINE();
String :: iterator IT = STR.cancella (p, q);
per (it = --it; it> = str.inizio(); Esso--)
cout << *it;
cout <restituzione 0;

L'output è:

Lmnopqr
Qponml

Dopo aver rimosso il carattere, R (insieme al suo elemento), la stringa rimanente è stata stampata per carattere per carattere, ma nell'ordine inverso.

Le prime tre righe del programma sono spiegate allo stesso modo del programma precedente. Nel corpo della funzione principale (), la prima istruzione dichiara l'oggetto stringa. La prossima istruzione stampica la stringa appena dichiarata.

Il segmento di codice che segue ha tre dichiarazioni. Il primo dichiara un iteratore che indica il primo carattere della stringa. Altri sei caratteri della stringa devono essere contati prima dell'ultimo personaggio, 'r'. Quindi, la seconda affermazione di questo segmento aggiunge 6 all'iteratore. L'istruzione successiva in questo segmento dichiara un iteratore, Q, che punta subito dopo la fine della stringa. La situazione è ora impostata per cancellare l'ultimo elemento: Q punti subito dopo "R" e P punti a "R".

L'affermazione che cancella 'R' è:

String :: iterator IT = STR.cancella (p, q);

Dopo aver cancellato 'R', l'ultimo personaggio diventa 'Q'. L'iteratore restituito, "It" qui, punta subito dopo "Q".

Il segmento di codice successivo è un per loop. La dichiarazione di inizializzazione di questo per loop diminuisce semplicemente "It" per indicare il nuovo ultimo personaggio, "Q". 'Q' è stampato sul terminale. Il per loop continua a decrescere "esso", stampando il carattere corrispondente, mentre "esso" è maggiore di STR.inizio(). Quando "esso" è uguale a STR.inizio (), cioè "esso" punta a "l", le stampe per loop "L" e si fermano. In questo modo, la stringa senza 'r' è stampata in ordine inverso.

Per ottenere il valore puntato a un iteratore, precedere l'iteratore con l'operatore indirezione, * .

BASIC_STRING & ERASE (size_type pos = 0, size_type n = NPO)

Questa funzione membro cancella un intervallo, proprio come la funzione sopra. Tuttavia, utilizza indici e non iteratori. Se l'argomento POS è 0, allora l'intervallo inizia dal primo elemento. Se l'argomento n è la lunghezza della stringa (numero di caratteri), allora l'intervallo termina all'ultimo carattere. Entrambi gli argomenti hanno i loro valori predefiniti. Questa funzione restituisce l'oggetto String Class, con i caratteri della gamma rimossi.

Il trucco da giocare qui è quello di rendere il valore di POS l'indice dell'ultimo personaggio. L'indice dell'ultimo carattere (elemento) è la dimensione (lunghezza) dell'elenco meno 1. Il secondo argomento qui dovrebbe essere omesso per questo problema. L'ultimo indice è dato da,

str.size () - 1

Il seguente programma, utilizza questa funzione membro, per togliere l'ultimo carattere, 'r' dalla stringa:

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

string str = "lmnopqr";
cout <int l = str.size () - 1;
String ret = STR.cancella (l);
per (int i = 0; i cout <cout <per (int i = 0; i cout <cout <restituzione 0;

L'output è:

Lmnopqr
Lmnopq
Lmnopq

Sia la stringa originale che quella restituita persa 'r'. Le prime tre righe del programma sono spiegate allo stesso modo del programma precedente. Nel corpo della funzione principale (), la prima istruzione dichiara l'oggetto stringa. La prossima istruzione stampica la stringa appena dichiarata.

L'istruzione successiva determina l'indice dell'ultimo elemento della stringa originale. L'istruzione dopo cancella l'ultimo personaggio usando questo indice. Il segmento di codice successivo stampa i caratteri della stringa di ritorno, uno per uno, usando gli indici. L'ultimo segmento di codice stampa i caratteri della stringa originale, uno per uno, usando indici.

Conclusione

La funzione membro della classe stringa normale, per rimuovere l'ultimo carattere di una stringa, con il suo elemento che la tiene, è la funzione pop_back (). Esistono tre funzioni dei membri sovraccaricate () che possono essere utilizzate anche per questo. Uno di loro prende un iteratore che indica l'ultimo personaggio e rimuove l'ultimo personaggio. Un altro prende un intervallo, indicato da due iteratori: un iteratore indica l'ultimo personaggio e gli altri punti subito dopo l'ultimo personaggio. Con ciò, l'ultimo personaggio viene tolto. La terza funzione sovraccarica utilizza l'indice dell'ultimo carattere per rimuoverlo. Tutta la discussione in questo articolo è stata conforme a C ++ 20.