De console beheren met de iostream-klassen in C++

Bij informatica is de console het computertoetsenbord en de computermonitor. In het verleden werd de uitvoer rechtstreeks naar het beeldscherm gestuurd en niet naar een venster dat op de monitor werd weergegeven. Voor de gewone computergebruiker gebruiken applicaties tegenwoordig de monitor niet expliciet. Deze toepassingen gebruiken vensters die op de monitor worden weergegeven. De computerprogrammeur moet echter nog steeds het beeldscherm gebruiken. Hoewel de programmeur nog steeds het beeldscherm moet gebruiken, staat het besturingssysteem hem dat niet toe. Het besturingssysteem biedt een venster dat het beeldscherm simuleert. In het Windows-besturingssysteem wordt dit venster de opdrachtprompt genoemd. In het Linux-besturingssysteem en zijn varianten wordt dit venster de terminal genoemd.

Er wordt verwacht dat de lezer al weet hoe hij de opdrachtprompt of de terminal moet gebruiken. In dit artikel wordt uitgelegd hoe u tekens en tekenreeksen van het toetsenbord kunt lezen en tekens en tekenreeksen naar de terminal (of opdrachtprompt) kunt sturen. Elke C++-programmeur moet dit weten in dit artikel.

Om invoer van het toetsenbord en uitvoer naar de terminal te hebben, moet het programma beginnen met:

#include
namespace std; gebruiken;

Artikel Inhoud

Smalle stroomobjecten van de standaard iostream
Tekens en tekenreeksen verkrijgen van het toetsenbord
Tekens weergeven en verwijderen voordat u op Enter drukt
Tekens en tekenreeksen naar de monitor verzenden
Argumenten voor een C++-programma
Conclusie

Smalle stroomobjecten van de standaard iostream

De iostream-klasse, de standaardobjecten, cout, cin, cerr en clog, zijn geïnstantieerd en staan al in de standaardbibliotheek. De programmeur gebruikt ze gewoon zonder ze opnieuw te instantiëren.

cout

Het volgende statement in de main() functie stuurt de tekst, “This is output.” naar de terminal:

cout << "This is output.";

cout is een output iostream-object in de standaardbibliotheek, al geïnstantieerd. << 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.

Met de bovenstaande verklaring verschijnt de opnieuw weergegeven opdrachtprompt rechts van de uitvoerzin. Het gaat niet naar de volgende regel. "endl" aan het einde van de volgende instructie dwingt alles wat door het scherm wordt afgedrukt naar de volgende regel:

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

"endl" is een vooraf gedefinieerde variabele. Scherminhoud kan ook naar de volgende regel worden geforceerd met:

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

Met het gebruik van '\n' kunnen nog steeds niet alle regels tekst direct op het scherm verschijnen. "endl" spoelt de volledige tekstregel naar het scherm.

Opmerking: een tekenreeks die naar cout wordt verzonden, staat tussen dubbele aanhalingstekens, terwijl een verzonden teken tussen enkele aanhalingstekens staat. Een reeks tekenreeksen en tekens kan in één instructie worden verzonden, elk voorafgegaan door << . All that will appear in one line at the output if '\n' is not in the series.

cin

cin is het standaard iostream-invoerobject, al geïnstantieerd en beschikbaar in de standaardbibliotheek. Overweeg het volgende codesegment in de functie main():

teken txt[50];
cout << "Enter a word and press Enter:" <> tekst;
cout << txt << endl;

De eerste instructie declareert een lege array van 50 tekens. De tweede instructie geeft de gebruiker de opdracht om een woord in te typen op de volgende schermregel en op de Enter-toets te drukken. Let op het gebruik van "endl" dat de gebruiker dwingt om tekst in te voeren op de volgende regel van het scherm. Terwijl de gebruiker tekst typt, wordt de ingevoerde tekst naar het scherm herhaald terwijl deze in het cin-object gaat. Nadat u op Enter heeft gedrukt, wordt de derde instructie in het codesegment uitgevoerd. Dit derde statement stuurt de ingevoerde tekst naar de variabele, txt. De ingevoerde tekst mag in dit geval niet langer zijn dan 50 tekens. Let op het gebruik van de extractie-operator, >>. De laatste verklaring toont de ingevoerde tekst op het scherm.

