C ++ String entfernen Sie das letzte Zeichen

Die C ++ - String -Klasse hat viele Mitgliederfunktionen. Zwei von ihnen sind die Funktionen pop_back () und die erase (). Die Funktion pop_back () entfernt das letzte Element aus der Zeichenfolge. Die Funktion erase () kann ein Element überall in der Zeichenfolge löschen. Es gibt drei Varianten der Löschfunktion. Sie unterscheiden sich in den Argumenten, die sie einnehmen. Solche gleichnamigen Funktionen werden überlastete Funktionen bezeichnet.

C ++-Zeichenfolgen können auf zwei Hauptarten deklariert werden: als konstanter Zeiger auf Zeichen (Array-of-Carray) oder aus der String-Klasse der String-Bibliothek instanziiert. Hier sind die Funktionen pop_back () und erase () vom String -Objekt, das aus der String -Klasse instanziiert ist. Das letzte Element eines Array-of-Care-Unternehmens kann nicht entfernt werden.

Es ist wahr, dass ein String -Literal aus Werten besteht, die Zeichen sind. Jedes Zeichen liegt in einem Element. Das Streichliteral besteht also tatsächlich aus Elementen. Das letzte Zeichen wird mit seinem letzten Element entfernt.

In diesem Artikel wird erläutert, wie das letzte Element einer Zeichenfolge zusammen mit seinem Charakter entfernt wird.

Artikelinhalt

• void pop_back ()
• Iterator -Löschen (const_iterator p)
• Iterator -Löschen (const_iterator zuerst, const_iterator zuletzt)
• Basic_string & Erase (size_type pos = 0, size_type n = npos)
• Abschluss

void pop_back ()

Diese Mitgliedsfunktion der String -Klasse entfernt das letzte Element der Zeichenfolge. Die Funktion gibt ungültig zurück. Dies bedeutet, dass nichts daraus zurückgegeben wird und keine Variable etwas erhalten kann, das daraus zurückgegeben wird. Die Verwendung dieser Funktion wird im folgenden Programm dargestellt:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

