Verwalten der Konsole mit den iostream-Klassen in C++

Im Computerbereich ist die Konsole die Computertastatur und der Computermonitor. In der Vergangenheit wurde die Ausgabe direkt an den Monitorbildschirm gesendet und nicht an ein auf dem Monitor angezeigtes Fenster. Für den normalen Computerbenutzer verwenden Anwendungen heute den Monitor nicht explizit. Diese Anwendungen verwenden Fenster, die auf dem Monitor angezeigt werden. Der Computerprogrammierer muss jedoch weiterhin den Monitorbildschirm verwenden use. Obwohl der Programmierer immer noch den Monitorbildschirm verwenden muss, erlaubt ihm das Betriebssystem nicht, dies zu tun. Das Betriebssystem bietet ein Fenster, das den Monitorbildschirm simuliert. Im Windows-Betriebssystem wird dieses Fenster als Eingabeaufforderung bezeichnet. Im Linux-Betriebssystem und seinen Varianten wird dieses Fenster als Terminal bezeichnet.

Es wird erwartet, dass der Leser bereits weiß, wie man die Eingabeaufforderung oder das Terminal verwendet. In diesem Artikel wird erläutert, wie Sie Zeichen und Zeichenfolgen von der Tastatur lesen und Zeichen und Zeichenfolgen an das Terminal (oder die Eingabeaufforderung) senden. Jeder C++-Programmierer muss in diesem Artikel wissen.

Um Eingaben über die Tastatur und Ausgabe auf dem Terminal zu haben, muss das Programm beginnen mit:

#einschließen
Verwenden von Namespace-Std;

Artikelinhalt

Narrow Stream-Objekte des Standard iostream
Abrufen von Zeichen und Strings von der Tastatur
Anzeigen und Löschen von Zeichen vor dem Drücken der Eingabetaste
Senden von Zeichen und Strings an den Monitor
Argumente für ein C++-Programm
Fazit

Narrow Stream-Objekte des Standard iostream

Die Klasse iostream, die Standardobjekte cout, cin, cerr und clog sind instanziiert und bereits in der Standardbibliothek enthalten. Der Programmierer verwendet sie einfach, ohne sie erneut zu instanziieren.

cout

Die folgende Anweisung in der Funktion main() sendet den Text „Dies wird ausgegeben“.“ zum Terminal:

cout << "This is output.";

cout ist ein Ausgabe-IOstream-Objekt in der Standardbibliothek, bereits instanziiert. << is the insertion operator, which sent the bytes, “This is output.” to the output stream object, cout. When the statement is executed, the text appears on the screen.

Mit der obigen Anweisung erscheint die erneut angezeigte Eingabeaufforderung rechts neben der Ausgabephrase. Es geht nicht in die nächste Zeile. „endl“ am Ende der folgenden Anweisung zwingt alles, was vom Bildschirm gedruckt wird, in die nächste Zeile:

cout << "This is output." << endl;

„endl“ ist eine vordefinierte Variable. Bildschirminhalte können auch mit folgendem Befehl in die nächste Zeile gebracht werden:

cout << "This is output." << '\n';

Bei Verwendung von '\n' werden möglicherweise immer noch nicht alle Textzeilen auf dem Bildschirm angezeigt. „endl“ spült die komplette Textzeile auf den Bildschirm.

Hinweis: Eine an cout gesendete Zeichenfolge steht in doppelten Anführungszeichen, während ein gesendetes Zeichen in einfachen Anführungszeichen steht. In einer Anweisung kann eine Reihe von Strings und Zeichen gesendet werden, denen jeweils ein vorangestellt ist << . All that will appear in one line at the output if '\n' is not in the series.

cin

cin ist das standardmäßige iostream-Eingabeobjekt, bereits instanziiert und in der Standardbibliothek verfügbar. Betrachten Sie das folgende Codesegment in der Funktion main():

char-txt[50];
cout << "Enter a word and press Enter:" <> TXT;
cout << txt << endl;