cin kan meer dan één woord van het toetsenbord halen, gescheiden door spaties. Deze woorden moeten worden geëxtraheerd in verschillende variabelen variable. Het volgende codesegment illustreert dit:

teken txt[20];
int het;
drijven voet;
cout << "Enter 3 values and press Enter:" <> txt >> het >> ft;
cout << txt << " << it << " << ft << endl;

Let op de verklaring:

cin >> txt >> het >> ft;

Het eerste woord wordt geëxtraheerd naar txt, het volgende en het laatste naar ft. Als de invoer was,

een 25 3.6

dan zou de uitvoer van het codesegment zijn:,

een 25 3.6

zeker

Het volgende programma heeft een fout:

#include
namespace std; gebruiken;
int hoofd()

in mijnInt;
retourneer 0;

Het eerste statement in main() is niet correct. Als de naam van het bestand met de code "temp" is.cc" en het resulterende uitvoerbare bestand moet "temp" heten, dan zal de volgende g++-opdracht de compilerfoutmelding naar het bestand "error.tekst":

g++ -o temp temp.cc 2>fout.tekst

Als het bestand “error.txt" niet bestaat, zou het worden gemaakt. Let op het gedeelte "2>fout".txt" van het g++-commando.

Het scherm is de standaarduitvoerbestemming en het is ook de standaardfoutbestemming. Als “2>fout.txt" wordt weggelaten uit de g++-opdracht, dan wordt de compilerfoutmelding naar de standaardfoutbestemming gestuurd, wat nog steeds het scherm (monitor) is.

Het stream-object dat de standaarduitvoerbestemming vertegenwoordigt, is cout. Het stream-object dat de standaardfoutbestemming vertegenwoordigt, is cerr. Een runtime-fout van het programma kan als volgt naar het scherm worden verzonden:

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

verstoppen

Een toepassing heeft verschillende invoer nodig op verschillende tijdstippen. Alle ingangen kunnen opnieuw op het scherm worden weergegeven. Alle invoer kan worden opgeslagen in een bestand. Dit is loggen. De standaard logboekbestemming is het scherm. Het standaard logstroomobject is een klomp. Met de volgende code wordt de invoertekst opnieuw op het scherm weergegeven:

teken txt[50];
cout<<"Enter text and press Enter:"<>tekst;
verstoppen<Als de invoertekst "input_text" is, zou klomp "input_text" opnieuw op het scherm weergeven.

In de praktijk wordt loggen meestal omgeleid naar een bestand. Het volgende programma illustreert dit:

#include
namespace std; gebruiken;
int hoofd()

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

Let op het gebruik van de functie, freopen(), en zijn argumenten. Het eerste argument is de naam van het logbestand. Als het bestand niet bestaat, wordt het aangemaakt. Het tweede argument is "w" voor "schrijven". Het derde argument is stdout voor standaarduitvoer. Het tweede statement in de main() functie gebruikt cout om de logtekst naar het bestand te sturen. Opmerking: de daadwerkelijke invoercode is niet weergegeven in dit programma.

Tekens en tekenreeksen verkrijgen van het toetsenbord

Terwijl de gebruiker invoer typt, worden de tekens naar de invoerstroombuffer gestuurd en op het scherm weergegeven. Wanneer de gebruiker op de Enter-toets drukt, bevinden alle tekens zich in de buffer; ook gaat de cursor naar het begin van de volgende regel hieronder, op het scherm. Het programma gaat dan verder naar de volgende programma-instructie, na de invoer leesinstructie.

Het cin-object heeft methoden waar deze sectie over gaat:.

Het eerste karakter lezen

get(char_type& c):
Het volgende codesegment laat zien hoe u het eerste teken uit de invoerstroombuffer kunt lezen:

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

De eerste verklaring verklaart een teken zonder toewijzing. De tweede instructie vertelt de gebruiker om een teken in te voeren. Wanneer de gebruiker een teken typt en op de Enter-toets drukt, kopieert de derde instructie het teken uit de invoerstroombuffer naar de variabele, ch.

Zelfs als de gebruiker meer dan één teken typt, wordt het eerste teken ingenomen door het codesegment.