String str = "lmnopqr";
Cout <str.Pop zurück();
für (int i = 0; iCout <Cout <Rückkehr 0;

Die Ausgabe ist:

Lmnopqr
Lmnopq

Der letzte Charakter wurde entfernt. Die ersten beiden Zeilen des Programms enthalten die erforderlichen Bibliotheken. Einer von ihnen ist natürlich die String -Bibliothek. Die String -Bibliothek muss enthalten sein, da alle beteiligten Zeichenfolgen aus der String -Klasse instanziiert werden. Die nächste Zeile ist eine Aussage. Es erklärt, dass alle Namen darunter im Standard -Namespace sind, sofern nicht anders angegeben.

Der Haupt () -Funktionskörper beginnt mit der Deklaration (Instanziierung) des String -Objekts. In der nächsten Aussage wird das wörtliche dieser neu deklarierten Zeichenfolge bei der Ausgabe angezeigt. In der Anweisung nach dem Last -Zeichen wird unter Verwendung der Member -Funktion pop_back () verwendet. Das nächste Code-Segment verwendet eine FOR-Schleife mit Indizes, um alle Zeichen, die nicht mehr die letzte haben, in einer kontinuierlichen Reihenfolge anzuzeigen.

Iterator -Löschen (const_iterator p)

Wenn der Iterator auf das letzte Element (Zeichen) verweist, kann die Funktion der Löschelemente das letzte Element entfernen. Diese Funktion gibt einen Iterator zurück, der kurz nach dem Entfernen auf das Element verweist (oder kurz nach dem letzten Element, wenn das entfernt das letzte Element war). Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

String str = "lmnopqr";
Cout <String :: Iterator p = str.Ende();
P--;
String :: Iterator it = str.löschen (p);
für (int i = 0; iCout <Cout <Rückkehr 0;

Die Ausgabe ist:

Lmnopqr
Lmnopq

Die ersten drei Zeilen des Programms werden auf die gleiche Weise wie im vorherigen Programm erklärt. Im Main () -Funktionskörper deklariert die erste Anweisung das String -Objekt. In der nächsten Aussage wird das wörtliche dieser neu deklarierten Zeichenfolge bei der Ausgabe angezeigt. Dieser Druck hätte immer noch mit einem Vorstoß gemacht werden können. Die Aussage nach dem After erhält einen Iterator, der kurz nach dem letzten Zeichenelement zeigt. Dies geschieht mit der Mitgliedsfunktion End (). Beachten Sie die Art und Weise, wie der Iterator deklariert wurde (linke Seite von, =). Dann wird der Iterator dekrementiert, um auf das letzte Element zu verweisen.

Als nächstes wird das letzte Element mit der ERASE () -Member -Funktion entfernt. Das nächste Code-Segment verwendet eine FOR-LOOP mit Indizes, um alle Zeichen anzuzeigen, die nicht mehr den letzten am Terminal in einer kontinuierlichen Reihenfolge haben.

Iterator -Löschen (const_iterator zuerst, const_iterator zuletzt)

Diese Mitgliedsfunktion würde eine Reihe von Zeichenelementen aus der Zeichenfolge löschen. Hier ist zuerst ein Iterator, der auf das erste Element des Bereichs zeigt. Der Iterator kehrte auf das Element zurück, das dort war, kurz nach dem Bereich. Wenn es dort keine Elemente gäbe, würde es auf das Ende der Saite hinweisen. Last ist ein Iterator, der auf das letzte Element des Bereichs verweist. Dieses letzte Element ist nicht an der Löschung beteiligt.

Um das letzte Element zu entfernen, besteht der Trick darin, "Letzte" direkt über das letzte Element der Zeichenfolge hinauszusetzen. und machen Sie den "ersten" Punkt auf das letzte Element der Zeichenfolge. Mit all dem wird die Löschfunktion das letzte Element abnehmen. Das folgende Programm zeigt, wie es gemacht wird:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

String str = "lmnopqr";
Cout <String :: Iterator p = str.Start();
p = p + 6;
String :: Iterator q = str.Ende();
String :: Iterator it = str.löschen (p, q);
für (it = -it; es> = str.Start(); Es--)
Cout << *it;
Cout <Rückkehr 0;

Die Ausgabe ist:

Lmnopqr
Qponml

Nach dem Entfernen des Zeichens R (zusammen mit seinem Element) wurde die verbleibende Zeichenfolge Zeichen für Zeichen gedruckt, jedoch in umgekehrter Reihenfolge, aber in umgekehrter Reihenfolge.

Die ersten drei Zeilen des Programms werden auf die gleiche Weise wie im vorherigen Programm erklärt. Im Main () -Funktionskörper deklariert die erste Anweisung das String -Objekt. In der nächsten Anweisung wird die neu deklarierte Zeichenfolge ausgegeben.

Das folgende Codesegment enthält drei Aussagen. Der erste erklärt einen Iterator, der auf den ersten Zeichen der String hinweist. Sechs weitere Zeichen der Zeichenfolge müssen vor dem letzten Zeichen gezählt werden, 'R' ist erreicht. Die zweite Aussage dieses Segments fügt dem Iterator 6 hinzu. Die nächste Aussage in diesem Segment erklärt einen Iterator, Q, der kurz nach dem Ende der Zeichenfolge zeigt. Die Situation ist nun festgelegt, um das letzte Element zu löschen: Q Punkte kurz nach 'R' und Ppunkten auf 'R'.

Die Aussage, die 'r' löscht, lautet:

String :: Iterator it = str.löschen (p, q);

Nachdem 'R' gelöscht wurde, wird der letzte Charakter zu 'Q'. Der zurückgegebene Iterator, 'es' hier, zeigt kurz nach 'q'.

Das nächste Code-Segment ist ein For-Loop. Die Initialisierungsaussage dieser For-Schleife verringert einfach "es", um auf den neuen letzten Charakter zu verweisen, 'Q'. 'Q' wird zum Terminal gedruckt. Die For-Loop verringert weiterhin „IT“ und druckt den entsprechenden Charakter, während 'It' größer ist als Str.Start(). Wenn „es“ gleich ist.begin (), das heißt, „es“ zeigt auf 'l', die für Schleife drucke 'l' und stoppt. Auf diese Weise wird die Zeichenfolge ohne 'R' in umgekehrter Reihenfolge gedruckt.

Um den auf einen Iterator gerichteten Wert zu erhalten, gehen Sie dem Iterator mit dem Indirektionoperator * vor, * .

Basic_string & Erase (size_type pos = 0, size_type n = npos)

Diese Mitgliedsfunktion löscht einen Bereich, genau wie die obige Funktion. Es verwendet jedoch Indizes und nicht Iteratoren. Wenn das Argument POS 0 ist, beginnt der Bereich vom ersten Element aus. Wenn das Argument n die Länge der Zeichenfolge (Anzahl der Zeichen) ist, endet der Bereich am letzten Zeichen. Beide Argumente haben ihre Standardwerte. Diese Funktion gibt das String -Klasse -Objekt zurück, wobei die Zeichen des Bereichs entfernt werden.

Der Trick, hier zu spielen, besteht darin, den Wert von POS den Index des letzten Charakters zu machen. Der Index des letzten Zeichens (Element) ist die Größe (Länge) der Liste minus 1. Das zweite Argument hier sollte für dieses Problem weggelassen werden. Der letzte Index ist gegeben von,

str.size () - 1

Das folgende Programm verwendet diese Mitgliedsfunktion, um das letzte Zeichen 'R' aus der Zeichenfolge abzunehmen:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

String str = "lmnopqr";
Cout <int l = str.size () - 1;
String ret = str.löschen (l);
für (int i = 0; i Cout <Cout <für (int i = 0; i Cout <Cout <Rückkehr 0;

Die Ausgabe ist:

Lmnopqr
Lmnopq
Lmnopq

Sowohl die ursprüngliche als auch die zurückgegebene Zeichenfolge verloren 'R'. Die ersten drei Zeilen des Programms werden auf die gleiche Weise wie im vorherigen Programm erklärt. Im Main () -Funktionskörper deklariert die erste Anweisung das String -Objekt. In der nächsten Anweisung wird die neu deklarierte Zeichenfolge ausgegeben.

Die nächste Anweisung bestimmt den Index des letzten Elements des ursprünglichen Zeichens. Die Aussage nach dem Löschungsschiff des letzten Zeichens unter Verwendung dieses Index. Das nächste Codesegment druckt die Zeichen der Rückgabezeichenfolge nacheinander mit Indizes aus. Das letzte Codesegment druckt die Zeichen der ursprünglichen Zeichenfolge nacheinander mit Indizes aus.

Abschluss

Die Normal -String -Klasse -Mitgliedsfunktion, um das letzte Zeichen einer Zeichenfolge mit ihrem Element zu entfernen, ist die Funktion pop_back (). Es gibt drei überlastete Mitgliederfunktionen, die auch dafür verwendet werden können. Einer von ihnen nimmt einen Iterator, der auf den letzten Charakter verweist und den letzten Charakter entfernt. Ein anderer nimmt eine Reichweite, die von zwei Iteratoren angezeigt wird: Ein Iterator zeigt auf den letzten Charakter, und der andere zeigt kurz nach dem letzten Charakter. Damit wird der letzte Charakter abgenommen. Die dritte überlastete Funktion verwendet den Index des letzten Zeichens, um ihn zu entfernen. Die gesamte Diskussion in diesem Artikel war C ++ 20 konform.