Die erste Anweisung deklariert ein leeres Array mit 50 Zeichen. Die zweite Anweisung weist den Benutzer an, in der nächsten Bildschirmzeile ein Wort einzugeben und die Eingabetaste zu drücken. Beachten Sie die Verwendung von "endl", die den Benutzer dazu zwingt, Text in der nächsten Zeile des Bildschirms einzugeben. Während der Benutzer Text eingibt, wird der eingegebene Text auf dem Bildschirm wiedergegeben, während er in das cin-Objekt eingeht. Nach Drücken der Eingabetaste wird die dritte Anweisung im Codesegment ausgeführt. Diese dritte Anweisung sendet den eingegebenen Text an die Variable txt. Der eingegebene Text sollte in diesem Fall nicht länger als 50 Zeichen sein. Beachten Sie die Verwendung des Extraktionsoperators, >>. Die letzte Anweisung zeigt den eingegebenen Text auf dem Bildschirm an.

cin kann mehr als ein Wort von der Tastatur annehmen, getrennt durch Leerzeichen. Diese Wörter müssen in verschiedene Variablen extrahiert werden. Das folgende Codesegment veranschaulicht dies:

char-txt[20];
int es;
schweben ft;
cout << "Enter 3 values and press Enter:" <> txt >> es >> ft;
cout << txt << " << it << " << ft << endl;

Beachte die Aussage:

cin >> txt >> es >> ft;

Das erste Wort wird in txt extrahiert, das nächste und das letzte in ft. Wenn die Eingabe war,

ein 25 3.6

dann wäre die Ausgabe durch das Codesegment,

ein 25 3.6

cerr

Das folgende Programm hat einen Fehler:

#einschließen
Verwenden von Namespace-Std;
int main()

in myInt;
0 zurückgeben;

Die erste Anweisung in main() ist nicht korrekt. Wenn der Name der Datei mit dem Code „temp“ lautet.cc“ und die resultierende ausführbare Datei soll „temp“ heißen, dann sendet der folgende g++-Befehl die Compiler-Fehlermeldung an die Datei „error.TXT":

g++ -o temp temp.cc 2>Fehler.TXT

Wenn die Datei „Fehler.txt“ existiert nicht, es würde erstellt. Beachten Sie den Abschnitt „2>Fehler“.txt“ des g++-Befehls.

Der Bildschirm ist das Standardausgabeziel und auch das Standardfehlerziel. Wenn „2>Fehler.txt“ im g++-Befehl weggelassen wird, würde die Compiler-Fehlermeldung an das Standardfehlerziel gesendet, das immer noch der Bildschirm (Monitor) ist.

Das Stream-Objekt, das das Standardausgabeziel darstellt, ist cout. Das Stream-Objekt, das das Standardfehlerziel darstellt, ist cerr. Ein Laufzeitfehler des Programms kann wie folgt an den Bildschirm gesendet werden:

cerr << "The error message!" << '\n';

verstopfen

Eine Anwendung nimmt unterschiedliche Eingaben zu unterschiedlichen Zeiten entgegen. Alle Eingaben können auf dem Bildschirm wieder angezeigt werden. Alle Eingaben können in einer Datei gespeichert werden. Das ist Protokollierung. Das Standardprotokollierungsziel ist der Bildschirm. Das Standard-Logging-Stream-Objekt ist ein Clog. Der folgende Code zeigt den eingegebenen Text erneut auf dem Bildschirm an:

char-txt[50];
cout<<"Enter text and press Enter:"<>TXT;
verstopfen<Wenn der Eingabetext "input_text" ist, würde clog "input_text" erneut auf dem Bildschirm anzeigen.

In der Praxis wird die Protokollierung normalerweise in eine Datei umgeleitet. Das folgende Programm veranschaulicht dies:

#einschließen
Verwenden von Namespace-Std;
int main()

freopen( "log.txt", "w", Standardausgabe);
cout << "input_text" << endl;

