Breve riepilogo della puntata precedente:

Transcript

1 Breve riepilogo della puntata precedente: 1. In C, il passaggio dei parametri alle funzioni avviene sempre per copia, ovvero il valore del parametro viene copiato all'interno della variabile che rappresenta il parametro stesso nel codice di implementazione della funzione. Per una singola variabile, la COPIA del valore del parametro richiede un numero di byte pari al valore da copiare; per un parametro di tipo int, quindi, sono richiesti 4 Byte. Nel caso in cui sia necessario passare ad una funzione un intero array, le cose si complicano un po', in quanto il quantitativo di memoria richiesta per effettuare la COPIA del parametro può diventare significativo. Ad esempio, un array di 100 double occupa 800 Byte, una tabella che rappresenta un'immagine può raggiungere alcuni MByte. Un metodo per risparmiare memoria ed evitare copie è quello di utilizzare come parametro della funzione non più il valore (o i valori) che intendiamo far conoscere alla funzione ma la posizione che tali valori hanno all'interno della memoria, ovvero passare alla funzione una variabile di tipo puntatore. In questo modo sia il passaggio di una variabile di tipo int che il passaggio di un array di int che il passaggio di un array di double richiederanno lo stesso quantitativo di memoria, ovvero quella richiesta per copiare il valore di una variabile di tipo puntatore (4 Byte). Domandona: Secondo quanto detto sopra, sembra che la scelta di passare un array ad una funzione mediante un puntatore sia giustificata solo dal risparmio, in termini di memoria, che tale scelta comporta. E' proprio così? 2. Vantaggi e svantaggi del passare un puntatore ad una funzione Utilizzo poca memoria per il passaggio dei valori delle variabili Permetto ad una funzione di modificare il valore di una variabile Si possono avere modifiche accidentali del valore di una variabile Non posso usufruire dei cast impliciti

2 Cosa significa l'ultima affermazione? Confrontiamo due funzioni #include <stdio.h> void funzione_di_prova(int); int main() {float c = 4.5; funzione_di_prova(c); return 0; void funzione_di_prova(int a) {a = a+3; printf("\n il valore e\' %d",a); #include <stdio.h> void funzione_di_prova(int*); int main() {float c = 4.5; funzione_di_prova(&c); return 0; void funzione_di_prova(int *b) {*b = *b + 3; printf("\n il valore e\' %d", *b); Ecco l'output il valore e' 7 Ecco l'output il valore e' viene effettuato un cast implicito per convertire il valore del parametro da float il parametro viene interpretato come int -> perdita di cifre significative no problem viene effettuato un cast implicito per convertire il valore del parametro da float* il parametro viene interpretato come int* -> può cambiare il numero totale di byte letti e cambia l'interpretazione dei bit pericoloso! da evitare!

3 Supponiamo di avere a disposizione un gruppo di 8 byte, contigui. Tali 8 byte possono essere pensati come ad un double o come ad un array di 8 char. Quindi mi posso muovere al loro interno sia pensando che ci sia un solo numero in virgola mobile o 8 interi da 8 bit. /* esempio: una copia di un double effettuata in modo un po' strano... */ #include <stdio.h> int main() {double doub1,doub2; /* creo due aree di memoria da 8 byte */ char *ptchar1,*ptchar2; /* ecco i puntatori che servono per scorrerle byte a byte */ int i; doub1 = ; ptchar1=(char*) &doub1; /* cast ESPLICITO! */ for(i=0;i<8;i++) printf("%d",*(ptchar + i)); /* visualizzo i valori dei singoli Byte */ ptchar2 = (char*) &doub2; for(i=0;i<8;i++) *(ptchar2+i) = *(ptchar1 + i);

