Puntatori. Grazie ai puntatori:

Transcript

1 Puntatori Grazie ai puntatori: 1) è possibile permettere ad una funzione di modificare il contenuto di un area di memoria; 2) invece di passare ad una funzione tutto un blocco di memoria, si passa alla funzione solo il puntatore alla prima cella dell area di memoria e la dimensione dell area stessa. Visto che il passaggio dei parametri, in C, avviene per copia, questo permette un notevole risparmio di memoria; 3) la visibilità delle variabili è circoscritta al blocco di codice in cui tali variabili sono dichiarate; la stessa cosa si può dire, in generale, delle aree di memoria allocate all atto della dichiarazione di tali variabili. Mediante l uso dei puntatori non si può alterare la visibilità delle variabili, ma possiamo rendere visibile un area di memoria anche a porzioni di codice distinte da quelle in cui è avvenuta l allocazione di tale area. 4) se la visibilità di un area di memoria può essere modificata, non risulta possibile alterare la durata di tale area, in quanto la durata dell area di memoria è vincolata a quella della variabile memorizzata in quell area. A seguito di quanto indicato in 4), NON E CORRETTO far restituire da una funzione il puntatore ad una variabile locale dichiarata nel blocco di codice della funzione stessa.

2 #include <stdlib.h> #define VAL 41 #define NUM 100 int *InizializzaInt(void); int *InizializzaArray(void); int * inizializzaint(void) {int valore; printf( Inizializzo una variabile\n ); valore=rand()%val; return (&valore);} int * inizializzaarray(void) {int valore[num]; int i; printf( Inizializzo un array\n ); for(i=0;i<num;i++) valore[i]=rand()%val; return valore;} Queste sono variabili locali, la loro durata coincide con la durata dell esecuzione della funzione. Quando la funzione termina la sua esecuzione, non è più garantito né l accesso all area né che i valori della variabili rimangano tali.

3 Per avere a disposizione aree di memoria di durata arbitraria: void *malloc(size_t dimensione); // size_t è un unsigned int Restituisce un valore di tipo void * in quanto malloc() permette di richiedere l autorizzazione ad accedere ad aree di memoria che possono contenere elementi aventi un tipo arbitrario; è buona norma, con un CAST ESPLICITO, trasformare il valore di tipo void * nel tipo di puntatore da utilizzare per l accesso all area allocata. Se l allocazione ha successo restituisce l indirizzo del primo elemento dell area; restituisce un valore pari a NULL se l allocazione non ha successo. void free(void *); libera un area di memoria precedentemente allocata con malloc(); in questo modo la durata dell area di memoria viene decisa dal programmatore. Gli accessi all area allocata con malloc() sono autorizzati fino al momento in cui non viene richiamata questa funzione; se il programmatore non invoca free(), l area viene automaticamente liberata al termine dell esecuzione del programma.

4 Esempio / versione corretta della funzioni implementate qualche lucido fa... #include <stdlib.h> #include <stdio.h> #define VAL 41 #define NUM 100 La sua dimensione può essere scelta in fase di esecuzione, non necessariamente in fase di compilazione funzioni.h int *InizializzaInt(void); int *InizializzaArray(void); CAST ESPLICITO int * inizializzaint(void) {int *valore; printf( Inizializzo una variabile, dopo aver allocato DINAMICAMENTE l area di memoria che la contiene\n ); valore = (int *) malloc(sizeof(int)); // l area di memoria deve contenere 1 intero if(valore==null) {printf( Area non allocata!\n ); exit(0);} // la funzione provoca la terminazione del programma exit(0) equivale a exit(exit_success) *valore=rand()%val; return valore;} int * inizializzaarray(void) {int *valore; int i; printf( Alloco in modo dinamico un area di memoria e poi la inizializzo\n ); valore = (int *) malloc(num*sizeof(int)); // l area di memoria deve contenere un numero di interi pari a NUM if(valore==null) {printf( Area non allocata!\n ); exit(0);} for(i=0;i<num;i++) *(valore+i)=rand()%val; return valore;}

