Gestire la console con le classi iostream in C ++

Nel calcolo, la console è la tastiera del computer e il monitor del computer. In passato, l'uscita è stata inviata direttamente alla schermata del monitor e non su una finestra visualizzata sul monitor. Per l'utente del computer ordinario, le applicazioni oggi non utilizzano esplicitamente il monitor. Queste applicazioni utilizzano Windows visualizzate sul monitor. Tuttavia, il programmatore di computer deve ancora utilizzare lo schermo del monitor. Sebbene il programmatore debba ancora utilizzare la schermata del monitor, il sistema operativo non gli consente di farlo. Il sistema operativo fornisce una finestra che simula lo schermo del monitor. Nel sistema operativo Windows, questa finestra è chiamata prompt dei comandi. Nel sistema operativo Linux e nelle sue varianti, questa finestra è chiamata terminale.

Si prevede che il lettore sappia già come utilizzare il prompt dei comandi o il terminale. Questo articolo spiega come leggere caratteri e stringhe dalla tastiera e inviare caratteri e stringhe al terminale (o prompt dei comandi). Ogni programmatore C ++ deve sapere in questo articolo.

Per avere input dalla tastiera e output al terminale, il programma deve iniziare:

#includere
Utilizzo dello spazio dei nomi std;

Contenuto dell'articolo

• Oggetti stretti del flusso dello standard iostream
• Ottenere caratteri e stringhe dalla tastiera
• Visualizzazione ed eliminazione dei caratteri prima di premere Invio
• Invio di caratteri e stringhe al monitor
• Argomenti per un programma C ++
• Conclusione

Oggetti stretti del flusso dello standard iostream

La classe iostream, gli oggetti standard, COUT, CIN, CERR e CLOG, sono stati istanziati e già nella libreria standard. Il programmatore li usa solo senza istanziarli di nuovo.

cout

La seguente istruzione nella funzione principale () invia il testo: “Questo è l'output."Al terminale:

cout << "This is output.";

Cout è un oggetto iostream di output nella libreria standard, già istanziata. << 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.

Con l'istruzione sopra, il prompt dei comandi ri-sfaldato appare a destra della frase di output. Non va alla riga successiva. "Endl" alla fine della seguente dichiarazione forzerà tutto ciò che viene stampato dallo schermo alla riga successiva:

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

"Endl" è una variabile predefinita. Il contenuto dello schermo può anche essere costretto alla riga successiva con:

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

Con l'uso di '\ n', tutte le righe di testo potrebbero non apparire immediatamente sullo schermo. "Endl" scarica la linea completa di testo sullo schermo.

Nota: una stringa inviata a cout è in doppie citazioni, mentre un personaggio inviato è in singole citazioni. Una serie di stringhe e carattere può essere inviata in una dichiarazione, ciascuna preceduta da << . All that will appear in one line at the output if '\n' is not in the series.

Cin

CIN è l'oggetto di input iostream standard, già istanziato e disponibile nella libreria standard. Considera il seguente segmento di codice nella funzione principale ():

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

La prima affermazione dichiara un array vuoto di 50 caratteri. La seconda istruzione indica all'utente di digitare una parola nella riga della schermata successiva e premere il tasto Invio. Nota l'uso di "endl" che costringe l'utente a inserire il testo nella riga successiva dello schermo. Poiché il testo dell'utente tipi, il testo immesso viene echeggiato sullo schermo mentre va nell'oggetto CIN. Dopo aver premuto Invio, viene eseguita la terza istruzione nel segmento del codice. Questa terza istruzione invia il testo immesso alla variabile, txt. Il testo inserito non dovrebbe essere più lungo di 50 caratteri in questo caso. Nota l'uso dell'operatore di estrazione, >>. L'ultima istruzione visualizza il testo immesso sullo schermo.

CIN può prendere più di una parola dalla tastiera, separata da spazi. Queste parole dovranno essere estratte in diverse variabili. Il seguente segmento di codice illustra questo:

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

