La copia di un file. contare di quanti caratteri sia composto il file (e quindi determinare la dimensione del file di origine)

Transcript

1 La copia di un file Nell'esercizio di oggi cerchiamo di implementare un programma che permetta di effettuare la copia di un file di testo. L'operazione di copia, oltre a permettere di creare un nuovo file il cui contenuto sia identico a quello del file di origine, ci dovrà anche permettere di: 1. contare di quanti caratteri sia composto il file (e quindi determinare la dimensione del file di origine) 2. determinare il numero di occorrenze di ciascuno dei caratteri della tabella standard all'interno del file, il numero di lettere maiuscole presenti ed il numero di lettere minuscole 3. determinare se, all'interno del file di origine, siano presenti dei numeri interi e, nel caso, visualizzarne il valore Tutte queste operazioni dovranno essere implementate in modalità ricorsiva. Una volta raccolte tali informazioni, esse andranno memorizzate all'interno di un'opportuna struttura. Prima di definire tale struttura, è importante considerare che: a. l'informazione relativa alla dimensione del file (punto (1)) è un'informazione che, assieme al nome del file, fa riferimento ad una proprietà del file nel suo complesso b. le informazioni raccolte ai punti (2) e (3) fanno riferimento al contenuto del file Per rendere evidente questa separazione, possiamo collocare le informazioni raccolte all'interno di due distinte strutture; una contenente informazioni sul file e l'altra sul suo contenuto. La definizione della prima potrebbe essere: typedef struct {char nome_file[100]; int dimensione; info_file; Quella della seconda, invece: typedef struct {int conteggi[128]; int maiusc; int minusc; int numeri; info_contenuto; Essendo entrambe strutture che contengono informazioni sul file, possiamo da queste due costruire una terza struttura che raggruppa le due precedenti: typedef struct {info_file *generale; info_contenuto *lettere; my_file;

2 Quest'ultima struttura contiene due puntatori, ciascuno dei quali fa riferimento ad una variabile di tipo info_file o di tipo info_contenuto. Vediamo ora un breve esempio di utilizzo della struttura my_file. /* inizio codice */ #include <stdio.h> #include <stdlib.h> typedef struct {char nome_file_orig[100]; char nome_file_dest[100]; int dimensione; info_file; typedef struct {int conteggi[128]; int maiusc; int minusc; int numeri; info_contenuto; typedef struct {info_file *generale; info_contenuto *lettere; my_file; int main() {my_file nuovo; /* dichiaro una variabile di tipo my_file */ /* ora alloco memoria per i due puntatori */ my_file.generale = (info_file*) malloc(sizeof(info_file)); my_file.lettere = (info_contenuto*) malloc(sizeof(info_contenuto)); /* ora è possibile accedere ai membri delle due strutture */ printf("\ninserisci il nome del file"); scanf("%s",my_file.generale->nome_file); /* my_file.generale è un puntatore a struttura */ printf("\nquante sono le lettere minuscole?"); scanf("%d", & (my_file.lettere->minusc)); /* my_file.lettere è un puntatore a struttura */ return 0; /* fine codice */ Procediamo ora con l'implementazione delle funzioni. Oltre alla copia del file di origine all'interno del file di destinazione, se la lettura del file di origine avviene carattere per carattere durante la copia è possibile ottenere anche le informazioni relative al numero di caratteri presenti nel file e alla loro altezza. La funzione che si occupa di effettuare la copia, può perciò servire anche a rispondere alle richieste presentate ai punti (1) e (2). Tali valori vanno inseriti all'interno delle due sottostrutture che compongono una struttura di tipo my_file; tali sottostrutture sono rappresentate, all'interno della struttura my_file, mediante puntatori. Sarà quindi sufficiente passare alla funzione una variabile di tipo my_file per copia. La funzione avrà perciò il seguente prototipo:

3 void copia_conta(file* origine,file* destinazione,my_file dati); Nello scrivere l'implementazione in modalità ricorsiva bisogna considerare che: 1. la funzione deve leggere UN SOLO CARATTERE dal file; la lettura del successivo avviene richiamando la funzione stessa letto il carattere, il contatore che rappresenta il numero totale di caratteri deve essere incrementato se il carattere è una minuscola bisogna incrementare il corrispondente contatore se il carattere è una maiuscola bisogna incrementare il corrispondente contatore se il carattere non è EOF, la funzione deve richiamare se stessa se il carattere è EOF, la funzione non deve richiamare se stessa Domanda: supponendo che un algoritmo si possa implementare sia in modalità iterativa che in modalità ricorsiva, in base a cosa scegliamo una modalità piuttosto che l'altra? /* inizio implementazione; nello scrivere il codice supponiamo che il file di origine e quello di destinazione siano già stati aperti e che la memoria per le sottostrutture della struttura di tipo my_file, dati, sia già stata allocata e che i contatori siano già stati inizializzati */ void copia_conta(file* origine,file* destinazione,my_file dati) (dati.generale->dimensione) ++; /* conteggio il carattere */ if(isupper(c)) (dati.lettere->maiusc) ++; /* incremento il contatore relativo alle lettere maiuscole */ if(islower(c)) (dati.lettere->minusc) ++; /* incremento il contatore relativo alle lettere minuscole */ if(c!=eof) {fputc(c,destinazione); /* non copio EOF, quello lo inserisce la funzione fclose() */ copia_conta(origine,destinazione,dati); /* fine implementazione */ Procediamo ora con la funzione che serve a determinare se nel file vi siano o meno dei numeri interi. La funzione, non sapendo a priori se vi siano o meno dei numeri, deve leggere dal file un carattere per volta; tale funzione non copia caratteri da un file all'altro quindi, tra i parametri, è sufficiente inserire il solo puntatore al file di origine. Nel caso la funzione individuasse la presenza di eventuali numeri, essa deve incrementare il valore del campo numeri della sottostruttura lettere della struttura di tipo my_file. Seguendo il ragionamento fatto prima, per poter effettuare tale operazione sarà sufficiente passare alla funzione la struttura di tipo my_file per valore e non per riferimento. La funzione avrà perciò il seguente prototipo: void cerca_interi(file* origine,my_file dati);

4 Nello scrivere l'implementazione in modalità ricorsiva bisogna considerare che: 1. la funzione deve leggere UN SOLO CARATTERE dal file; la lettura del successivo avviene richiamando la funzione stessa 2. letto il carattere, la funzione deve determinare se tale carattere sia o meno un carattere numerico 3. se il carattere è numerico, essa deve continuare a leggere fino ad incontrare il primo carattere non numerico; tutti i caratteri numerici letti vanno inseriti in una stringa di appoggio 4. riempita la stringa d'appoggio con i caratteri numerici, la funzione deve visualizzare il valore contenuto nella stringa /* inizio implementazione; nello scrivere il codice supponiamo che il file di origine sia già stato aperto e che la memoria per le sottostrutture della struttura di tipo my_file, dati, sia già stata allocata e che il contatore siano già stato inizializzato. Nell'implementare la funzione, serviamoci di una stringa d'appoggio dichiarata come variabile esterna */ char appoggio[30]; void cerca_interi(file* origine,my_file dati) int i=0; if(isdigit(c)) {appoggio[i]=c; /* inserisco il primo valore */ i++; while(isdigit(c=fgetc(origine))) {appoggio[i]=c; i++; appoggio[i]=0; printf("\n ho trovato il numero %s",appoggio); printf("\n ora lo visualizzo come un intero: %d",atoi(appoggio)); (dati.lettere->numeri)++; /* incremento il contatore */ if(c!=eof) cerca_interi(origine,dati) ; /* fine implementazione */ Prepariamo ora il programma che, basandosi sulle funzioni appena implementate, crea una copia del file di origine e raccoglie le informazioni richieste. /* inizio codice*/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stype.h> typedef struct {char nome_file_orig[100]; char nome_file_dest[100]; int dimensione; info_file; typedef struct {int conteggi[128];

5 int maiusc; int minusc; int numeri; info_contenuto; typedef struct {info_file *generale; info_contenuto *lettere; my_file; char appoggio[30]; void cerca_interi(file*,my_file); void copia_conta(file*,file*,my_file); int main() {FILE *input,*output; char stringa_info[120]; my_file informazioni; informazioni.generale = (info_file*) malloc(sizeof(info_file)); informazioni.lettere = (info_contenuto*) malloc(sizeof(info_contenuto)); if(informazioni.generale==null) exit(0); if(informazioni.lettere==null) exit(0); /* lettura dei nomi dei file */ printf("inserisci il nome del file di origine"); scanf("%s", informazioni.generale->nome_file_orig); printf("inserisci il nome del file di destinazione "); scanf("%s", informazioni.generale->nome_file_dest); /* apertura dei file */ input= fopen ( informazioni.generale->nome_file_orig, "r" ); output= fopen ( informazioni.generale->nome_file_dest, "w" ); if(input==null) exit(0); if(output==null) exit(0); /* inizializzo i contatori */ informazioni.generale->dimensione = 0; informazioni.lettere->maiusc = 0; informazioni.lettere->minusc = 0; informazioni.lettere->numeri = 0; copia_conta(input,output,informazioni); fclose(output); /* chiudo il canale di collegamento al file; i dati vengono memorizzati su disco */ rewind(input); /* ritorno all'inizio del file perché devo ripetere la lettura */ cerca_interi(input,informazioni); /* ora salvo le informazioni raccolte */ strcpy(stringa_info, informazioni.generale->nome_file_orig); strcat(stringa_info,"_info"); output = fopen(stringa_info,"w"); fprintf(output,"ecco il nome del file di origine: %s", informazioni.generale->nome_file_orig); fprintf(output,"\nla dimensione del file di origine e\': %d", informazioni.generale->dimensione); fprintf(output,"\necco il nome del file di destinazione: %s", informazioni.generale->nome_file_dest); fprintf(output,"\nnel file di origine ci sono %d lettere maiuscole", informazioni.lettere->maiusc); fprintf(output,"\nnel file di origine ci sono %d lettere minuscole", informazioni.lettere->minusc); fprintf(output,"\nnel file di origine ci sono %d numeri interi ", informazioni.lettere->numeri); fclose(output); return 0;

6 void copia_conta(file* origine,file* destinazione,my_file dati) (dati.generale->dimensione) ++; /* conteggio il carattere */ if(isupper(c)) (dati.lettere->maiusc) ++; /* incremento il contatore relativo alle lettere maiuscole */ if(islower(c)) (dati.lettere->minusc) ++; /* incremento il contatore relativo alle lettere minuscole */ if(c!=eof) {fputc(c,destinazione); /* non copio EOF, quello lo inserisce la funzione fclose() */ copia_conta(origine,destinazione,dati); void cerca_interi(file* origine,my_file dati) int i=0; if(isdigit(c)) {appoggio[i]=c; /* inserisco il primo valore */ i++; while(isdigit(c=fgetc(origine))) {appoggio[i]=c; i++; appoggio[i]=0; printf("\n ho trovato il numero %s",appoggio); printf("\n ora lo visualizzo come un intero: %d",atoi(appoggio)); (dati.lettere->numeri)++; /* incremento il contatore */ if(c!=eof) cerca_interi(origine,dati) ; /* fine codice*/ Esercizio: sia data la seguente struttura typedef struct { int *array; char * stringa;; coppia; Si scriva un programma che richiama le funzioni qui di seguito descritte. Alla fine del programma, TUTTE le aree di memoria allocate dinamicamente DEVONO ESSERE disallocate. 1. dichiarare ed implementare una funzione che accetta come parametro un intero e che restituisce un puntatore a

7 variabile di tipo coppia. la funzione deve allocare un'area di memoria sufficiente a contenere un numero di strutture pari al valore del parametro di tipo intero. Allocata l'area di memoria, la funzione deve controllare che la chiamata a malloc() sia avvenuta in modo corretto e deve restituire il puntatore a tale area di memoria dichiarare ed implementare una funzione che accetta come parametro un puntatore a struttura di tipo coppia ed una variabile di tipo intero. Il primo parametro rappresenta l'indirizzo di un'area di memoria contenente delle strutture di tipo coppia mentre il secondo indica quale sia il numero di strutture presenti nell'area di memoria. La funzione deve allocare memoria per entrambi i puntatori di ciascuna delle strutture di tipo coppia presenti nell'array. In particolare, al puntatore a int deve essere assegnato l'indirizzo di un'area contenente 10 elementi di tipo int, mentre al puntatore a char va assegnato l'indirizzo di un'area contenente 11 char. Nell'implementare la funzione VERIFICARE che le chiamate alla funzione malloc() vadano a buon fine. dichiarare ed implementare una funzione che accetta come parametro un puntatore a struttura di tipo coppia ed una variabile di tipo intero. Il primo parametro rappresenta l'indirizzo di un'area di memoria contenente delle strutture di tipo coppia mentre il secondo indica quale sia il numero di strutture presenti nell'area di memoria. La funzione deve inizializzare ciascuna struttura dell'array in questo modo: ad ogni elemento dell'array di int cui fa riferimento il puntatore ad intero contenuto in ogni struttura va inizializzato con numeri casuali compresi tra 300 e 1000 mentre ogni elemento dell'array di char cui fa riferimento il puntatore a carattere contenuto in ogni struttura va inizializzato con lettere causali minuscole. dichiarare ed implementare una funzione che visualizzi il contenuto di tutte le strutture contenute nell'array di char. la funzione deve anche poter permettere di salvare su file il contenuto dell'array.