Home

Federica EU

1/34

Silvia Rossi » 16.I File di testo

La nozione di classe e oggetti

Tipo: l’insieme dei valori che può assumere una variabile (semplice o strutturata) e l’insieme delle operazioni che possono applicarsi a tali valori.

Classe: la definizione di un tipo esteso che racchiude sia i valori che lo caratterizzano (proprietà), sia gli operatori che agiscono su quei valori (metodi).

Elemento del linguaggio del tipo assegnato

Elemento del linguaggio della classe assegnata

Vantaggi delle classi

Incapsulamento dati

I metodi come unico punto di accesso (interfaccia) alle sue proprietà.

Lo stato di un oggetto (l’insieme delle sue proprietà) può essere modificato solo attraverso l’interfaccia progettata (Oscuramento/Protezione dati).
cin.precision(2);

cin.precision = 2

Gli oggetti stream

Uno stream è un’astrazione, che rappresenta un “qualcosa” da o verso cui “fluisce” una sequenza di bytes

può essere interpretato come un “file intelligente” (con proprietà e metodi), che agisce come “sorgente” da cui estrarre (input), o “destinazione” in cui inserire (output) i dati

Esempi di stream:

Input da tastiera, output a schermo
File in lettura, file in scrittura
Buffer
Canali di trasmissione di rete

Sequenza di byte

Gli oggetti stream

Un concetto importante è la posizione corrente in uno stream (file position indicator), che coincide con l’indice del prossimo byte che deve essere letto o scritto.

Ogni operazione di I/O modifica la posizione corrente.

La posizione corrente può essere ricavata o modificata direttamente usando particolari metodi.

File position indicator

Gli oggetti stream

Gli oggetti stream sono organizzati secondo una gerarchia di classi dette genericamente stream

Ogni classe è specializzata per tipo di operatori di input e output supportati e per il tipo delle sorgenti e destinazioni (file, I/O, stringhe, etc.)

Gerarchia di classi

Gli oggetti stream

cin e cout sono oggetti (globali) rispettivamente delle classi istream e ostream di cui conosciamo già alcuni metodi:

cin>>dato; (operatore di estrazione)

cin.getline(char s[], int n, char c='\n')

cin.get (char s[], int n, char c='\n')

cout<<dato; (operatore di inserimento)
cout.width(ampiezza);

cout.precision(cifre);

File testo

Il file di testo è un file che contiene caratteri ASCII.

Il file fisicoè immagazzinato su una memoria secondaria (disco)
- Può essere manipolato con le funzioni che il sistema operativo mette a disposizione dei programmi

Nome del file fisico: una stringa che indica il percorso e il nome del file sul supporto di memoria

Il file logico(buffer) è una copia residente in RAM di dati contenuti in un file fisico
- Nel programma viene identificato da un nome logico.

File testo

Un file di testo può essere immaginato come una successione di caratteri leggibili, separati da carattere speciali:

La posizione corrente nel file (file position indicator), durante la lettura o la scrittura dei caratteri è memorizzata nell’oggetto file.

FPI può essere spostato in qualsiasi parte del file con l’uso di opportuni metodi.

File testo

Supponiamo che il contenuto di un file di nome fisico prova.txt, che si trova sul disco rigido sia:

Nel mezzo del cammin di nostra vita <eoln>

mi ritrovai in una selva oscura <eoln> <eof>

Per scrivere questo testo è sufficiente utilizzare un qualsiasi editor (come lo stesso sistema di sviluppo DevCpp oppure Blocco Note sotto Windows).

File testo

Per gestire un file in un programma C++ occorre:

Includere <fstream>
dichiarare una variabile di tipo ifstream per la lettura del file o di tipo ofstream per la scrittura del file ( tale variabile corrisponderà al nome logico del file)
aprire il file creando una corrispondenza tra nome fisico e nome logico del file
leggere o scrivere i dati nel file.
chiudere file

File testo → dichiarazione

Oggetti di tipo file testo in sola lettura:

#include
ifstream inputfile

Oggetti di tipo file testo in sola scrittura:

#include
ofstream outputfile

Oggetti di tipo file testo in lettura e scrittura:

#include
fstream file

La definizione (allocazione) di un oggetto file testo coincide con la sua prima dichiarazione incontrata dal compilatore nel programma

File testo → apertura

L’apertura del file logico con il conseguente collegamento al file fisico è svolta dal seguente metodo (procedura):

file.open(nomefile)

L’apertura del file corrisponde all’inizializzazione dell’oggetto file

È possibile definire e insieme inizializzare un file testo:

#include <fstream>
fstream file(nomefile)

Esempio:

ifstream file1;
file1.open("prova.txt");

oppure:

ifstream file1 (“prova.txt”);

File testo → apertura