Nota la dichiarazione:

CIN >> txt >> it >> ft;

La prima parola viene estratta su txt, il prossimo e l'ultimo a ft. Se l'input era,

uno 25 3.6

quindi l'output per il segmento del codice sarebbe,

uno 25 3.6

Cerr

Il seguente programma ha un errore:

#includere
Utilizzo dello spazio dei nomi std;
int main ()

in myint;
restituzione 0;

La prima affermazione in main () non è corretta. Se il nome del file con il codice è "temp.CC "e il file eseguibile risultante deve essere chiamato" temp ", quindi il seguente comando G ++ invierà il messaggio di errore del compilatore al file," Errore.TXT":

G ++ -O Tempt Temp.CC 2> Errore.TXT

Se il file "Errore.txt ”non esiste, verrebbe creato. Nota la porzione “2> Errore.txt "del comando G ++.

Lo schermo è la destinazione di uscita standard ed è anche la destinazione di errore standard. Se "2> Errore.txt ”viene omesso dal comando G ++, quindi il messaggio di errore del compilatore verrebbe inviato alla destinazione di errore standard, che è ancora lo schermo (monitor).

L'oggetto flusso che rappresenta la destinazione di output standard è cout. L'oggetto flusso che rappresenta la destinazione di errore standard è CERR. Un errore di runtime del programma può essere inviato allo schermo come segue:

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

Clog

Un'applicazione richiede input diversi in momenti diversi. Tutti gli ingressi possono essere ri-esplicati sullo schermo. Tutti gli input possono essere salvati in un file. Questa è la registrazione. La destinazione di registrazione standard è lo schermo. L'oggetto di flusso di registrazione standard è un intasamento. Il seguente codice sfalderà nuovamente il testo di input sullo schermo:

char txt [50];
cout<<"Enter text and press Enter:"txt;
Clog<

Se il testo di input è "input_text", allora il clog si sfalderà "input_text" sullo schermo.

In pratica, la registrazione viene generalmente reindirizzata a un file. Il seguente programma illustra questo:

#includere
Utilizzo dello spazio dei nomi std;
int main ()

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

Nota l'uso della funzione, freopen () e i suoi argomenti. Il suo primo argomento è il nome del file di registro. Se il file non esiste, verrebbe creato. Il suo secondo argomento è "W" per "Scrivi". Il suo terzo argomento è stdout per standard-output. La seconda istruzione nella funzione principale () utilizza Cout per inviare il testo di registrazione al file. Nota: il codice di input effettivo non è stato mostrato in questo programma.

Ottenere caratteri e stringhe dalla tastiera

Mentre l'utente sta digitando input, i caratteri vengono inviati al buffer del flusso di input e visualizzati sullo schermo. Quando l'utente preme il tasto Invio, tutti i caratteri sono nel buffer; Inoltre, il cursore va all'inizio della riga successiva in basso, sullo schermo. Il programma continua quindi all'istruzione del programma successivo, dopo l'istruzione di lettura input.

L'oggetto CIN ha metodi, di cui questa sezione riguarda.

Leggere il primo personaggio

get (char_type & c):
Il seguente segmento di codice mostra come leggere il primo carattere, dal buffer del flusso di input:

Char Ch;
cout << "Input text:" << endl;
Cin.ottenere (ch);
cout << ch << endl;

La prima affermazione dichiara un personaggio senza incarico. La seconda istruzione dice all'utente di inserire un carattere. Quando l'utente tipi in carattere e preme il tasto Invio, la terza istruzione copia il carattere dal buffer di flusso di input nella variabile, CH.

Anche se l'utente digitato in più di un carattere, il primo carattere verrebbe assunto dal segmento del codice.

Ottenere():
get () senza argomento, restituisce il codice ASCII decimale. Considera il seguente segmento di codice:

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

Se l'input è "asdfg", verrà restituito 97, che è il codice ASCII decimale per 'A'.

