Escape-Sequenzen verstehen
Escape-Sequenzen in C++ ermöglichen es den Zeichen, die die Steuerfunktionen innerhalb der Zeichenfolgen ausführen, Teil des Textes zu sein, ohne dass sie als Code verwechselt werden. Eine häufige Gefahr für Anfänger ist die Verwirrung darüber, ob Anführungszeichen in eine Literalzeichenfolge eingefügt werden sollen. Die folgende Codezeile führt beispielsweise zu einem Kompilierungsfehler, da die Anführungszeichen um „\t Escape-Sequenz“ die Zeichenfolge vorzeitig beenden:
Zeichenfolge txt = „In diesem Artikel geht es um die Erkundung der „ \T Escape-Sequenz“ anhand von Beispielen.“ ;Um dies in einem C++-Programm zu korrigieren, verwenden wir den Backslash „\“ als Escape-Zeichen, um dem Compiler zu signalisieren, dass das folgende Zeichen eine besondere Interpretation hat. So wird es gemacht:
Zeichenfolge txt = „In diesem Artikel geht es um die Erkundung der\“ \\ t Escape-Sequenz\“ anhand von Beispielen. ;
Eintauchen in das Sonderzeichen (\t) in C++
Die „\t“-Sequenz ist mehr als nur ein Abstandswerkzeug. Es stellt ein Tabulatorzeichen dar, das bewirkt, dass der Cursor zum nächsten Tabstopp wechselt. Dies ist besonders praktisch für die Erstellung sauber formatierter Textanzeigen in Terminalanwendungen. Über „\t“ hinaus unterstützt C++ eine Vielzahl von Escape-Sequenzen für unterschiedliche Zwecke – „\n“ erstellt beispielsweise eine neue Zeile. In diesem Artikel konzentrieren wir uns jedoch ausschließlich auf die Escape-Sequenz „\t“ in C++ und stellen Beispiele zur Veranschaulichung ihres Zwecks und ihrer Verwendung bereit. Dadurch erhalten Sie das Wissen, die horizontale Registerkarte effektiv in Ihren Programmieraufgaben einzusetzen. Fahren wir mit den Beispielen fort, um die Funktionsweise der Escape-Sequenz „\t“ in einem C++-Programm zu verstehen.
Beispiel 1:
Das folgende C++-Codebeispiel enthält ein einfaches Programm, das zum Drucken des Textes auf der Konsole verwendet wird. Sehen Sie sich den folgenden Code an und wir erklären ihn anschließend:
#include
Verwenden des Namensraums std ;
int hauptsächlich ( ) {
cout << „Dies ist eine erste Textzeile.“ << endl ;
cout << „Dies ist die zweite Textzeile. \T ' ;
cout << „Auf diese Zeile folgt ein \\ t Escape-Sequenz. ;
zurückkehren 0 ;
}
Hier ist ein Detail zu jedem Teil des Codes:
#include
Verwenden des Namensraums std; – Mit diesem Code können Sie die Namen verwenden, die in der Standardbibliothek enthalten sind, ohne ihnen „std::“ voranzustellen. Sie können beispielsweise „cout“ anstelle von „std::cout“ schreiben.
int main() { – Dies ist die Deklaration und der Einstiegspunkt der Hauptfunktion für jedes C++-Programm. Das „int“ vor „main“ zeigt normalerweise an, dass die Funktion einen ganzzahligen Wert zurückgibt.
cout << „Dies ist die erste Textzeile.“<
cout << „Dies ist die zweite Textzeile.\t“; – Hier gibt das Programm eine weitere Zeichenfolge aus: „Dies ist die zweite Textzeile.\t“. Beachten Sie das „\t“ am Ende. Beim Drucken in der Konsole wird direkt nach dem Text ein horizontaler Tabulatorbereich eingefügt.
cout << „Auf diese Zeile folgt eine \\t-Escape-Sequenz.“; – In dieser Zeile gibt das Programm „Auf diese Zeile folgt eine \t-Escape-Sequenz“ aus. Die Escape-Sequenz „\\t“ wird verwendet, um „\t“ buchstäblich in die Ausgabe einzuschließen, da der Backslash „\“ selbst durch einen anderen Backslash maskiert wird, sodass „\t“ selbst anstelle eines horizontalen Tabulators gedruckt wird.
0 zurückgeben; – Dies markiert das Ende der Hauptfunktion und gibt Null zurück, was die erfolgreiche Ausführung des Programms anzeigt. Wenn dieses Programm ausgeführt wird, sieht die Ausgabe folgendermaßen aus:
Beispiel 2:
Schauen wir uns nun ein weiteres Beispiel an und sehen wir uns die Magie des Escape-Zeichens „\t“ an. Das Beispiel ist ein einfaches C++-Programm, das eine Standard-Eingabe-Ausgabe-Stream-Bibliothek enthält und den Standard-Namespace verwendet. Das Programm ist so konzipiert, dass es eine formatierte Namenstabelle sowie die zugehörige Stadt und das zugehörige Land auf der Konsole ausgibt.
#includeVerwenden des Namensraums std ;
int hauptsächlich ( ) {
cout << 'Name \T | \T Stadt \T | \T Land' << endl ;
cout << „------------------------------------------“ << endl ;
cout << „Alice \T | \T Peking \T | \T China' << endl ;
cout << 'Bob \T | \T Austin \T | \T Amerika' << endl ;
cout << „Cathe \T | \T Paris \T | \T Frankreich' << endl ;
cout << 'David \T | \T Durban \T | \T Südafrika' << endl ;
cout << „------------------------------------------“ << endl ;
zurückkehren 0 ;
}
Hier ist eine Aufschlüsselung des Codes:
Wieder, #include
Verwenden des Namensraums std; – Es ermöglicht die Verwendung der Entitäten aus dem „std“-Namespace, ohne dass ihnen „std::“ vorangestellt werden muss.
Der int main() { ist der Einstiegspunkt jedes C++-Programms. Wenn Sie das Programm ausführen, beginnt die Ausführung hier.
Innerhalb der Hauptfunktion haben wir Folgendes:
cout << „Name\t|\tStadt\t|\tLand“<
cout << „——————————————-“<
Die nächsten vier Zeilen drucken jeweils eine Zeile der Tabelle. Diese Zeilen folgen dem gleichen Format wie Tabulatoren und sind Teil der Erstellung der Tabellenausgabe. Nach jeder Datenzeile wird „endl“ verwendet, um zur nächsten Zeile zu wechseln. Die letzte Zeile druckt erneut die Trennlinie, um das Ende der Tabellendaten anzuzeigen.
return 0;: – Diese Zeile zeigt die erfolgreiche Ausführung des Programms an. Ein Rückgabewert von 0 zeigt einen Erfolg an.
Wenn dieses Programm kompiliert und ausgeführt wird, erscheint die Ausgabe als Tabelle auf der Konsole mit den Namen, Städten und Ländern der Personen, die sauber in Spalten angeordnet sind, die durch vertikale Balken (|) und Tabulatoren getrennt sind. Siehe die folgende Ausgabe:
Notiz: Denken Sie daran, dass die tatsächliche Ausrichtung des Textes in der Konsole von der Breite der Tabulatoreinstellungen in Ihrer Konsole oder Ihrem Terminal abhängt, was zu unterschiedlichen Tabellendarstellungen auf verschiedenen Systemen führen kann.
Beispiel 3:
Dieses einfache, aber interessante C++-Programm verwendet die Tab-Escape-Sequenzen „\t“, um eine Rautenform auf dem Bildschirm zu drucken. Dieser Code skaliert die Rautengröße basierend auf der Variablen „Diamant“, die die Größe angibt und die Anzahl der Linien von der Mitte der Raute bis zu ihrer Ober- oder Unterseite darstellt. Überprüfen Sie den folgenden angegebenen Code:
#includeVerwenden des Namensraums std ;
int hauptsächlich ( ) {
int Diamant = 3 ;
für ( int ich = 1 ; ich <= Diamant ; ++ ich ) {
für ( int J = 0 ; J < Diamant - ich ; ++ J ) {
cout << ' \T ' ;
}
für ( int J = 0 ; J < 2 * ich - 1 ; ++ J ) {
cout << „* \T ' ; }
cout << endl ;
}
für ( int ich = Diamant - 1 ; ich >= 1 ; -- ich ) {
für ( int J = 0 ; J < Diamant - ich ; ++ J ) {
cout << ' \T ' ;
}
für ( int J = 0 ; J < 2 * ich - 1 ; ++ J ) {
cout << „* \T ' ; }
cout << endl ;
}
zurückkehren 0 ;
}
Wie Sie sehen, besteht dieses Programm aus zwei Teilen: Einer druckt die obere Hälfte der Raute und der andere druckt die untere Hälfte. Die obere Hälfte der Raute wird gedruckt, indem zunächst eine abnehmende Anzahl von Tabulatoren ausgegeben wird, um den Einzug zu erzeugen, gefolgt von einer zunehmenden Anzahl von Sternchen „*“, getrennt durch Tabulatoren. Dies wird in der ersten „for“-Schleife behandelt.
Die untere Hälfte wird auf ähnliche Weise gedruckt, wobei die Schleifen jedoch in umgekehrter Reihenfolge durchlaufen werden, um die Anzahl der Sternchen zu verringern und den Einzug wieder zu vergrößern, wodurch die untere Hälfte der Raute entsteht. Dies wird in der zweiten „for“-Schleife behandelt.
Wenn das Programm mit „Diamant=3“ ausgeführt wird, sieht die Ausgabe aufgrund der Tabulatorzeichen wie eine Raute aus, die zentriert auf dem Bildschirm angezeigt wird. Sehen Sie sich die Ausgabe dieses speziellen Programms an:
Bitte beachten Sie, dass das tatsächliche Erscheinungsbild je nach verwendeter Konsole oder Terminal unterschiedlich sein kann, da die Tab-Breiten variieren können.
Abschluss
Escape-Sequenzen in C++ sind ein leistungsstarkes Werkzeug zur Darstellung von Zeichen, die in einem Standardausgabefenster nicht ohne weiteres angezeigt werden können. Unter diesen Sequenzen ist der horizontale Tabulator, der mit „\t“ gekennzeichnet ist, besonders nützlich, um die kontrollierten horizontalen Leerzeichen im Text hinzuzufügen. Mit „\t“ können die Programmierer ihre Textausgabe ausrichten, die Lesbarkeit verbessern und die Daten systematisch strukturieren. Dieses Zeichen imitiert das Drücken der „Tab“-Taste auf einer Tastatur und bewegt den Cursor zur nächsten Tabulatorposition. In diesem Artikel haben wir die Funktionalität der „\t“-Escape-Sequenz in der C++-Sprache untersucht und ihre Anwendung anhand einfacher und praktischer Beispiele hervorgehoben, um ihr Verhalten zu veranschaulichen.