4 printf("\n %f %f",doub1,doub2); return 0; /* fine esempio */ Provate a visualizzare l'output di questo codice! Le stringhe Le stringhe sono un particolare tipo di array di char in quanto, diversamente dagli array convenzionali, è possibile conoscerne la lunghezza; essendo le stringhe degli array, la loro gestione, da parte della libreria standard, viene effettuata SOLO MEDIANTE PUNTATORI A CHAR. Convenzionalmente, si assume che 1. la stringa inizi in corrispondenza del carattere cui fa riferimento il puntatore utilizzato per identificare la stringa stessa 2. la stringa termini quando, al suo interno, si incontra il carattere '\0', cioè il carattere avente codice ASCII nullo. Le funzioni della libreria standard, i cui prototipi si trovano all'interno del file string.h, considerano solo i caratteri dell'intero vettore che vanno dall'inizio della stringa fino al carattere di terminazione.

5 NOTA: la fine della stringa non coincide sempre con la fine dell'array di char. La stringa termina quando incontriamo il carattere con codice ASCII nullo mentre l'array termina quando arriviamo all'ultimo elemento. indice : valore dell'elemento : c i a o \0 c i a o! Per le funzioni della libreria standard la stringa termina alla posizione 4 nonostante l'array di char sia composto in totale da 10 caratteri. Utilizzando un opportuno specificatore di formato, %s, è inoltre possibile inserire i caratteri digitati sulla tastiera direttamente all'interno di una stringa: /* inizio codice */ #include <stdio.h> int main() {char stringa[40]; printf("\n inserisci dei caratteri, non più di 39!"); /* ci vuole spazio per il terminatore */ scanf("%s",stringa); /* passo a scanf() il puntatore all'array di char */ /* il carattere con codice ASCII nullo viene inserito automanticamente da scanf() */ printf("\n ecco la stringa inserita dall'utente: %s",stringa); return 0; /* fine codice */ 1. Attenzione: evitiamo gli accessi illegali alla memoria! Controllare SEMPRE di avere spazio a sufficienza per memorizzare i caratteri inseriti dall'utente

6 Nell'esempio visto prima, se l'utente inserisce 50 caratteri vengono superati i limiti dell'array e si accede ad aree della memoria in cui non siamo autorizzati a scrivere. In generale, quindi, sovradimensionare gli array che servono per accettare input. 2. Non usare MAI dei puntatori non inizializzati /* inizio esempio */ #include <stdio.h> int main() {char *stringa; printf("\n inserisci dei caratteri!"); scanf("%s",stringa); /* passo a scanf() il puntatore a char */ /* accesso illegale alla memoria!!! il puntatore non è stato inizializzato */ printf("\n ecco la stringa inserita dall'utente: %s",stringa); return 0; /* fine esempio */ Ecco alcune delle funzioni appartenenti alla libreria standard che possono essere utilizzate per la gestione delle stringhe int strlen(char *s) la funzione restituisce un numero intero pari al numero di caratteri che compongono la stringa s (ovvero il numero di caratteri che sta prima di quello nullo) char * strcpy(char*s1,char*s2) la funzione copia la stringa s2 all'interno di s1 e restituisce poi la stringa s1 (s1 deve essere abbastanza grande da contenere s2). Anche il carattere nullo viene copiato in s1. int strcmp(char*s1,char*s2)

7 la funzione confronta la stringa s1 con la stringa s2. il valore restituito è: negativo se, secondo l'ordine alfabetico, s1 viene prima di s2; zero se le due stringhe coincidono; positivo se, secondo l'ordine alfabetico, s1 viene dopo s2. int strncmp(char*s1,char*s2,int n) la funzione confronta al massimo n caratteri della stringa s1 con quelli della stringa s2. il valore restituito è: negativo se, secondo l'ordine alfabetico, la porzione di s1 viene prima di quella di s2; zero se le due stringhe coincidono; positivo se, secondo l'ordine alfabetico, la porzione di s1 viene dopo quella di s2. /* Breve esempio di utilizzo */ #include <string.h> #include <stdio.h> #define DIM 50 int main() {char parola[dim]; /* costruisco una stringa non inizializzata */ int lunghezza, confronto; strcpy( parola, "ecco una stringa costante 3987 #()$(#*@ " ); /* inizializzo la stringa copiando all'interno della stringa parola una stringa costante (ovvero un gruppo di caratteri circondato da DOPPI apici) */ printf("\n ecco la stringa inizializzata: %s",parola); lunghezza = strlen ( parola ); printf("\n l'array di char contiene %d caratteri, la stringa ne occupa %d",dim,lunghezza); /* confronto la stringa parola con una stringa costante */ confronto = strcmp( parola, "ecco" ); printf("\n il risultato del confronto: %d",confronto); /* ripeto il confronto, limitando il numero di caratteri letti */ confronto = strncmp( parola, "ecco", 4); printf("\n il risultato del nuovo confronto: %d",confronto); return 0; /* fine esempio */ Ecco l'output:

8 ecco la stringa inizializzata: ecco una stringa costante l'array di char contiene 50 caratteri, la stringa ne occupa 40 il risultato del confronto: 1 il risultato del nuovo confronto: 0 Usiamo ora le funzioni di libreria per preparare un programma che: 1. consenta all'utente di inserire una stringa di testo 2. determini la lunghezza della stringa di testo 3. verifichi se l'articolo "il" compaia o meno nella stringa inserita dall'utente e determini quante volte tale articolo sia presente all'interno della stringa (-> funzione) 4. analizzi i caratteri che compongono la stringa (-> funzione basata su analisi_carattere()) Iniziamo dalle funzioni (3) prepariamo una funzione che verifichi se l'articolo "il" compaia o meno nella stringa inserita dall'utente e determini quante volte tale articolo sia presente all'interno della stringa La funzione deve analizzare una stringa, essa quindi necessita di un unico parametro che permetta di identificare univocamente la stringa stessa, ovvero un puntatore a char.

9 Una volta determinato se "il" compaia o meno nella stringa, la funzione deve restituire il numero di occorrenze dell'articolo; il valore restituito dalla funzione sarà perciò di tipo int. prototipo: int CercaArticolo(char *); /* prima versione */ int CercaArticolo(char *stringa) {int occorrenze = 0; /* questa è la variabile che serve a contare il numero di volte che l'articolo "il" compare all'interno della stringa */ char pattern[3]; strcpy(pattern, "li" ); if( strncmp(stringa, pattern, 2) ) {occorrenze ++; /* sarebbe stato equivalente scrivere if( strncmp(stringa, "li", 2) ) {occorrenze ++; */ return occorrenze; /* questo confronto, però, funziona solo nel caso in cui la stringa che la funzione riceve come parametro sia, ad esempio : "il cane dei vicini abbaia". ma se il parametro è : "è quello il cane che abbaia" allora tale criterio di ricerca non va bene, in quanto non riconosce la presenza della coppia di caratteri "il" */ Per cercare bene in tutta la stringa devo spostarmi all'interno della stringa; è quindi necessario che il confronto venga fatto ridefinendo l'inizio della stringa