get (char_type* s, flusso n)

Dopo che l'utente inserisce una frase e preme il tasto ENTER, un numero di caratteri a partire dal primo, possono essere estratti dal buffer CIN Stream. È possibile utilizzare il seguente codice:

Char Str [10];
cout << "Input text:" << endl;
Cin.get (str, 10);
cout << str << endl;

Se l'input è "persone fantastiche", allora l'output sarà "grande peo", di 9 caratteri e non 10. Il carattere di stringa nul (\ 0) prende la decima posizione nell'argomento. Quindi, per avere 9 caratteri in STR, la sua dimensione di archiviazione deve essere almeno 10 e l'argomento get () deve essere 11. Se si desidera l'intera riga di input, il numero di archiviazione stringa deve essere almeno il numero di caratteri digitati, più 1. Quindi, se vengono digitati 12 caratteri per l'intera riga, il numero dovrebbe essere 13 per la dimensione di archiviazione della stringa (STR) e 13 per l'argomento get (). Si noti che uno spazio viene conteggiato come un personaggio.

get (char_type* s, streamsize n, char_type delim)
È possibile estrarre una sotto-corda, delimitata a destra, con la prima occorrenza di un personaggio particolare, o dal flusso della sotto-corda, che mai viene prima. Se il testo di input per il seguente codice è "persone fantastiche", allora "grande" verrebbe estratto:

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

La sesta posizione dall'inizio è il carattere spaziale e delimita la sottostrimento estratto esclusivamente. La sesta posizione arriva prima prima dell'unico personaggio, 'O'. Si noti che la dimensione di archiviazione per STR può essere il più elevata possibile.

Se il testo di input al seguente codice è "persone fantastiche", allora "GR" verrebbe estratto:

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

La prima occorrenza di "E", arriva prima della decima posizione.

Ottenere tutti i personaggi di una linea

Dopo aver premuto il tasto ENTER, tutti i caratteri digitati nella riga, possono essere ottenuti come mostrato nel seguente codice:

cout << "Input text:" << endl;
while (1)
char ch = (char) cin.Ottenere();
cout << ch;
if (ch == '\ n')
rottura;

Il casting con (char), converte ogni numero decimale nel carattere ASCII corrispondente.

sbirciare()

Le funzioni del membro get () non solo leggono il personaggio successivo; Lo rimuovono dal buffer di flusso. Tuttavia, la funzione membro Peek () Simple legge il carattere successivo (a partire dal primo) senza rimuoverlo dal buffer. Nel seguente codice, ogni carattere viene letto per la prima volta con la funzione Peek () prima di essere rimosso, dalla funzione get (). Tutto ciò che accade dopo che l'utente ha premuto il tasto Invio:

cout << "Input text:" << endl;
while (1)
char ch = (char) cin.sbirciare();
cout << ch;
Cin.Ottenere();
if (ch == '\ n')
rottura;

Se i personaggi successivi non fossero rimossi da Get (), Peek () avrebbe letto solo il primo personaggio e il ciclo iterirà indefinitamente.

Visualizzazione ed eliminazione dei caratteri prima di premere Invio

Si noti che con l'oggetto CIN, il tasto Invio deve essere premuto prima che ci sarà azione. Bene, è possibile che i caratteri vengano visualizzati durante la digitazione e la cancellazione prima di premere il tasto ENTER. Tuttavia, ciò significa interfacciarsi con il sistema operativo. I sistemi operativi differiscono. Quindi questo significa codifica diversa per diversi sistemi operativi. Quindi questo argomento merita un tutorial completamente diverso - vedi più tardi.

Invio di caratteri e stringhe al monitor

L'oggetto Cout è un oggetto di flusso di output, già istanziato e presente nella libreria standard C ++. Cout è l'oggetto principale utilizzato nell'invio di caratteri e stringhe al monitor. Questo viene fatto con l'operatore di inserimento, << . 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.

