Gestire la console con le classi iostream in C++

In informatica, la console è la tastiera del computer e il monitor del computer. In passato, l'output veniva inviato direttamente allo schermo del monitor e non a una finestra visualizzata sul monitor. Per l'utente ordinario di computer, le applicazioni oggi non utilizzano il monitor in modo esplicito. Queste applicazioni utilizzano finestre visualizzate sul monitor. Tuttavia, il programmatore di computer deve ancora utilizzare lo schermo del monitor. Sebbene il programmatore debba ancora utilizzare lo schermo 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.

Ci si aspetta che il lettore sappia già come usare 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 al prompt dei comandi). Ogni programmatore C++ deve sapere in questo articolo.

Per avere l'input dalla tastiera e l'output sul terminale, il programma deve iniziare con:

#includere
usando lo spazio dei nomi std;

Contenuto dell'articolo

Narrow Stream Object 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

Narrow Stream Object 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 semplicemente senza istanziarli di nuovo.

cout

La seguente istruzione nella funzione main() invia il testo, "Questo è output.” al terminale:

cout << "This is output.";

cout è un oggetto iostream di output nella libreria standard, già istanziato. << 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 di cui sopra, il prompt dei comandi visualizzato nuovamente viene visualizzato a destra della frase di output. Non va alla riga successiva. "endl" alla fine della seguente istruzione 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 forzato 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" fa scorrere l'intera riga di testo sullo schermo.

Nota: una stringa inviata a cout è tra virgolette, mentre un carattere inviato è tra virgolette singole. Una serie di stringhe e caratteri può essere inviata in un'istruzione, 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 standard di iostream, già istanziato e disponibile nella libreria standard. Considera il seguente segmento di codice nella funzione main():

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

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

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

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

Nota la dichiarazione:

cin >> txt >> it >> ft;

La prima parola viene estratta in txt, la successiva e l'ultima in ft. Se l'input era,

uno 25 3.6

allora l'output del segmento di codice sarebbe,

uno 25 3.6

certo

Il seguente programma ha un errore:

#includere
usando lo spazio dei nomi std;
intero principale()

in mioInt;
restituisce 0;

La prima istruzione 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, "error.TXT":

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

Se il file “error.txt" non esiste, verrebbe creato. Nota la parte “2>error.txt" del comando g++.

Lo schermo è la destinazione dell'output standard ed è anche la destinazione dell'errore standard. Se “2>error.txt" viene omesso dal comando g++, quindi il messaggio di errore del compilatore verrebbe inviato alla destinazione dell'errore standard, che è ancora lo schermo (monitor).

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

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

zoccolo

Un'applicazione richiede input diversi in momenti diversi. Tutti gli ingressi possono essere rivisualizzati sullo schermo. Tutti gli input possono essere salvati in un file. Questo sta registrando. La destinazione di registrazione standard è lo schermo. L'oggetto flusso di registrazione standard è un intasamento. Il seguente codice visualizzerà nuovamente il testo di input sullo schermo:

char txt[50];
cout<<"Enter text and press Enter:"<>TXT;
zoccolo<Se il testo di input è "input_text", allora clog visualizzerà nuovamente "input_text" sullo schermo.

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

#includere
usando lo spazio dei nomi std;
intero principale()

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

Nota l'uso della funzione, freopen(), e dei 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 "write". Il suo terzo argomento è stdout per l'output standard. La seconda istruzione nella funzione main() usa 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 digita l'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 quindi passa all'istruzione di programma successiva, dopo l'istruzione di lettura dell'input.

L'oggetto cin ha metodi, di cui questa sezione si occupa.

Leggere il primo carattere