10 char prova[30]; strcpy(prova, "ecco alcuni termini di prova"); printf("\n%s",prova); /* visualizza "ecco alcuni termini di prova" */ printf("\n%s",prova + 5); /* visualizza "alcuni termini di prova" */ printf("\n%s",prova + 12); /* visualizza "termini di prova" */ Il puntatore rappresenta, quindi, una sorta di indice con cui scorrere la stringa. L'elemento cui fa riferimento il puntatore rappresenta l'inizio effettivo della stringa (per le funzioni di accesso della libreria standard) /* seconda versione */ int CercaArticolo(char *stringa) {int occorrenze = 0; /* questa è la variabile che serve a contare il numero di volte che l'articolo "il" compare all'interno della stringa */ int i; char pattern[3]; strcpy(pattern, "li" ); /* devo scorrere la stringa fino a quando il numero di caratteri di cui è composta è sufficiente ad effettuare il confronto*/ for( i = 0; i < ( strlen(stringa)-strlen(pattern) ); i++) { if( strncmp(stringa + i, pattern, 2) ) {occorrenze ++; return occorrenze;... chiaramente usando questo metodo la stringa "il cane abbaia al gatto smilzo"

11 contiene 2 occorrenze dell'articolo "il"... (4) prepariamo una funzione che analizzi i caratteri presenti nella stringa La funzione necessita di un solo parametro, ovvero la stringa da analizzare, e non deve restituire alcun valore, in quanto il risultato dell'analisi di ciascuno dei caratteri verrà visualizzato utilizzando la funzione analisi_carattere() preparata alcune lezioni fa. Prototipo: #include <mie_funzioni.h> void analizza_stringa(char*); /* versione 1 */ void analizza_stringa(char* parola) {int i; /* indice da utilizzare per scorrere la stringa */ for(i = 0; i < strlen(parola); i++) {analisi_carattere(parola[i]); /* versione 2: il valore logico di 0 e' FALSO. Il ciclo si ferma quando viene incontrato il carattere con codice ASCII nullo */ void analizza_stringa(char* parola) {int i; /* indice da utilizzare per scorrere la stringa */ for(i = 0; parola[i] ; i++) {analisi_carattere(parola[i]);

12 /* versione 3: anche il puntatore può essere pensato come un indice da incrementare ad ogni iterazione... */ void analizza_stringa(char* parola) { for( ; *parola ; parola++) {analisi_carattere(*parola); /* in questa implementazione ho modificato il valore del puntatore!! è pericoloso agire in questo modo??? */ /* versione 4: usiamo l'implementazione ricorsiva */ la funzione richiama se stessa fino a quando non viene individuata la condizione di fine della procedura ricorsiva la condizione che determina la fine della procedura ricorsiva è: ho incontrato il carattere con codice ASCII nullo

13 void analizza_stringa(char* parola) {if ( *parola ) {analisi_carattere(*parola) ; analizza_stringa(parola+1); /* ecco il codice */ #include <string.h> #include <stdio.h> #include <mie_funzioni.h> #define DIM 50 int CercaArticolo(char *); void analizza_stringa(char*); int main() {char parola[dim]; /* costruisco una stringa non inizializzata */ int lunghezza; int occorrenze; printf("\n inserisci una stringa contenente non più di 30 caratteri"); scanf("%s",parola); lunghezza = strlen ( parola ); printf("\n l'array di char contiene %d caratteri, la stringa ne occupa %d",dim,lunghezza); /* cerco nella stringa parola le occorrenze dell'articolo "il"*/ occorrenze = CercaArticolo(parola); printf("\n nella stringa sono state trovate %d occorrenze ",occorrenze); /* in alternativa, sfruttando il valore restituito dalla funzione */ printf("\n nella stringa sono state trovate %d occorrenze ",CercaArticolo(parola)); /* analizzo la stringa, carattere per carattere */ analizza_stringa(parola); return 0; int CercaArticolo(char *stringa)

14 {int occorrenze = 0; int i; char pattern[3]; strcpy(pattern, "li" ); for( i = 0; i < ( strlen(stringa)-strlen(pattern) ); i++) { if( strncmp(stringa + i, pattern, 2) ) {occorrenze ++; return occorrenze; void analizza_stringa(char* parola) {if ( *parola ) {analisi_carattere(*parola) ; analizza_stringa(parola+1); /* fine esempio */ Esercizio: Implementare una funzione che accetti come parametro un puntatore a char e che restituisca un numero intero. La funzione deve inizialmente determinare la lunghezza della stringa e poi visualizzare tale valore. Essa deve poi scorrere, carattere per carattere, la stringa cui fa riferimento il puntatore che riceve come parametro; se un carattere è una lettera minuscola, allora la lettera deve diventare maiuscola; se un carattere è una lettera maiuscola, allora la lettera deve diventare minuscola; tutti gli altri caratteri devono essere sostituiti con il carattere ' ' (spazio). Terminato questo controllo, la funzione deve restituire un valore pari al numero di sostituzioni effettuate. Implementare una funzione che accetti come parametro due stringhe e che restituisca un valore di tipo intero. La funzione deve determinare se la seconda stringa sia presente o meno all'interno della prima; nel caso in cui tale condizione sia verificata, TUTTI i caratteri della prima stringa che compongono una sottostringa uguale alla seconda devono essere sostituiti con degli asterischi.

15 Ad esempio, se i parametri sono "la casa del vicino e' bella ma piccola" "la" il risultato deve essere "** casa del vicino e' bel** ma picco**" Il valore da restituire deve essere pari al numero di sostituzioni effettuate