Le espressioni che si traducono in scalari possono essere argomenti per l'operatore di inserzione. L'operatore converte lo scalare in testo e posiziona il testo nel flusso di oggetti Cout. Quando il testo viene inviato all'oggetto Cout, normalmente appare sullo schermo (monitoraggio). Tuttavia, occasionalmente, potrebbe non apparire immediatamente. Per un testo forzato sullo schermo, inserire il valore speciale, "endl", subito dopo aver inserito il testo. Ciò causerà il lavaggio del testo sullo schermo e verrà aggiunta una nuova linea. Nota: '\ n' aggiunge semplicemente una nuova linea ma non scarica il testo allo schermo.

Il seguente programma mostra come stampare i valori di int, galleggianti e testo ordinario, sullo schermo:

#includere
Utilizzo dello spazio dei nomi std;
int main ()

int it = 5;
float ft = 63.5;
cout << "The " << it << " items cost $" << ft << " US." << endl;
restituzione 0;

L'output è:

I 5 articoli costano $ 63.5 US.

Il seguente programma mostra come viene stampata la stringa di un oggetto istanziato da una classe:

#includere
Utilizzo dello spazio dei nomi std;
struct st
char str [11] = "alcune parole";
obj;
int main ()

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

L'output è "alcune parole".

Argomenti per un programma C ++

L'esecuzione del programma inizia dalla funzione principale (). La funzione principale () ha in realtà due parametri opzionali. La sintassi della funzione principale () con i parametri opzionali, è:

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

restituzione 0;

Supponiamo che il nome del file C ++ eseguibile sia "temp". Supponiamo che gli argomenti di cui il programma ha bisogno dal suo ambiente (sistema operativo), digitato dall'utente,,

Articoli 3 Book Pen "Big House"

Ci sono 5 argomenti qui: "articoli", "3", "libro", "penna" e "grande casa"

Ognuno è testo. Un argomento numerato per un programma è il testo. In altre parole, ogni argomento è una stringa. "Big House" è tra le citazioni perché è una frase. Il comando terminale per eseguire questo programma sarebbe:

./ARTICOLI DI TEMP 3 Penna del libro "Big House"

Supponendo che la temperatura del file sia nella home directory. Si noti che gli spazi e non le virgole separano gli argomenti.

Ora, nella sintassi della funzione principale (), Argc è il numero di argomenti per il programma, più 1. In questo caso, ci sono 5 argomenti per il programma. Quindi, Argc è 6. Nella sintassi, Argv [argc] è una serie di puntatori alle corde. Il primo valore per questo array su argv [0] è dato dal compilatore. È un puntatore al nome del file di programma. Il resto dei valori è puntatori degli argomenti del programma nell'ordine dell'utente digitato. La dimensione di questo array è argc. In questo caso la dimensione è 1 + 5 = 6.

Supponiamo che alla compilazione, il seguente programma sia chiamato temp:

#includere
Utilizzo dello spazio dei nomi std;
int main (int argc, char ** argv)

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

Nota qui che l'array "char*argv [argc]", è stato dichiarato "char ** argv".

Se questo programma viene eseguito con il comando terminale,

./ARTICOLI DI TEMP 3 Penna del libro "Big House"

allora l'output sarebbe:

./temp, articoli, 3, libro, penna, grande casa

Si noti che il percorso della directory è stato incluso con il nome del file eseguibile.

Inoltre, si noti che nel corso del programma (chiamata del programma), il valore per Argc non è stato inviato.

Conclusione

La classe iostream ha quattro oggetti importanti che sono COUT, CIN, CERR e intasamento. CIN è un oggetto di input, mentre il resto sono oggetti di output. Mentre un programma è in esecuzione, l'input per il programma è diverso da quando il programma è iniziare a funzionare. Quando un programma inizia a funzionare, l'input per il programma è unita al comando per eseguire il programma, separato da spazi.