Beachten Sie die Verwendung der Funktion freopen() und ihrer Argumente. Das erste Argument ist der Name der Protokolldatei. Wenn die Datei nicht existiert, wird sie erstellt. Das zweite Argument ist "w" für "write". Das dritte Argument ist stdout für Standardausgabe. Die zweite Anweisung in der main()-Funktion verwendet cout, um den Logging-Text an die Datei zu senden. Hinweis: Der eigentliche Eingabecode wurde in diesem Programm nicht angezeigt.

Abrufen von Zeichen und Strings von der Tastatur

Während der Benutzer Eingaben eingibt, werden die Zeichen an den Eingabedatenstrompuffer gesendet und auf dem Bildschirm angezeigt. Wenn der Benutzer die Eingabetaste drückt, befinden sich alle Zeichen im Puffer; außerdem springt der Cursor zum Anfang der nächsten Zeile darunter, auf dem Bildschirm. Das Programm fährt dann mit der nächsten Programmanweisung fort, nach der Eingabeleseanweisung.

Das cin-Objekt hat Methoden, mit denen sich dieser Abschnitt beschäftigt.

Das erste Zeichen lesen

get(char_type& c):
Das folgende Codesegment zeigt, wie das erste Zeichen aus dem Eingabedatenstrompuffer gelesen wird:

char-ch;
cout << "Input text:" << endl;
cin.erhalten(ch);
cout << ch << endl;

Die erste Anweisung deklariert ein Zeichen ohne Zuweisung. Die zweite Anweisung fordert den Benutzer auf, ein Zeichen einzugeben. Wenn der Benutzer Zeichen eingibt und die Eingabetaste drückt, kopiert die dritte Anweisung das Zeichen aus dem Eingabedatenstrompuffer in die Variable, ch.

Selbst wenn der Benutzer mehr als ein Zeichen eintippt, wird das erste Zeichen vom Codesegment übernommen.

erhalten():
get() ohne Argument, gibt den dezimalen ASCII-Code zurück. Betrachten Sie das folgende Codesegment:

cout << "Input text:" << endl;
cout << cin.get() << endl;

Wenn die Eingabe "asdfg" ist, wird 97 zurückgegeben, was der dezimale ASCII-Code für "a" ist.

**get(char_type* s, streamsize n)**

Nachdem der Benutzer eine Phrase eingegeben und die Eingabetaste gedrückt hat, kann eine Reihe von Zeichen, beginnend mit dem ersten, aus dem Cin-Stream-Puffer extrahiert werden. Der folgende Code kann verwendet werden:

char str[10];
cout << "Input text:" << endl;
cin.get(str, 10);
cout << str << endl;

Wenn die Eingabe "großartige Leute" ist, dann ist die Ausgabe "großartige Leute", mit 9 Zeichen und nicht 10. Der String NUL-Zeichen (\0) nimmt die zehnte Position im get-Argument ein. Um also 9 Zeichen in str zu haben, muss die Speichergröße mindestens 10 betragen und das Argument get() muss 11 sein. Wenn die gesamte Eingabezeile gewünscht wird, muss die Zeichenkettenspeichernummer mindestens der Anzahl der eingegebenen Zeichen plus 1 . entsprechen. Wenn also 12 Zeichen für die gesamte Zeile eingegeben werden, sollte die Zahl 13 für die Speichergröße der Zeichenfolge (str) und 13 für das Argument get() sein. Beachten Sie, dass ein Leerzeichen als ein Zeichen gezählt wird.

get(char_type* s, streamsize n, char_type delim)
Es ist möglich, eine rechts abgegrenzte Teilzeichenfolge durch das erste Vorkommen eines bestimmten Zeichens oder durch die Streamgröße der Teilzeichenfolge zu extrahieren, je nachdem, was zuerst eintritt. Wenn der Eingabetext für den folgenden Code „großartige Leute“ lautet, wird „großartig“ extrahiert:

char str[30];
cout << "Input text:" << endl;
cin.get(str, 6, 'o');
cout << str << endl;

