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 del computer, le applicazioni odierne 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 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 al prompt dei comandi). Ogni programmatore C++ deve sapere in questo articolo.
Per avere input dalla tastiera e output al terminale, il programma deve iniziare con:
#includere
usando spazio dei nomiore;
Contenuto dell'articolo
- Oggetti a flusso stretto 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 a flusso stretto dello standard iostream
La classe iostream, gli oggetti standard, cout, cin, cerr e clog, sono stati istanziati e sono già presenti nella libreria standard. Il programmatore li usa semplicemente senza istanziarli di nuovo.
costo
La seguente istruzione nella funzione main() invia il testo, This is output. al terminale:
costo << 'Questo è l'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:
costo << 'Questo è l'output.' <<fine;
endl è una variabile predefinita. Il contenuto dello schermo può anche essere forzato alla riga successiva con:
costo << 'Questo è l'output.' << ' ';Con l'uso di ' ', tutte le righe di testo potrebbero non essere visualizzate immediatamente sullo schermo. endl scarica l'intera riga di testo sullo schermo.
Nota: una stringa inviata a cout è tra virgolette, mentre un carattere inviato è tra virgolette. 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 ‘ ’ is not in the series.
Gin
cin è l'oggetto di input standard di iostream, già istanziato e disponibile nella libreria standard. Considera il seguente segmento di codice nella funzione main():
chartesto[cinquanta];costo << 'Inserisci una parola e premi Invio:' testo;
costo <<testo<<fine;
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. Notare l'uso di 'endl' che obbliga l'utente a inserire del testo nella riga successiva dello schermo. Mentre l'utente digita il testo, il testo immesso 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. Si noti l'uso dell'operatore di estrazione, >>. L'ultima istruzione visualizza il testo immesso 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:
chartesto[venti];intesso;
galleggianteft;
costo << 'Inserisci 3 valori e premi Invio:' testo>>esso>>ft;
costo <<testo<< '' <<esso<< '' <<ft<<fine;
Nota la dichiarazione:
Gin >>testo>>esso>>ft;La prima parola viene estratta in txt, la successiva e l'ultima in ft. Se l'input era,
uno25 3.6quindi l'output del segmento di codice sarebbe,
uno25 3.6certo
Il seguente programma ha un errore:
#includereusando spazio dei nomiore;
intprincipale()
{
in myInt;
Restituzione 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, il seguente comando g++ invierà il messaggio di errore del compilatore al file error.txt:
G++ -o temp.DC 2>errore.testoSe il file error.txt non esiste, verrebbe creato. Nota la parte 2>error.txt del comando g++.
La schermata è la destinazione dell'output standard ed è anche la destinazione dell'errore standard. Se 2>error.txt viene omesso dal comando g++, il messaggio di errore del compilatore verrà 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 << 'Il messaggio di errore!' << ' ';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. Questa è la registrazione. 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:
chartesto[cinquanta];costo<<'Inserisci il testo e premi Invio:'testo;
zoccolo<<testo<<fine;
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:
#includereusando spazio dei nomiore;
intprincipale()
{
aperto( 'log.txt','in',stdout);
costo << 'testo di input' <<fine;
}
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 prosegue quindi con l'istruzione di programma successiva, dopo l'istruzione di lettura dell'input.
L'oggetto cin ha metodi di cui si occupa questa sezione.
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:
costo << 'Testo di input:' <<fine;
Gin.ottenere(ch);
costo <<ch<<fine;
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 verrà preso dal segmento di codice.
ottenere():
get() senza argomenti, restituisce il codice ASCII decimale. Considera il seguente segmento di codice:
costo << Gin.ottenere() <<fine;
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:
charP[10];costo << 'Testo di input:' <<fine;
Gin.ottenere(str,10);
costo <<P<<fine;
Se l'input è 'grandi persone', l'output sarà 'grande peo', di 9 caratteri e non di 10. Il carattere NUL della stringa ( ) 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 è di grandi persone, allora verrà estratto grande:
costo << 'Testo di input:' <<fine;
Gin.ottenere(str,6,'o');
costo <<P<<fine;
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 è fantastico, allora gr verrebbe estratto:
charP[30];costo << 'Testo di input:' <<fine;
Gin.ottenere(str,10,'e');
costo <<P<<fine;
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:
costo << 'Testo di input:' <<fine;mentre (1) {
charch= (char)Gin.ottenere();
costo <<ch;
Se (ch== ' ')
rottura;
}
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 di 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:
costo << 'Testo di input:' <<fine;mentre (1) {
charch= (char)Gin.sbirciare();
costo <<ch;
Gin.ottenere();
Se (ch== ' ')
rottura;
}
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
Notare che con l'oggetto cin, il tasto Invio deve essere premuto prima che venga eseguita l'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 più avanti.
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 ‘ ’ 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 inserisce il testo nel flusso di oggetti cout. 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: ' ' aggiunge semplicemente una nuova riga ma non svuota il testo sullo schermo.
Il seguente programma mostra come stampare sullo schermo i valori di int, float e testo ordinario:
#includereusando spazio dei nomiore;
intprincipale()
{
intesso= 5;
galleggianteft= 63,5;
costo << 'Il ' <<esso<< 'gli articoli costano $' <<ft<< ' NOI.' <<fine;
Restituzione 0;
}
L'uscita è:
Il5gli articoli costano $63,5NOI.Il seguente programma mostra come viene stampata la stringa di un oggetto istanziato da una classe:
#includereusando spazio dei nomiore;
strutturans{
charP[undici] = 'alcune parole';
}obj;
intprincipale()
{
costo <<ogg.P << ' ';
Restituzione 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 è:
intprincipale(intargc,char *argv[argomento]){
Restituzione 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,
articoli3penna libro'grande casa'Ci sono 5 argomenti qui: articoli, 3, libro, penna e grande casa
Ciascuno è testo. Un argomento numerato per un programma è il testo. In altre parole, ogni argomento è una stringa. big house è tra virgolette perché è una frase. Il comando del terminale per eseguire questo programma sarebbe:
./articoli temporanei3penna libro'grande casa'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 di 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 taglia è 1 + 5 = 6.
Supponiamo che al momento della compilazione, il seguente programma si chiami temp:
#includereusando spazio dei nomiore;
intprincipale(intargc,char**argv)
{
costo <<argv[0] << ',' <<argv[1] << ',' <<argv[2] << ',' <<argv[3] << ',' <<argv[4] << ',' <<argv[5] <<fine;
Restituzione 0;
}
Nota qui che l'array 'char *argv[argc]' è stato dichiarato come 'char** argv'.
Se questo programma viene eseguito con il comando da terminale,
./articoli temporanei3penna libro'grande casa'allora l'output sarebbe:
./temperatura, articoli,3, libro, penna, grande casaNotare 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 avviarsi. Quando un programma viene avviato, l'input al programma viene unito al comando per eseguire il programma, separato da spazi.