5 #include funzioni.h codice.c int main() {int *variabile,*vettore; int i; variabile = InizializzaInt(); vettore = InizializzaArray(); printf( Ecco il valore della variabile: %d \n, *variabile); // stdio.h è incluso in funzioni.h printf( Ecco gli elementi dell array:\n ); for(i=0;i<num;i++) // NUM è definito in funzioni.h {printf( Indice: %d, valore: %d\n,i,vettore[i]); return 0;} OK le operazioni di allocazione e gestione delle aree di memoria possono essere delegate completamente alle funzioni, in modo da rendere il codice modulare e di facile lettura KO nel main è disponibile la variabile che permette l accesso all area di memoria allocata, quindi in caso di errori d accesso possiamo compromettere i valori memorizzata dell area stessa. Cerchiamo di rendere la gestione dell area ancora più svincolata da main()

6 #include <stdlib.h> #include <stdio.h> #define VAL 41 #define NUM 100 funzioni.h #include funzioni.h codice.c int *InizializzaInt(void); void InizializzaArray(void); void StampaArray(void); int *area; int * inizializzaint(void) {int *valore; valore = (int *) malloc(sizeof(int)); if(valore==null) {printf( Area non allocata!\n ); exit(0);} *valore=rand()%val; return valore;} void inizializzaarray(void) {int i; area = (int *) malloc(num*sizeof(int)); if(area==null) {printf( Area non allocata!\n ); exit(0);} for(i=0;i<num;i++) *(area+i)=rand()%val;} void StampaArray(void) {int i; for(i=0;i<num;i++) printf( indice: %d / valore: %d\n,i,*(area+i)); } int main() {int *variabile; int i; variabile = InizializzaInt(); InizializzaArray(); // il valore della variabile è accessibile da main() e quindi // modificabile da qui printf( Ecco il valore : %d \n, *variabile); /* l array di interi non è modificabile da main() in quanto il puntatore viene gestito completamente all interno del file funzioni.h */ StampaArray(); return 0;} Questo non è del tutto corretto; essendo area una variabile globale, essa è visibile a tutto il codice, quindi anche a main(). In futuro, per rendere questa affermazione corretta, dovremmo cambiare la classe di memorizzazione della variabile area al fine di renderla inaccessibile a main().

7 Nota: fino ad ora la sintassi con cui abbiamo utilizzato la direttiva #include è stata scelta in base al tipo di file che volevamo includere. #include <nomefile.h> #include nomefile.h // per i file della libreria standard // per i file preparati da noi Possiamo uniformare la sintassi? CERTO! E possibile includere QUALSIASI file con la sintassi #include <nomefile.h> (a patto di specificare quale sia la posizione del file su disco) La collocazione dei file della libreria standard è automaticamente definita, mentre quella dei file preparati dal programmatore non è detto sia nota a priori. Per indicare la posizione di tali file è sufficiente utilizzare una nuova opzione del compilatore gcc o nome_programma Wall I./ nome_codice.c -I opzione che specifica la posizione dei file da Inlcudere./ nella sintassi del sistema operativo,. rappresenta la directory corrente nel caso il file da includere si trovi nella directory /home/studente/include gcc o nome_programma Wall I/home/studente/include nome_codice.c

8 Esempio: usiamo l allocazione dinamica per gestire l input immesso dall utente. Si supponga di voler leggere una frase immessa da tastiera, di voler determinare di quante parole sia composta e di volerla crittografare. Obiettivi: (1) si deve poter memorizzare dei caratteri -> si necessita di un array di char (una stringa) (2) si devono contare quante parole ha immesso l utente -> devo distinguere una parola dall altra (3) si deve crittografare il testo -> si necessita di un algoritmo che consenta di accedere ad un area di memoria e di modificare i valori memorizzati in tale area (1) in main deve essere disponibile un array di char opportunamente dimensionato (2) serve una funzione che riconosca spazi, apostrofi (supponiamo non vengano introdotti altri caratteri di punteggiatura) (3) uso l algoritmo di Cesare (versione 2.0)