get(tipo_carattere& 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.get(ch);
cout << ch << endl;

La prima istruzione dichiara un carattere senza assegnazione. La seconda istruzione dice all'utente di inserire un carattere. Quando l'utente digita il carattere e preme il tasto Invio, la terza istruzione copia il carattere dal buffer del flusso di input nella variabile, ch.

Anche se l'utente ha digitato più di un carattere, il primo carattere sarà preso dal segmento di 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, streamsize n)**

Dopo che l'utente ha immesso una frase e premuto il tasto Invio, è possibile estrarre un numero di caratteri a partire dal primo dal buffer del flusso cin. È possibile utilizzare il seguente codice:

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

Se l'input è "grandi persone", l'output sarà "grande peo", di 9 caratteri e non di 10. Il carattere NUL della stringa (\0) occupa la decima posizione nell'argomento get. 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 della 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(). Nota che uno spazio viene conteggiato come un carattere.

get(char_type* s, streamsize n, char_type delim)
È possibile estrarre una sottostringa, delimitata a destra, dalla prima occorrenza di un particolare carattere, o dalla dimensione del flusso della sottostringa, che viene prima. Se il testo di input per il seguente codice è "grandi persone", verrà estratto "ottimo":

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

La sesta posizione dall'inizio è il carattere spazio e delimita esclusivamente la sottostringa estratta. La sesta posizione viene prima dell'unico carattere, 'o'. Nota che la dimensione di archiviazione per str può essere la più alta possibile.

Se il testo di input per il seguente codice è "grandi persone", verrà estratto "gr":

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

La prima occorrenza di 'e' viene prima della decima posizione.

Ottenere tutti i caratteri di una linea

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

cout << "Input text:" << endl;
mentre (1)
char ch = (char)cin.ottenere();
cout << ch;
if (ch == '\n')
rompere;

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

sbirciare()

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

cout << "Input text:" << endl;
mentre (1)
char ch = (char)cin.sbirciare();
cout << ch;
cin.ottenere();
if (ch == '\n')
rompere;

Se i caratteri successivi non sono stati rimossi da get(), peek() leggerebbe solo il primo carattere e il ciclo itera all'infinito.

Visualizzazione ed eliminazione dei caratteri prima di premere Invio

Nota che con l'oggetto cin, il tasto Invio deve essere premuto prima che ci sia azione. Bene, è possibile che i caratteri vengano visualizzati mentre vengono digitati e cancellati prima di premere il tasto Invio. 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 dopo.

Invio di caratteri e stringhe al monitor

L'oggetto cout è un oggetto flusso di output, già istanziato e presente nella libreria standard C++. cout è l'oggetto principale utilizzato per inviare 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 risultano in scalari possono essere argomenti per l'operatore di inserimento. L'operatore converte lo scalare in testo e posiziona il testo nel flusso di oggetti coutout. Quando il testo viene inviato all'oggetto cout, normalmente appare sullo schermo (monitor). Tuttavia, a volte, potrebbe non apparire immediatamente. Per forzare il testo sullo schermo, inserisci il valore speciale, "endl", subito dopo aver inserito il testo. Ciò farà sì che il testo venga scaricato sullo schermo e verrà aggiunta una nuova riga. Nota: '\n' aggiunge semplicemente una nuova riga ma non cancella il testo sullo schermo.

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

#includere
usando lo spazio dei nomi std;
intero principale()

int esso = 5;
galleggiante piedi = 63.5;
cout << "The " << it << " items cost $" << ft << " US." << endl;
restituisce 0;

L'uscita è:

I 5 articoli costano $ 63.5 USA.

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

#includere
usando lo spazio dei nomi std;
struttura St
char str[11] = "alcune parole";
obj;
intero principale()

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

L'output è "alcune parole".

Argomenti per un programma C++

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

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

restituisce 0;

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

articoli 3 penna libro "casa grande"

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

Ognuno è testo. Un argomento numerato per un programma è testo. In altre parole, ogni argomento è una stringa. "casa grande" è tra virgolette perché è una frase. Il comando del terminale per eseguire questo programma sarebbe:

./temp articoli 3 penna libro "casa grande"

Supponendo che il file temp sia nella directory home. Nota che gli spazi e non le virgole separano gli argomenti.

Ora, nella sintassi della funzione main(), 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] è un array di puntatori a stringhe. Il primo valore per questo array in argv[0] è dato dal compilatore. È un puntatore al nome del file del programma. Il resto dei valori sono puntatori agli argomenti del programma nell'ordine digitato dall'utente. La dimensione di questo array è argc. In questo caso la dimensione è 1 + 5 = 6.

Supponiamo che al momento della compilazione, il seguente programma si chiami temp:

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

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

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

Se questo programma viene eseguito con il comando da terminale,

./temp articoli 3 penna libro "casa grande"

allora l'output sarebbe:

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

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

Si noti inoltre che durante l'esecuzione 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 clog. cin è un oggetto di input, mentre gli altri sono oggetti di output. Mentre un programma è in esecuzione, l'input al programma è diverso da quando il programma deve iniziare a funzionare. Quando un programma inizia l'esecuzione, l'input al programma viene unito al comando per eseguire il programma, separato da spazi.