krijgen():
get() zonder argument, retourneert de decimale ASCII-code. Overweeg het volgende codesegment:

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

Als de invoer "asdfg" is, wordt 97 geretourneerd, wat de decimale ASCII-code voor 'a' is.

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

Nadat de gebruiker een zin heeft ingevoerd en op de Enter-toets heeft gedrukt, kan een aantal tekens vanaf de eerste worden geëxtraheerd uit de cin-streambuffer. De volgende code kan worden gebruikt:

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

Als de invoer "geweldige mensen" is, is de uitvoer "geweldige mensen", van 9 tekens en niet 10. Het NUL-tekenreeks (\0) neemt de tiende positie in het get-argument in. Dus om 9 tekens in str te hebben, moet de opslaggrootte minimaal 10 zijn en moet het argument get() 11 zijn. Als de hele invoerregel gewenst is, moet het stringopslagnummer minimaal het aantal getypte tekens zijn, plus 1. Dus als 12 tekens worden getypt voor de hele regel, dan moet het nummer 13 zijn voor de string (str) opslaggrootte en 13 voor het argument get(). Merk op dat één spatie wordt geteld als één teken.

get(char_type* s, streamsize n, char_type delim)
Het is mogelijk om een substring te extraheren, aan de rechterkant begrensd door het eerste voorkomen van een bepaald teken, of door de stroomgrootte van de substring, wat het eerst komt. Als de invoertekst voor de volgende code "geweldige mensen" is, wordt "geweldig" geëxtraheerd:

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

De zesde positie vanaf het begin is het spatieteken en het begrenst uitsluitend de geëxtraheerde subtekenreeks. De zesde positie komt eerst voor het enige teken, 'o'. Merk op dat de opslaggrootte voor str zo hoog mogelijk kan zijn.

Als de invoertekst voor de volgende code "geweldige mensen" is, wordt "gr" geëxtraheerd:

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

De eerste keer dat 'e' voorkomt, komt eerst voor de tiende positie.

Alle karakters van een regel krijgen

Nadat u op de Enter-toets hebt gedrukt, kunnen alle tekens die in de regel zijn getypt, worden opgehaald zoals weergegeven in de volgende code:

cout << "Input text:" << endl;
terwijl (1)
char ch = (char)cin.krijgen();
cout << ch;
if (ch == '\n')
breken;

De casting met (char), converteert elk decimaal getal naar het overeenkomstige ASCII-teken.

kijkje()

De get() lidfuncties lezen niet alleen het volgende teken; ze verwijderen het uit de streambuffer. De functie peek() lid leest echter eenvoudig het volgende teken (beginnend bij het eerste) zonder het uit de buffer te verwijderen. In de volgende code wordt elk teken eerst gelezen met de functie peek() voordat het wordt verwijderd door de functie get(). Dat gebeurt allemaal nadat de gebruiker op de Enter-toets heeft gedrukt:

cout << "Input text:" << endl;
terwijl (1)
char ch = (char)cin.kijkje();
cout << ch;
cin.krijgen();
if (ch == '\n')
breken;

Als de volgende tekens niet werden verwijderd door get(), zou peek() alleen het eerste teken lezen, en de lus zal voor onbepaalde tijd worden herhaald.

Tekens weergeven en verwijderen voordat u op Enter drukt

Merk op dat met het cin-object de Enter-toets moet worden ingedrukt voordat er actie wordt ondernomen. Welnu, het is mogelijk dat tekens worden weergegeven terwijl ze worden getypt en gewist voordat op de Enter-toets wordt gedrukt. Dat betekent echter een interface met het besturingssysteem. Besturingssystemen verschillen. Dit betekent dus verschillende codering voor verschillende besturingssystemen. Dit onderwerp verdient dus een heel andere tutorial - zie later.

Tekens en tekenreeksen naar de monitor verzenden

Het cout-object is een outputstream-object, dat al is geïnstantieerd en aanwezig is in de standaardbibliotheek van C++. cout is het hoofdobject dat wordt gebruikt bij het verzenden van tekens en tekenreeksen naar de monitor. Dit wordt gedaan met de invoegoperator, << . 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.