Die sechste Position von Anfang an ist das Leerzeichen und begrenzt ausschließlich die extrahierte Teilzeichenfolge. Die sechste Position steht an erster Stelle vor dem einzigen Zeichen, 'o'. Beachten Sie, dass die Speichergröße für str so hoch wie möglich sein kann.

Wenn der Eingabetext für den folgenden Code „großartige Leute“ ist, wird „gr“ extrahiert:

char str[30];
cout << "Input text:" << endl;
cin.get(str, 10, 'e');
cout << str << endl;

Das erste Auftreten von 'e' kommt zuerst vor der zehnten Stelle.

Alle Zeichen einer Zeile erhalten

Nach dem Drücken der Eingabetaste können alle in die Zeile eingegebenen Zeichen wie im folgenden Code gezeigt abgerufen werden:

cout << "Input text:" << endl;
während (1)
char ch = (char)cin.erhalten();
cout << ch;
if (ch == '\n')
Unterbrechung;

Die Umwandlung mit (char) wandelt jede Dezimalzahl in das entsprechende ASCII-Zeichen um.

spähen()

Die Memberfunktionen get() lesen nicht nur das nächste Zeichen; sie entfernen es aus dem Stream-Puffer. Die Memberfunktion peek() liest jedoch einfach das nächste Zeichen (beginnend mit dem ersten), ohne es aus dem Puffer zu entfernen. Im folgenden Code wird jedes Zeichen zuerst mit der peek()-Funktion gelesen, bevor es von der get()-Funktion entfernt wird. Alles, was passiert, nachdem der Benutzer die Eingabetaste gedrückt hat:

cout << "Input text:" << endl;
während (1)
char ch = (char)cin.spähen();
cout << ch;
cin.erhalten();
if (ch == '\n')
Unterbrechung;

Wenn die nächsten Zeichen nicht durch get() entfernt würden, würde peek() nur das erste Zeichen lesen und die Schleife wird unbegrenzt durchlaufen.

Anzeigen und Löschen von Zeichen vor dem Drücken der Eingabetaste

Beachten Sie, dass beim cin-Objekt die Eingabetaste gedrückt werden muss, bevor eine Aktion ausgeführt wird. Nun, es ist möglich, dass Zeichen während der Eingabe angezeigt und gelöscht werden, bevor Sie die Eingabetaste drücken. Das bedeutet jedoch eine Schnittstelle zum Betriebssystem. Betriebssysteme unterscheiden sich. Das bedeutet also unterschiedliche Codierung für verschiedene Betriebssysteme. Dieses Thema verdient also ein ganz anderes Tutorial - siehe später.

Senden von Zeichen und Strings an den Monitor

Das cout-Objekt ist ein Ausgabestromobjekt, das bereits instanziiert und in der C++-Standardbibliothek vorhanden ist. cout ist das Hauptobjekt, das beim Senden von Zeichen und Strings an den Monitor verwendet wird. Dies geschieht mit dem Einfügeoperator, << . With the cin object, the text is obtained line-by-line. With the cout object, the text is added onto the same line until '\n' or endl is encountered.

Ausdrücke, die zu Skalaren führen, können Argumente für den Einfügeoperator sein. Der Operator wandelt den Skalar in Text um und platziert den Text im cout-Objektstrom. Wenn Text an das cout-Objekt gesendet wird, erscheint dieser normalerweise auf dem Bildschirm (Monitor). Gelegentlich kann es jedoch nicht sofort erscheinen. Um Text auf dem Bildschirm zu erzwingen, fügen Sie den Sonderwert „endl“ direkt nach dem Einfügen des Textes ein. Dadurch wird der Text auf dem Bildschirm angezeigt und ein Zeilenumbruch wird hinzugefügt. Hinweis: '\n' fügt einfach einen Zeilenumbruch hinzu, fügt jedoch keinen Text auf dem Bildschirm ein.