9 L algoritmo per crittografare una stringa Implementiamo una funzione che permetta di crittografare una stringa inserita dall utente. La funzione deve ricevere come parametro un puntatore a char e non restituire alcun valore. Per cifrare il testo usiamo un meccanismo simile al cifrario di Cesare. a b c d e f g h i j k l m n o p q r s t u v w x y z d e f g h i j k l m n o p q r s t u v w x y z a b c lettere in chiaro dopo aver cifrato il messaggio shift di 3 posizioni casa fdvd Noi abbiamo un pc ed un compilatore e sappiamo programmare, quindi possiamo fare degli shift variabili! Usando la funzione rand(), ad ogni lettera possiamo associare uno shift diverso! Inoltre, possiamo applicare uno shift a TUTTI i caratteri, non solo alle lettere minuscole.! # $ % &... { } ~ caratteri codici ASCII

10 #include <stdio.h> #include <stdlib.h> #define NUM 50 void crittografa(char *); void decodifica(char*); int main() {char stringa[num]; printf( Inserisci del testo: (meno di %d caratteri),num); scanf( %s,stringa); crittografa(stringa); printf( ecco la nuova stringa: %s\n,stringa); return 0;} void crittografa(char *stringa) {char *indice; indice = stringa; // potevo usare la variabile stringa come indice? while(*indice!=0) {*indice = ((*indice -32) + rand()%21 )%( )+32; indice++;} } void decodifica(char *stringa) {... come sarà il codice di questa funzione?... }

11 #include <stdio.h> #include <stdlib.h> #define NUM 100 char *LeggiInput(void); int separatore(char); char *crittografa(char *); char *ContaParole(char*); funzioni.h LINE è una MACRO che contiene il numero della riga del codice sorgente char *LeggiInput(void) {char *lettura,*finale; int num,i; lettura=(char*)malloc(num*sizeof(char)); if(lettura==null) {printf( allocazione fallita linea: %d\n, LINE ); exit(0);} printf( Inserisci delle parole (max 100 caratteri); scanf( %s,lettura); num=strlen(lettura); finale=(char *)malloc((num+1)*sizeof(char)); if(finale==null) {printf( allocazione fallita linea: %d\n, LINE ); exit(0);} Per utilizzare solo la memoria effettivamente necessaria al funzionamento del programma, prima viene allocata un area di memoria per contenere l input, poi si alloca una nuova area di dimensione pari a quella richiesta per memorizzare tutti e soli i caratteri inseriti. while(i<=num) // così copio anche il terminatore {*(finale+i) = *(lettura+i); i++;} free(lettura); return finale; } continua nella prossima pagina

12 int separatore(char a) {int temp; if((a== ) (a == )) temp = 1; else temp = 0; return temp; } funzioni.h char *ContaParole(char *stringa) {int numparole=0,i; for(i=0;i<strlen(stringa);i++) {if( separatore(*(stringa+i)) numparole++; } printf( Sono state inserite %d parole\n,numparole); return stringa; } char *crittografa(char *stringa) {char *indice; indice = stringa; // potevo usare la variabile stringa come indice? while(*indice!=0) {*indice = ((*indice -32) + rand()%21 )%( )+32; indice++;} return stringa; } #include <funzioni.h> // usare I per gcc int main() // versione 1.0 {char *parole; parole=leggiinput(); ContaParole(parole); crittografa(parole); printf( Le parole crittografate: \n %s\n,parole); return 0;}

13 Le funzioni di accesso all area contenente le parole inserite dall utente restituiscono il valore del puntatore che ricevono come parametro. Come sfrutto questa caratteristica? #include <funzioni.h> // usare I per gcc int main() // versione 2.0 {char *parole; parole=crittografa(contaparole(leggiinput())); printf( Le parole crittografate: \n %s\n,parole); return 0;} Le funzioni di accesso all area contenente le parole inserite possono essere annidate una dentro l altra, in modo che il valore restituito da una possa subito essere passato alla successiva.