Una volta creata la corrispondenza tra file fisico e file logico, il sistema operativo si occuperà di travasare i dati dall’uno all’altro.

Quando ordiniamo di scrivere sul file logico:

i dati inviati vengono memorizzati temporaneamente nel buffer.
Nel momento in cui tale zona di memoria viene riempita oppure il file viene chiuso, allora il computer provvederà ad inviare tutti i dati al file fisico.

Nella fase di lettura:

il computer legge dal file fisico una quantità di dati tale da riempire il buffer (oppure legge tutti i dati del file se questi sono in quantità inferiore alla lunghezza del buffer);
ogni istruzione di lettura successiva continuerà a leggere dati dal buffer finché esso non si svuota;
a quel punto nuovi dati vengono prelevati dal file ed inseriti nel buffer per essere letti successivamente.

File testo → chiusura

La chiusura del file logico con conseguente rilascio del collegamento col file fisico è svolta dal seguente metodo (procedura):

file.close ()

Alla chiusura del file logico le modifiche in esso registrare sono definitivamente scritte sul file fisico

Esempio:

fstream file1;

file1.open (“prova.txt”);

… lavora sul file …

file1.close ();

File testo → controlli

L’apertura di un file (in lettura e/o scrittura) potrebbe non aver successo:

Si apre un file in una modalità protetta (scrittura, lettura, entrambi)
Si apre un file senza averne i permessi opportuni
Si apre un file indicando un nome (o percorso) errato

…

L’espressione !(file) vale true se l’apertura ha successo, false in caso di errore:

Esempio:
ifstream file1;

file1.open (“prova.txt”);

if (!file1) {

cerr<< “Non si può aprire il file\n”;

}

File testo → lettura per parola

Per leggere una parola da un file si usa l’operatore di estrazione:

file>>parola

file>>carattere

file>>numero prova.txt

Mostra codice

...

legge una stringa di caratteri da file fin quando trova uno spazio o la fine linea o tabulazione; la stringa è convertita nel tipo nativo dell'argomento (int, double, char, char, ...)

ritorna un puntatore (a void) non nullo in caso di lettura con successo, nullo altrimenti.

Esempio:

ifstream file;

file.open ("prova.txt");

while (file>>parola) {

cout <<parola<< " ";

}

File testo → fine del file

Per determinare la fine di un file si usa il metodo (funzione)

file.eof()

Mostra codice

ritorna true se il FPI è sul carattere <eof> , false altrimenti:

vale true se non ci sono più caratteri da leggere o se si è scritto un carattere alla fine del file

Esempio:

cout << "Nome File="; cin >> Nomefile;

file.open (Nomefile);

while

(!file1.eof()) {

file1 >>parola;

cout<< parola<endl;

}
prova.txt

File testo → lettura per carattere

Per leggere un carattere alla volta in un file si usa il metodo:

file.get(c)

(o c = file.get())

c è la variabile di tipo char che conterrà il carattere letto dal buffer

Mostra codice

file.putback ()

Immette nuovamente l'ultimo carattere letto nel buffer (arretrando FPI)

c = file.peek () prova.txt

ritorna il prossimo carattere da leggere (senza toglierlo dal buffer e senza spostare FPI)

può essere usato per riconoscere il tipo del prossimo dato prima di leggerlo effettivamente

Mostra codice

File testo → lettura per riga

Per leggere una sequenza di caratteri di un file fino alla fine della riga (<eol>) si usa il metodo (funzione):

file.getline(s,n,c='\n')

s è una variabile stringa che conterrà i caratteri letti seguiti dal terminatore ‘\0′

n è intero che indica il numero massimo di caratteri da leggere

c (opzionale) è il carattere delimitatore di input: se incontrato la lettura termina, c non è copiato in s e il FPI si posizione subito dopo il delimitatore (che viene saltato)

File testo → lettura per riga

Esempio

Mostra codice

File testo → lettura per riga

Per leggere una sequenza di caratteri di un file fino alla fine della riga (<eol>) si usa il metodo (funzione):

file.getline(s,n,c='\n') email.txt

Esempio:

ifstream file1;

file1.open (“email.txt”);

while (!file1.eof()) {

file1.getline (nome,100,'|');

file1.getline (uname,100,'@');

file1.getline (host,100);

cout<<<" at "<<

}

Mostra codice

File testo → saltare la lettura

Per saltare la lettura di una sequenza di byte in un file si usa il metodo:

file.ignore (n=1, c=EOF) email.txt

n (opzionale) è l’intero che indica il numero di bytes da saltare (se omesso vale 1)

c (opzionale) è il delimitatore che indica fin dove saltare i bytes (anche il delimitatore è saltato)

Serve per avanzare la lettura senza acquisire dati (non validi)

Esempio:

Mostra codice

File testo → scrittura per parola