Expressies die resulteren in scalaire waarden kunnen argumenten zijn voor de invoegoperator. De operator zet de scalaire waarde om in tekst en plaatst de tekst in de cout-objectstroom. Wanneer tekst naar het cout-object wordt verzonden, verschijnt deze normaal gesproken op het scherm (monitor). Soms verschijnt het echter niet onmiddellijk. Om tekst op het scherm te forceren, voegt u de speciale waarde "endl" in, net na het invoegen van de tekst. Hierdoor wordt de tekst naar het scherm gespoeld en wordt er een nieuwe regel toegevoegd. Opmerking: '\n' voegt gewoon een nieuwe regel toe, maar spoelt de tekst niet door op het scherm.

Het volgende programma laat zien hoe u de waarden van int, float en gewone tekst op het scherm kunt afdrukken:

#include
namespace std; gebruiken;
int hoofd()

int het = 5;
vlotter ft = 63.5;
cout << "The " << it << " items cost $" << ft << " US." << endl;
retourneer 0;

De uitvoer is:

De 5 items kosten $63.5 US.

Het volgende programma laat zien hoe de string van een object dat is geïnstantieerd vanuit een klasse wordt afgedrukt:

#include
namespace std; gebruiken;
structuur St
char str[11] = "sommige woorden";
obj;
int hoofd()

cout << obj.str << '\n';
retourneer 0;

De output is "sommige woorden".

Argumenten voor een C++-programma

De uitvoering van het programma begint vanaf de functie main(). De functie main() heeft eigenlijk twee optionele parameters. De syntaxis van de functie main() met de optionele parameters is:

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

retourneer 0;

Neem aan dat de naam van het uitvoerbare C++-bestand "temp" is. Neem aan dat de argumenten die het programma nodig heeft van zijn omgeving (besturingssysteem), getypt door de gebruiker, is,

artikelen 3 boekenpen "groot huis"

Er zijn hier 5 argumenten: "artikelen", "3", "boek", "pen" en "groot huis"

Elk is tekst. Een genummerd argument voor een programma is tekst. Met andere woorden, elk argument is een string. "groot huis" staat tussen aanhalingstekens omdat het een zin is. De terminalopdracht om dit programma uit te voeren zou zijn:

./temp artikelen 3 boekenpen "groot huis"

Ervan uitgaande dat het bestand temp in de home directory staat. Merk op dat spaties en geen komma's de argumenten scheiden.

Nu, in de syntaxis van de functie main() is argc het aantal argumenten voor het programma, plus 1. In dit geval zijn er 5 argumenten voor het programma. Dus argc is 6. In de syntaxis is argv[argc] een array van verwijzingen naar strings. De eerste waarde voor deze array op argv[0] wordt gegeven door de compiler. Het is een verwijzing naar de naam van het programmabestand. De rest van de waarden zijn verwijzingen naar de programmaargumenten in de door de gebruiker ingetypte volgorde. De grootte van deze array is argc. In dit geval is de maat 1 + 5 = 6.

Neem aan dat bij compilatie het volgende programma temp heet:

#include
namespace std; gebruiken;
int main(int argc, char** argv)

cout << argv[0] << ", " << argv[1] << ", " << argv[2] << ", " << argv[3] << ", " << argv[4] << ", " << argv[5] << endl;
retourneer 0;

Merk hier op dat de array "char *argv[argc]", gedeclareerd is als "char** argv".

Als dit programma wordt uitgevoerd met het terminalcommando,

./temp artikelen 3 boekenpen "groot huis"

dan zou de output zijn:

./temp, artikelen, 3, boek, pen, groot huis

Merk op dat het mappad is opgenomen in de naam van het uitvoerbare bestand.

Merk ook op dat tijdens het uitvoeren van het programma (aanroepen van het programma), de waarde voor argc niet is verzonden.

Conclusie

De klasse iostream heeft vier belangrijke objecten: cout, cin, cerr en clog. cin is een invoerobject, terwijl de rest uitvoerobjecten zijn. Terwijl een programma loopt, is de invoer van het programma anders dan wanneer het programma moet starten. Wanneer een programma begint te lopen, wordt de invoer voor het programma samengevoegd met de opdracht om het programma uit te voeren, gescheiden door spaties.