HOWTO · C++
Wie man eine Zeichenkette in C++ umkehrt
Dieser Artikel führt ein, wie man eine Zeichenkette in C++ umkehrt
Auf dieser Seite
Um eine C++-Zeichenkette umzukehren, entscheiden Sie zunächst, ob das Original verändert werden soll. Erzeugen Sie mit Reverse-Iteratoren eine neue std::string, wenn die Quelle erhalten bleiben soll, oder rufen Sie std::reverse auf der Zeichenkette auf, wenn eine Änderung an Ort und Stelle passend ist. Mit std::copy können Sie eine Zielzeichenkette füllen oder die umgekehrten Zeichen direkt in einen Ausgabestrom schreiben. Eine Schleife veranschaulicht die Verarbeitung einzelner Elemente; Rekursion eignet sich vor allem als Lernbeispiel.
Eine Vorgehensweise zum Umkehren einer Zeichenkette auswählen
Verwenden Sie in den meisten Programmen Reverse-Iteratoren, um ein separates Ergebnis zu erzeugen, oder std::reverse, um eine vorhandene Zeichenkette umzuordnen. Beide Verfahren arbeiten mit den Elementen von std::string, also mit Werten vom Typ char. Enthält der Text UTF-8, kann das Umkehren dieser Bytes mehrbyteige Zeichen beschädigen. Lesen Sie deshalb den letzten Abschnitt, bevor Sie diese Verfahren auf natürlichsprachlichen Text anwenden.
Eine Zeichenkette mit Reverse-Iteratoren umkehren
Die Iteratoren rbegin() und rend() einer Zeichenkette durchlaufen ihre Elemente vom letzten bis zum ersten. Werden sie an den Konstruktor von std::string übergeben, entsteht eine umgekehrte Kopie; die Quelle bleibt unverändert. Das ist eine direkte Möglichkeit, wenn beide Zeichenketten verfügbar bleiben sollen.
Führen Sie dieses Beispiel aus:
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
#include <iostream>
#include <string>
int main() {
const std::string original = "Hello, C++!";
const std::string reversed(original.rbegin(), original.rend());
std::cout << "Original: " << original << '\n';
std::cout << "Reversed: " << reversed << '\n';
}
Der Konstruktor erhält ein Iteratorpaar, das die Reihenfolge der Elemente in der neuen Zeichenkette festlegt. Das Original bleibt für eine spätere Verwendung erhalten; die neue Zeichenkette enthält die umgekehrte Folge.
Eine Zeichenkette mit std::reverse direkt umkehren
std::reverse ist ein in <algorithm> deklarierter Algorithmus. Er vertauscht Elemente im halboffenen Bereich vom ersten Iterator bis zum zweiten, wobei der zweite Iterator nicht mehr dazugehört. Der übergebene Bereich wird verändert; eine umgekehrte Kopie wird nicht zurückgegeben. Das folgende Programm wendet den Algorithmus auf eine Kopie an, damit beide Fassungen ausgegeben werden können:
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
#include <algorithm>
#include <iostream>
#include <string>
int main() {
const std::string original = "Hello, C++!";
std::string changed = original;
std::reverse(changed.begin(), changed.end());
std::cout << "Original: " << original << '\n';
std::cout << "Changed: " << changed << '\n';
}
Soll das Original selbst verändert werden, rufen Sie stattdessen std::reverse(original.begin(), original.end()) für eine nicht konstante Zeichenkette auf. Dafür muss keine zweite Zeichenkette angelegt werden. Verlassen Sie sich nicht darauf, dass der Algorithmus einen Allokationsfehler meldet: Er ordnet lediglich die Elemente des Bereichs neu und führt selbst keine Speicherallokation aus.
Mit std::copy eine umgekehrte Zeichenkette erstellen
std::copy kopiert Elemente aus einem Eingabebereich in einen Zielbereich; die Größe einer Zielzeichenkette wird dadurch nicht angepasst. Sorgen Sie vor dem Kopieren dafür, dass der Zielbereich genügend Elemente enthält. Reverse-Iteratoren kehren die Reihenfolge der kopierten Elemente um. Wenn Sie die Zeichen nur anzeigen möchten, können Sie mit einem Ausgabeiterator auf eine zusätzliche gespeicherte Zeichenkette verzichten.
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
#include <algorithm>
#include <iostream>
#include <iterator>
#include <string>
int main() {
const std::string original = "Hello, C++!";
std::string reversed(original.size(), '\0');
std::copy(original.rbegin(), original.rend(), reversed.begin());
std::cout << "Copy: " << reversed << '\n';
std::cout << "Stream: ";
std::copy(original.rbegin(), original.rend(),
std::ostream_iterator<char>(std::cout));
std::cout << '\n';
}
Der Zeichenkettenkonstruktor erzeugt ein Ziel mit der erforderlichen Elementanzahl. Damit ist der Ausgabebereich groß genug für die Quelle. std::ostream_iterator schreibt jedes kopierte Zeichen nach std::cout; die Deklaration befindet sich in <iterator>. Durch std:: vor den Algorithmusnamen wird deren Namensraum ausdrücklich angegeben.
Eine Zeichenkette mit einer Schleife umkehren
Eine Schleife kann Elemente vom Ende der Quelle bis zu ihrem Anfang an eine neue Zeichenkette anhängen. Die Iteration mit std::string::size_type vermeidet die Umwandlung der Zeichenkettenlänge in eine vorzeichenbehaftete Ganzzahl. Die folgende Form mit Dekrement und anschließender Prüfung endet außerdem, bevor von null subtrahiert wird:
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
#include <iostream>
#include <string>
int main() {
const std::string original = "Hello, C++!";
std::string reversed;
reversed.reserve(original.size());
for (std::string::size_type i = original.size(); i > 0; --i) {
reversed.push_back(original[i - 1]);
}
std::cout << reversed << '\n';
}
Das Reservieren von Kapazität ist eine optionale Optimierung, die wiederholtes Vergrößern beim Anhängen vermeiden kann. Die Schleife eignet sich, um den Vorgang zu verstehen oder eine Verarbeitung pro Element hinzuzufügen. Für das gewöhnliche Umkehren sind die Verfahren der Standardbibliothek kürzer und leichter wiederzuerkennen.
Eine Zeichenkette rekursiv umkehren
Rekursiv lässt sich das Umkehren so ausdrücken, dass zunächst das letzte Element genommen und anschließend die vorhergehende Teilzeichenkette verarbeitet wird. Diese Variante gibt eine neue Zeichenkette zurück und veranschaulicht dieses Prinzip:
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
#include <iostream>
#include <string>
std::string reverseString(const std::string& value) {
if (value.size() < 2) {
return value;
}
return value.back() + reverseString(value.substr(0, value.size() - 1));
}
int main() {
const std::string original = "Hello, C++!";
std::cout << reverseString(original) << '\n';
}
Bei jedem rekursiven Schritt wird eine Teilzeichenkette erzeugt. Dadurch können viele Daten kopiert und zahlreiche Funktionsaufrufe ausgeführt werden. Bei langen Eingaben kommt außerdem eine tiefe Aufrufkette hinzu. Verwenden Sie in produktivem Code bevorzugt Reverse-Iteratoren oder std::reverse, sofern Rekursion nicht selbst das Lehrthema ist.
Leere Zeichenketten und Zeichenkodierung berücksichtigen
Bei einer leeren Zeichenkette erzeugt der Konstruktor mit Reverse-Iteratoren wieder eine leere Zeichenkette, und der an std::reverse übergebene Bereich enthält keine Elemente. Die Schleife wird kein einziges Mal durchlaufen. Das rekursive Beispiel kehrt im Basisfall zurück. Für leere Eingaben benötigen diese Verfahren daher weder eine besondere Ausgabe noch eine eigene Umkehrlogik.
Ein std::string speichert char-Elemente und keine abstrakten Unicode-Zeichen. In UTF-8 kann ein sichtbares Zeichen mehrere Bytes belegen; ein vom Menschen wahrgenommenes Zeichen kann außerdem aus mehreren Unicode-Codepoints bestehen. Das Umkehren der Bytes kann die Kodierung beschädigen. Selbst beim Umkehren von Codepoints kann eine Graphemgruppe getrennt werden, etwa ein Buchstabe mit Akzent. Für mehrsprachigen Text sollten Sie ihn dekodieren und eine Unicode-fähige Bibliothek verwenden, um die für die Anwendung erforderlichen Einheiten umzukehren, häufig Graphemcluster.