Per scrivere una parola in un file si usa l’operatore di estrazione

file<<parola file<<carattere file<<numero ...

ha come argomento un tipo nativo (int, double [ ] , char , char, …) e lo converte in una stringa di caratteri da scrivere nel file.

File testo → scrittura per carattere

Per scrivere un carattere alla volta in un file si usa il metodo:

file.put(c)

c è la variabile char che contiene il carattere da scrivere nel file

Esempio:

Mostra codice

File testo → scrittura per carattere

put

file.put (ch);
file.put (‘A’);
Può essere usato in cascata
- file.put(‘A’).put(‘\n’);
- operatore (.) valutato da sinistra a destra
ASCII
- file.put(65);
- Inserisce ‘A’

flush()

Anche l’output è gestito tramite un buffer, quindi i dati che noi scriviamo vengono scritti nel buffer e non immediatamente nel file.
Quando il buffer si riempie (o si chiude il file) i dati sono trascritti nel file e il buffer si svuota.
Se si vogliono salvare prima i dati si usa flush()

Mostra codice

C++ File I/O

ifstream OpenFile(char *filename, int open_mode);

input_filename_var.open("pathname/filename",ios::in);

output_filename_var.open("pathname/filename",ios::out);

ios::in e ios::out sono opzionali e rappresentano la modalità di accesso al file.

I file possono essere aperti in altre modalità, come, ad esempio, ios::append o ios::binary

Append

Le operazioni standard iniziano con un file vuoto

Se il file esiste → il contenuto viene perso

append:

ofstream outStream;

outStream.open(“prova.txt”, ios::app);

Se il file non esiste → viene creato

Se il file esiste → I dati vengono aggiunti alla fine del file

File testo

Esempio: lettura di un archivio studenti

Si abbia un file di tipo testo, “prova01.txt”, contenente le seguenti informazioni rispetto agli studenti di una certa università:

cognome e nome dello studente seguito dal simbolo di punto e virgola (;),
numero di matricola,
4 numeri interi che rappresentano il voto dei primi 4 esami (lo zero indica che l’esame non è stato superato )

Scrivere un programma che, assegnata una media M in input, stampi il cognome, nome e numero di matricola di tutti gli studenti che hanno una media maggiore o uguale ad M

Esempio:

Input:
- M=26
Output:
- Caio Mario 15340
- Ferrara Ciro 13124

de Rossi Mario;13240 28 25 0 24

Caio Mario;15340 28 0 26 24

Bianchi Antonio;12540 26 20 30 25

Ferrara Ciro;13124 30 28 0 27
prova2.txt

File testo

Esempio: lettura di un archivio studenti Mostra codice

prova2.txt

File testo

Esercizi:

1. Sia dato un file testo di nome fisico “studenti.txt” contenente informazioni sugli studenti di un corso (strutturate secondo l’esempio in figura). Dati un intero C rappresentante un codice d’esame, un intero M rappresentante un voto ed un intero N rappresentante un anno, scrivere un algoritmo che dia in output il nome degli studenti che hanno sostenuto l’esame di codice C prima dell’anno N con un voto≥M.

Esempio:

Input:
- 3070 24 2002
Output:
- Marco Rossi

Esempio

File testo

2. Un file testo “parole.txt” contiene, per ogni riga, una serie di parole, ognuna delle quali è seguita da uno spazio o dal carattere . Ogni parola è costituita da caratteri alfabetici e può essere composta da sole lettere maiuscole, sole lettere minuscole o da entrambe. Scrivere una procedura che legga il file “parole.txt” e costruisca due file:

nel primo file andranno inserite, una per riga, le parole contenenti solo lettere maiuscole;
nel secondo andranno inserite, sempre una per riga, le parole contenenti solo lettere minuscole.
Le parole contenenti sia lettere maiuscole che lettere minuscole non andranno memorizzate.

Esempio

File testo

3. Sia dato un file testo “parole.txt” composto da sole lettere maiuscole. Ogni linea di testo è costituita da un carattere seguito da uno spazio e da una serie di parole tutte separate da uno spazio (compreso l’ultima). Tutte le parole di un rigo dovrebbero iniziare o terminare con il carattere di inizio riga. Scrivere una procedura che legga il file “parole.txt” e stampi a video tutte le parole che non verificano la condizione suddetta.

Esempio

File testo

4. Siano dati due file testo: “studenti.txt” e “tesi.txt”. Il primo contiene informazioni riguardanti tutti gli studenti di un corso di laurea; il secondo contiene informazioni riguardanti i soli studenti del medesimo corso di laurea che hanno già fatto richiesta della tesi (vedi figura) Scrivere una procedura che mostri a video la matricola e la media di tutti gli studenti che hanno richiesto la tesi e che hanno svolto tutti gli esami.