Umgekehrte Wörter in einer Zeichenfolge mit C ++ umgekehrt

Eine String -Variable besteht aus einer Sammlung von Zeichen, die von doppelten Zitaten umgeben sind. In diesem C ++-Artikel wird die Wörter in einer Zeichenfolge mit integrierten und anderen Funktionen umgekehrt.

Umkehrenden oder vollständig umdrehen eine Zeichenfolge in C ++ impliziert, dass die Abfolge der Zeichen in der Zeichenfolge nach hinten angezeigt wird, um rückwärts zu erscheinen. Abhängig von den Anforderungen des Programms, das Sie implementieren, können wir eine Vielzahl von Implementierungen verwenden, um eine Zeichenfolge umzukehren.

Beispiel 1: Verwendung der integrierten Umkehrfunktion zum Umkehr von Wörtern in einer Zeichenfolge in C++

C ++ enthält eine umgekehrte Funktion zum Umkehr von Zeichenfolgen. Der String -Start -Iterator und der String -End -Iterator sind die einzigen beiden Parameter, die von dieser Funktion akzeptiert werden. Die nachfolgende Codezeile zeigt die Verwendung dieser Funktion.

Zunächst haben wir die Header -Datei in den Code aufgenommen. Die iOstream -Datei und die STDC -Datei. Diese STDC -Datei ermöglicht hier die Reverse -String -Funktion. Die STD -Namespace -Datei wird ebenfalls bereitgestellt, um die Verwendung ihrer Klassen und Funktionen im Code zu ermöglichen.

Dann haben wir die Hauptfunktion des Programms und in der Hauptfunktionskörper haben wir eine String -Variable -Deklaration als "StrValue". Gleichzeitig haben wir es mit dem Wort initialisiert. Die Ausgangszeichenfolge wird über den Befehl c ++ cout angezeigt. Danach verwenden wir eine Funktion namens "Reverse". Die Funktion „umgekehrt“ wird zwei Parameter aufnimmt. Der erste Parameter ist der Beginn (), und der zweite Parameter ist der Ende () Iterator, der über die angegebene Zeichenfolge iteriert. Die Funktion begin () gibt einen Iterator zurück, der sich auf das ursprüngliche Element des Containers bezieht.

Andererseits gibt das Iterator in End () einen Iterator zurück, der sich auf das letzte Element des Containers bezieht. Das umgekehrte Zeichenfolgenwort wird nach der Umkehrfunktion gedruckt.

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()
String StrValue = "ausgezeichnet";
Cout<<"String:"<umgekehrt (StrValue.begin (), StrValue.Ende());
Cout<<"Reverse String:"<

Die Ergebnisse der Zeichenfolge sowie der invertierte Zeichenfolge sind im folgenden Bild angezeigt:

Beispiel 2: Verwendung von für die Schleife zum Umkehren von Wörtern in einer Zeichenfolge in C++

Eine Schleife ist nützlich, um eine Zeichenfolge umzukehren. Um die Orte von Elementen zu ändern, werden wir die Swap-Funktion verwenden, die eine integrierte Methode von C ist++. Lassen Sie uns den folgenden Code -Snippet besprechen, um eine Zeichenfolge umzukehren.

Wir haben die Header -Dateien im Code hinzugefügt. Im nächsten Schritt haben wir die Hauptfunktion aufgerufen, in der wir den Code für die Umkehrung einer Zeichenfolge implementieren. Erstens haben wir eine String -Variable "MyString" definiert. Die String -Variable "MyString" enthält ein Wort der Zeichenfolge "kalsoom", auf das wir die umgekehrte Methode anwenden müssen. Wir haben die Zeichenfolge mit der Cout -Anweisung angezeigt. Dann haben wir eine int -Variable „Strlen“ deklariert, die als Längenfunktion für die angegebene Zeichenfolge bezeichnet wurde. Wir haben auch eine weitere Int-Variable "S" deklariert, um das "Strlen-1" zu halten. Das "Strlen-1" -Verfahren benötigt die Länge der Zeichenfolge bis zum Charakter an der letzten Position.

Dann haben wir einen Swap -Algorithmus, bei dem „Temperatur“ verwendet wird, um die Elemente des „Chars“ im Index „I“ zu speichern, damit wir ihn später mit den Char -Elementen in den Index „S“ austauschen können. Die umgekehrte Zeichenfolge dieses Programms wird dann angezeigt. Danach haben wir eine für die Schleifenbedingung, die das Wort der angegebenen Zeichenfolge umgeht.

