FONDAMENTI DI INFORMATICA
Prof. PIER LUCA MONTESSORO Ing. DAVIDE PIERATTONI
Facoltà di Ingegneria
Università degli Studi di Udine
Input/output in C e in C++
Questo insieme di trasparenze (detto nel seguito slide) è protetto dalle leggi sul copyright e dalle disposizioni dei trattati internazionali. Il titolo ed i copyright relativi alle slides (ivi inclusi, ma non limitatamente, ogni immagine, fotografia, animazione, video, audio, musica e testo) sono di proprietà degli autori prof. Pier Luca Montessoro e ing. Davide Pierattoni, Università degli Studi di Udine.
Le slide possono essere riprodotte ed utilizzate liberamente dagli istituti di ricerca, scolastici ed universitari afferenti al Ministero della Pubblica Istruzione e al Ministero dell’Università e Ricerca Scientifica e Tecnologica, per scopi istituzionali, non a fine di lucro. In tal caso non è richiesta alcuna autorizzazione.
Ogni altro utilizzo o riproduzione (ivi incluse, ma non limitatamente, le riproduzioni su supporti magnetici, su reti di calcolatori e stampe) in toto o in parte è vietata, se non esplicitamente autorizzata per iscritto, a priori, da parte degli autori.
L’informazione contenuta in queste slide è ritenuta essere accurata alla data della pubblicazione. Essa è fornita per scopi meramente didattici e non per essere utilizzata in progetti di impianti, prodotti, reti, ecc. In ogni caso essa è soggetta a cambiamenti senza preavviso. Gli autori non assumono alcuna responsabilità per il contenuto di queste slide (ivi incluse, ma non limitatamente, la correttezza, completezza, applicabilità, aggiornamento dell’informazione).
In ogni caso non può essere dichiarata conformità all’informazione contenuta in queste slide.
In ogni caso questa nota di copyright e il suo richiamo in calce ad ogni slide non devono
Nota di Copyright
Input/output standard
• In C, l’header file necessario per effettuare l’input da tastiera e l’output sul monitor è stdio.h:
#include <stdio.h>
• In C++ le stesse operazioni richiedono l’header file iostream.h:
#include <iostream.h>
Lettura di dati da tastiera
• Per leggere da tastiera un intero i, un numero reale z oppure una stringa str, il C offre la funzione
scanf (di input formattato):
scanf ("%d %f %s", &i, &z, str);
• Il C++ permette simili operazioni in modo più
semplice, interpretando automaticamente il tipo del dato a partire da quello della variabile in cui il dato viene scritto:
cin >> i >> z >> str;
Stampa sul monitor
• Per stampare sul monitor (standard output) un intero i, un numero reale z oppure una stringa str, in C si usa la funzione printf (di output formattato):
printf ("%d %f %s", i, z, str);
• In C++ si utilizza la funzione cout, che interpreta automaticamente il tipo del dato a partire da quello della variabile da stampare:
cout << i << z << str;
Lettura di caratteri
• La lettura di un carattere singolo, spazi inclusi, si effettua in C con la funzione getchar():
char ch;
ch = getchar();
Il corrispondente in C++ è la funzione cin.get():
ch = cin.get();
Scrittura con formattazione
• La stampa sul monitor di un intero i in ottale o in esadecimale avviene in C con opportuni caratteri di conversione applicati alla funzione printf():
printf ("%o %h", i, i);
• La stessa formattazione si ottiene in C++ con la sequenza:
cout << oct << i << hex << i;
Scrittura di numeri reali
• In C la stampa di un numero reale z può essere
effettuata specificando negli argomenti di printf() il numero di caratteri totali e il numero di cifre
decimali desiderati:
printf ("%10.4f", z); /* stampa z su 10 caratteri con 4 cifre decimali */
• In C++ simili formattazioni, con risultato
generalmente diverso, si ottengono ad esempio con:
cout << cout.precision(4) << z;
Input e output sui file
• In C, l’header file necessario per effettuare l’input e l’output sui file è stdio.h:
#include <stdio.h>
• In C++ le stesse operazioni richiedono in aggiunta a iostream.h l’header file specifico fstream.h:
#include <iostream.h>
#include <fstream.h>
File handler
• La dichiarazione di un file handler (puntatore ad una struttura FILE) in un programma C è:
FILE *f_input, *f_output;
/*due handler, uno per il file di input e l’altro per il file di output */
• In C++ gli handler di file su disco si dichiarano invece come:
fstream f_input, f_output;
Apertura dei file in lettura
• Per aprire il file dati_in.txt in lettura e gestire la condizione di errore in mancanza del file stesso, il C prevede l’uso della funzione fopen:
if ((f_input = fopen("dati_in.txt", "r")) == NULL)
{
/* istruzioni da eseguire in caso di errore (es. nel caso di
file inesistente) */
}
Apertura dei file in lettura
• Per aprire lo stesso file dati_in.txt in lettura, una delle possibili sequenze di istruzioni corrispondenti in C++ è la seguente:
f_input.open ("dati_in.txt", ios::in);
if (f_input.fail()) {
// istruzioni da eseguire in caso di // errore
}
Apertura dei file in scrittura
• Per aprire il file dati_out.txt in scrittura,
cancellando un’eventuale versione preesistente del file su disco, il C prevede istruzioni del tipo:
if ((f_output =
fopen("dati_out.txt", "w")) == NULL) {
/* istruzioni da eseguire in caso di errore*/
}
Apertura dei file in scrittura
• In C++ lo stesso risultato si ha con istruzioni del tipo:
f_output.open ("dati_out.txt", ios::out);
if (f_output.fail()) {
// istruzioni da eseguire in caso di // errore
}
Apertura dei file in scrittura
• Per aprire il file dati_out.txt in scrittura, iniziando però dalla fine del file se esso è già presente su disco (append) , il C utilizza ancora la funzione fopen():
if ((f_output =
fopen("dati_out.txt", "a")) == NULL) {
/* istruzioni da eseguire in caso di errore*/
}
Apertura dei file in scrittura
• In C++ la scrittura in modalità append si ha con istruzioni del tipo:
f_output.open ("dati_out.txt", ios::app);
if (f_output.fail()) {
// istruzioni da eseguire in caso di // errore
}
Lettura di caratteri da file
• Per leggere dei caratteri (spazi inclusi) da un file
dati_in.txt, il C impiega la funzione fgetc(), che restituisce il valore EOF (-1) quando si raggiunge la fine del file:
char ch;
FILE *f_input;
if ((f_input =
fopen("dati_in.txt", "r")) != NULL) while ((ch = fgetc(f_input)) != EOF)
{
Lettura di caratteri da file
• Il C++ utilizza invece la funzione get()della classe fstream, che restituisce il valore zero quando si raggiunge la fine del file:
char ch;
fstream f_input;
f_input.open("dati_in.txt", ios::in);
if (f_input.fail()) { ... }
while ((ch = f_input.get()) != 0) {
Lettura da file con fomattazione
• Per leggere da un file dati_in.txt un intero i, un reale z e una stringa str, in C si utilizza la funzione fscanf(), che consente di specificare il tipo del dato letto e salvarne il valore in un’opportuna variabile:
while (fscanf (f_input, "%d %f %s", &i, &z, str) != EOF)
{
...
}
Lettura da file con fomattazione
• Un risultato equivalente si ha in C++ con costrutti del tipo:
if (f_input >> i >> z >> str) {
// se l’espressione restituisce il // valore zero, allora il file
// è finito...
}
Scrittura su file con formattazione
• Per scrivere su un file dati_out.txt un intero i, un reale z e una stringa str, in C si usa la funzione
fprintf(), specificando negli argomenti il tipo delle variabili il cui valore verrà scritto nel file:
fprintf (f_output, "%d %f %s", i, z, str);
• In C++ lo stesso risultato si ottiene con la sintassi:
f_output << i << z << str;
Chiusura di un file
• Per chiudere un file precedentemente aperto da un programma C con fopen(), si deve usare la
funzione fclose():
f_input = fopen("dati_in.txt", "r");
f_output = fopen("dati_out.txt", "w");
...
fclose(f_input);
fclose(f_output);
Chiusura di un file
• In C++ le istruzioni corrispondenti sono:
f_input.open("dati_in.txt", ios::in);
f_output.open("dati_out.txt", ios::out);
...
f_input.close();
f_output.close();