Das folgende Programm zeigt, wie die Werte von int, float und normaler Text auf den Bildschirm gedruckt werden:

#einschließen
Verwenden von Namespace-Std;
int main()

int it = 5;
Schwimmer ft = 63.5;
cout << "The " << it << " items cost $" << ft << " US." << endl;
0 zurückgeben;

Die Ausgabe ist:

Die 5 Artikel kosten $63.5 US.

Das folgende Programm zeigt, wie der String eines aus einer Klasse instanziierten Objekts ausgegeben wird:

#einschließen
Verwenden von Namespace-Std;
strukt St
char str[11] = "einige Wörter";
obj;
int main()

cout << obj.str << '\n';
0 zurückgeben;

Die Ausgabe ist "einige Wörter".

Argumente für ein C++-Programm

Die Programmausführung beginnt mit der main()-Funktion. Die Funktion main() hat eigentlich zwei optionale Parameter. Die Syntax der Funktion main() mit den optionalen Parametern lautet:

int main (int argc, char *argv[argc])

0 zurückgeben;

Angenommen, der Name der ausführbaren C++-Datei ist „temp“. Angenommen, die vom Benutzer eingegebenen Argumente, die das Programm von seiner Umgebung (Betriebssystem) benötigt, sind,

Artikel 3 Buchstift "Großes Haus"

Hier gibt es 5 Argumente: „Artikel“, „3“, „Buch“, „Stift“ und „Großes Haus“

Jeder ist Text. Ein nummeriertes Argument für ein Programm ist Text. Mit anderen Worten, jedes Argument ist ein String. „großes Haus“ steht in Anführungszeichen, weil es eine Phrase ist. Der Terminalbefehl zum Ausführen dieses Programms wäre:

./temp article 3 Buchstift "großes Haus"

Angenommen, die Datei temp befindet sich im Home-Verzeichnis. Beachten Sie, dass die Argumente durch Leerzeichen und nicht durch Kommas getrennt werden.

In der Syntax der Funktion main() ist argc die Anzahl der Argumente für das Programm plus 1. In diesem Fall gibt es 5 Argumente für das Programm. Argc ist also 6. In der Syntax ist argv[argc] ein Array von Zeigern auf Strings. Der erste Wert für dieses Array bei argv[0] wird vom Compiler gegeben. Es ist ein Zeiger auf den Namen der Programmdatei. Die restlichen Werte sind Zeiger auf die Programmargumente in der eingegebenen Reihenfolge des Benutzers. Die Größe dieses Arrays ist argc. In diesem Fall ist die Größe 1 + 5 = 6.

Angenommen, bei der Kompilierung heißt das folgende Programm temp:

#einschließen
Verwenden von Namespace-Std;
int main(int argc, char** argv)

cout << argv[0] << ", " << argv[1] << ", " << argv[2] << ", " << argv[3] << ", " << argv[4] << ", " << argv[5] << endl;
0 zurückgeben;

Beachten Sie hier, dass das Array "char *argv[argc]" als "char** argv" deklariert wurde.

Wenn dieses Programm mit dem Terminalbefehl ausgeführt wird,

./temp article 3 Buchstift "großes Haus"

dann wäre die Ausgabe:

./temp, artikel, 3, buch, stift, großes haus

Beachten Sie, dass der Verzeichnispfad mit dem Namen der ausführbaren Datei enthalten ist.

Beachten Sie auch, dass beim Ausführen des Programms (Aufruf des Programms) der Wert für argc nicht gesendet wurde.

Fazit

Die Klasse iostream hat vier wichtige Objekte: cout, cin, cerr und clog. cin ist ein Eingabeobjekt, der Rest sind Ausgabeobjekte. Während ein Programm läuft, unterscheidet sich die Eingabe in das Programm von dem Zeitpunkt, an dem das Programm gestartet werden soll. Wenn ein Programm gestartet wird, wird die Eingabe in das Programm mit dem Befehl zum Ausführen des Programms verbunden, getrennt durch Leerzeichen.