#enthalten
Verwenden von Namespace STD;
int main ()
String mystring = "kalsoom";
Cout<<"Original String: "<int strlen = mystring.Länge();
int s = strlen-1;
für (int i = 0; i<(strlen/2);i++)
char temp = mystring [i];
MyString [i] = MyString [s];
MyString [s] = temp;
S = S-1;

Cout<<"Reversed String: "<

Sie können die ursprüngliche Zeichenfolge „kalsoom“ und die Rückseite der angegebenen Zeichenfolge auf der Ubuntu -Eingabeaufforderung sehen.

Beispiel 3: Verwendung einer Funktion zum Umkehren von Wörtern in einer Zeichenfolge in C++

Rekursion wird auch verwendet, um eine Reverse -Zeichenfolge -Funktion zu erstellen. Die nachfolgende Code -Abbildung zeigt, wie wir die Zeichenfolge über die Funktion umkehren können.

Im ersten Schritt haben wir eine Funktion namens "Revstr", und der Konstruktor wird auch für diese Funktion generiert. Der Konstruktor nimmt die String -Referenz, die Ganzzahlvariable "I" und die andere Ganzzahlvariable "J" über. In der Funktion "revstr" haben wir die IF -Bedingung und die Swap -Funktion, die den Index "I" mit dem Index "J" ausgetauscht hat. Die Funktion "revstr" ist gebannt, damit das nächste Wort der String umgekehrt ist.

Am Ende hat die Hauptfunktion den Befehl cout, mit dem die Zeichenfolge vor der umgekehrten Methode und nach der umgekehrten Methode gedruckt wird.

#enthalten
Verwenden von Namespace STD;
void revstr (String & str, int i, int j)
wenn ich<=j)return;
Swap (Str [i], Str [j]);
Revstr (STR, I-1, J+1);

int main ()
String mystr = "Linux";
Cout<<"String: "<Revstr (Mystr, Mystr.Länge ()-1,0);
Cout<<"Reversed String: "<

Der folgende Screenshot zeigt die Ausgabe der Zeichenfolge vor und nach dem Auftragen der Funktion:

Beispiel 4: Erstellen einer neuen Zeichenfolge zum Umkehren von Wörtern in einer Zeichenfolge in C++

Rückwärts über eine Schnur zu schieben und den Inhalt in einer neuen Saite derselben Größe zu halten, ist ein Kreisverkehrsansatz, um ihn umzukehren. Die Push-Back () -Methode kann Zeichen zu einer leeren Zeichenfolge hinzufügen.

In der Hauptfunktion des folgenden Programms haben wir eine String -Variable „StringOne“ deklariert und ein Wort der Zeichenfolge darin gespeichert. Dann haben wir eine weitere Variable deklariert, "new_string". Die for -Schleife wird für die String -Variable "StringOne" verwendet, die das letzte Zeichen in der Zeichenfolge iteriert und die Zeichenfolge in umgekehrter Reihenfolge zurückgibt. Dann haben wir mit der Methode push_back () den String -Wert hinzugefügt, der von der für die Loop in das New_String zurückgegeben wurde. Am Ende werden die Zeichenfolge und die umgekehrte Zeichenfolge gedruckt.

#enthalten
Verwenden von Namespace STD;
int main ()
string stringOne = "programmieren";
String new_string;
für (int s = StringOne.Länge ()-1; S> = 0; S--)
New_String.push_back (stringOne [s]);

Cout<<"String: "<Cout<<"Reversed string: "<

Die folgenden Ergebnisse werden gezeigt, dass die Zeichenfolge bei der Ausführung des vorherigen Programms umgekehrt wird:

Abschluss

Hier haben wir die Wörter Zeichenfolge umgekehrt, indem wir die möglichen Möglichkeiten untersuchten, die Zeichenfolge in C umzukehren++. Wir haben die Zeichenfolge mit der C ++ integrierten Funktion, der Schleifenmethode und -funktion und der Erstellung einer neuen Zeichenfolge umgekehrt. Alle Ergebnisse, die aus diesen Methoden zur Umkehrung von String -Methoden erzielt wurden.04.