Prof.ssa Chiara Petrioli -- Fondamenti di programmazione, a.a. 2009/2010 Corso di Fondamenti di...

Prof.ssa Chiara Petrioli -- Fondamenti diProf.ssa Chiara Petrioli -- Fondamenti di programmazione, a.a. 2009/2010 programmazione, a.a. 2009/2010

Corso di Fondamenti di Corso di Fondamenti di programmazioneprogrammazione

a.a.2009/2010a.a.2009/2010Prof.ssa Chiara PetrioliProf.ssa Chiara Petrioli

Corso di Laurea in InformaticaCorso di Laurea in InformaticaUniversità degli Studi “La Sapienza”Università degli Studi “La Sapienza”

(lezioni 8 e 9)(lezioni 8 e 9)Matrici e stringhe


Array n-dimensionaliArray n-dimensionali

I vettori possono avere più di un indice I vettori possono avere più di un indice possono ad esempio memorizzare i valori di tabelle possono ad esempio memorizzare i valori di tabelle costituite da un certo numero di righe e colonnecostituite da un certo numero di righe e colonne

Es. temperature dei giorni dell’ultima settimana1 riga per ogni giornoUna colonna per ogni ora del giorno in cui si è presa la temperatura

Lun

Mar

Mer




Per individuare un particolare elemento della tabella bisogna specificaredue indiciindice di rigaindice di colonna

Es. a[0][1] specifica l’elemento nella riga 0

e nella colonna 1

Nome della matrice




Es. a[2][2] specifica l’elemento nella riga 2

e nella colonna 2

Nome della matrice

a[2][2]

I vettori che per identificare un particolare elemento richiedono due indici sonodetti vettori bidimensionali o matriciUna matrice con m righe e n colonne è detta matrice m x n


MatriciMatrici

a[i][j] identifica l’elemento della a[i][j] identifica l’elemento della matrice a in posizione (i,j)matrice a in posizione (i,j)

Dichiarazione di una variabile Dichiarazione di una variabile di tipo matricedi tipo matrice

int b[2][2]; int b[2][2]; /* b è una matrice /* b è una matrice di interi costituita da di interi costituita da

due righe due righe e due colonne */e due colonne */

Dichiarazione e Dichiarazione e inizializzazioneinizializzazione

int b[2][2]={{1,2},{3,4}};int b[2][2]={{1,2},{3,4}};

(in alternativa possiamo ad (in alternativa possiamo ad esempio prendere da input i esempio prendere da input i vari valori della matrice)vari valori della matrice)

Se non vengono forniti tuttiI valori di una riga i rimanentiSono inizializzati a 0

a[0][0]a[0][0] a[0][1]a[0][1] a[0][2]a[0][2] a[0][3]a[0][3]

a[1][0]a[1][0] a[1][1]a[1][1] a[1][2]a[1][2] a[1][3]a[1][3]

a[2][0]a[2][0] a[2][1]a[2][1] a[2][2]a[2][2] a[2][3]a[2][3]


Allocazione di memoria per matriciAllocazione di memoria per matrici

Elem 1 riga 1Elem 2 riga 1

Elem n riga 1

…..


Elem n riga 2

…..

…..Elem 1 riga mElem 2 riga m

Elem n riga m

…..

a[0][0]

Gli elementi della matrice sono memorizzati in celle consecutive di memoria,Una riga dopo l’altra


Allocazione di memoria per matriciAllocazione di memoria per matrici


Elem n riga 1

…..


Elem n riga 2

…..

…..Elem 1 riga mElem 2 riga m

Elem n riga m

…..

a[0][0]

Se a[0][0] memorizzato nella cella 1800 in che cella è memorizzato l’elemento i,j(assumendo una cella, un intero)?

&a[0][0] + (i*n)+ j

Serve conoscere il numero di colonne n per sapere in che cella trovare ungenerico elemento di una matrice !!


Un primo esempio..Un primo esempio..include <stdio.h>include <stdio.h>void printmatrice(int [ ][3]);void printmatrice(int [ ][3]);int main()int main(){{int matrix1[2][3]={{1,2,3},{4,5,6}};int matrix1[2][3]={{1,2,3},{4,5,6}};int matrix2[2][3]={1,2,3,4,5};int matrix2[2][3]={1,2,3,4,5};int matrix3[2][3]={{1,2},{4}};int matrix3[2][3]={{1,2},{4}};printmatrice(matrix1);printmatrice(matrix1);printmatrice(matrix2);printmatrice(matrix2);printmatrice(matrix3);printmatrice(matrix3);return 0;return 0;}}

1 2 34 5 6

1 2 34 5 0

1 2 04 0 0

IN OUTPUT

Serve indicare il numero di colonne perconsentire di saper trovare l’elemento (i,j)


Un primo esempio…Un primo esempio…

void printmatrice (int a[ ][3])void printmatrice (int a[ ][3]){{int i,j;int i,j;for (i=0; i<=1;i++)for (i=0; i<=1;i++)

{{for (j=0;j<=2;j++)for (j=0;j<=2;j++)

printf (“%d ”, a[i][j]);printf (“%d ”, a[i][j]);printf(“\n”);printf(“\n”);}}

print(“\n”);print(“\n”);} }


EsercizioEsercizio

Si scriva un programma che Si scriva un programma che – prenda da input per ciascuno studente di una prenda da input per ciascuno studente di una

classe il voto conseguito in ciascuno degli classe il voto conseguito in ciascuno degli esami dell’annoesami dell’anno

– calcoli e stampi il voto più basso e più alto tra calcoli e stampi il voto più basso e più alto tra quelli dei vari studenti e, per ciascuno quelli dei vari studenti e, per ciascuno studente,la media dei voti degli esami studente,la media dei voti degli esami dell’annodell’anno


SoluzioneSoluzione

#include <stdio.h>#include <stdio.h>

#define NUM_ESAMI 10#define NUM_ESAMI 10

#define ALUNNI 100#define ALUNNI 100

int minimum (int [ ][NUM_ESAMI],int,int);int minimum (int [ ][NUM_ESAMI],int,int);

int massimo (int [ ][NUM_ESAMI], int,int);int massimo (int [ ][NUM_ESAMI], int,int);

float media(int [ ][NUM_ESAMI],int,int);float media(int [ ][NUM_ESAMI],int,int);


SoluzioneSoluzionemain()main(){{int i,j;int i,j;int studentGrades[ALUNNI][NUM_ESAMI];int studentGrades[ALUNNI][NUM_ESAMI];for (i=0; i<ALUNNI;i++)for (i=0; i<ALUNNI;i++)

for (j=0;j<NUM_ESAMI;j++)for (j=0;j<NUM_ESAMI;j++){{printf(“inserisci voto %d esimo esame dell %d esimo alunno \printf(“inserisci voto %d esimo esame dell %d esimo alunno \n”, j,i);n”, j,i);scanf(“%d”, &studentGrades[i][j]);scanf(“%d”, &studentGrades[i][j]);}}

}}printf(“il voto più basso e il voto più alto sono: %d \n %d \n”, printf(“il voto più basso e il voto più alto sono: %d \n %d \n”,

minimum(studentGrades, ALUNNI, NUM_ESAMI), minimum(studentGrades, ALUNNI, NUM_ESAMI), massimo(studentGrades, ALUNNI, NUM_ESAMI)); massimo(studentGrades, ALUNNI, NUM_ESAMI));

for (i=0; i<ALUNNI;i++)for (i=0; i<ALUNNI;i++){{

printf (“la media dei suoi esami è %f\printf (“la media dei suoi esami è %f\n”,media(studentGrades, i, NUM_ESAMI));n”,media(studentGrades, i, NUM_ESAMI));}}

}}

Alunno che stiamoconsiderando


SoluzioneSoluzioneint minimum (int grades[ ][NUM_ESAMI],int alunni,int test)int minimum (int grades[ ][NUM_ESAMI],int alunni,int test){{

int i,j;int i,j;int lowgrade=100; /*upper bound del valore dei voti*/int lowgrade=100; /*upper bound del valore dei voti*/for (i=0; i<alunni; i++)for (i=0; i<alunni; i++){{

for (j=0; j<test;j++)for (j=0; j<test;j++){{

if (grades[i][j]<lowgrade)if (grades[i][j]<lowgrade)lowgrade=grades[i][j];lowgrade=grades[i][j];

}}}}

return lowgrade;return lowgrade;}}


SoluzioneSoluzioneint massimo (int grades[ ][NUM_ESAMI],int alunni,int test)int massimo (int grades[ ][NUM_ESAMI],int alunni,int test){{

int i,j;int i,j;int highgrade=0; int highgrade=0; for (i=0; i<alunni; i++)for (i=0; i<alunni; i++){{

for (j=0; j<test;j++)for (j=0; j<test;j++){{

if (grades[i][j]>highgrade)if (grades[i][j]>highgrade)highgrade=grades[i][j];highgrade=grades[i][j];

}}}}

return highgrade;return highgrade;}}


SoluzioneSoluzionefloat media (int grades[ ][NUM_ESAMI],int float media (int grades[ ][NUM_ESAMI],int

alunno,int test)alunno,int test){{

int j;int j;int total=0; int total=0; for (j=0; j<test;j++)for (j=0; j<test;j++)

{{total+=grades[alunno][j];total+=grades[alunno][j];

}}return (float) total / test;return (float) total / test;}}


PuntatoriPuntatori

I puntatori sono delle variabili che come I puntatori sono delle variabili che come valore contengono degli indirizzi di valore contengono degli indirizzi di memoriamemoriaint count;int count;

count contiene un count contiene un _valore__valore_ intero intero int *countPtr;int *countPtr;

La variabile countPtr contiene l’indirizzo La variabile countPtr contiene l’indirizzo di una locazione di memoria che contiene di una locazione di memoria che contiene un valore intero.un valore intero.

2340

countPtr

5 2340

Il nome di una variabile intera (es. count) fadirettamente riferimento ad un valore intero;Una variabile puntatore fa indirettamente riferimentoad un valore intero (deriferimento).

Variabili di tipo puntatore devono esseredichiarate e inizializzateEs.int * countPtr; /*dichiarazoine*/float * fcountPtr;

countPtr = &count; /*inizializzazione*/fcountPtr=NULL; /*NULL è una costante simbolica predefinitaIn molti file di intestazione incluso stdio.h. Se una variabile puntatore è inizializzata a NULL non punta ad alcuna locazione di memoria*/


Operatore di indirizzoOperatore di indirizzo

& (operatore unario di indirizzo) restituisce & (operatore unario di indirizzo) restituisce l’indirizzo di memoria associato al suo l’indirizzo di memoria associato al suo operando;operando;

int y=5;int y=5;

int *yPtr;int *yPtr;

yPtr=&y;yPtr=&y;

5 y3200


Operatore di indirizzoOperatore di indirizzo

& (operatore unario di indirizzo) restituisce & (operatore unario di indirizzo) restituisce l’indirizzo di memoria associato al suo l’indirizzo di memoria associato al suo operando;operando;

int y=5;int y=5;

int *yPtr;int *yPtr;

yPtr=&y;yPtr=&y;

5 y3200

Viene allocata memoria per la variabile puntatoreyPtr. Nella locazione di yPtr viene memorizzatol’indirizzo di memoria associato alla variabile y

yPtr3200

& deve essere applicato ad una variabile. Non Può essere applicato a costanti, espressioni oa variabili dichiarate con la specifica di classedi memoria register


Operatore di deriferimentoOperatore di deriferimento

L’operatore * (detto operatore di L’operatore * (detto operatore di deriferimentoderiferimento o di o di risoluzione dell’indirizzorisoluzione dell’indirizzo) ) consente di accedere al consente di accedere al valorevalore contenuto contenuto nella locazione di memoria puntata da una nella locazione di memoria puntata da una variabile puntatorevariabile puntatore


Operatore di deriferimentoOperatore di deriferimento

L’operatore * (detto operatore di L’operatore * (detto operatore di deriferimentoderiferimento o di o di risoluzione dell’indirizzorisoluzione dell’indirizzo) ) consente di accedere al consente di accedere al valorevalore contenuto contenuto nella locazione di memoria puntata da una nella locazione di memoria puntata da una variabile puntatorevariabile puntatore

5 y3200

yPtr3200

*yPtr è il valore contenuto nellalocazione di memoria il cui indirizzo è memorizzato in yPtr

5


EsempioEsempioLa specifica di conversione %pdi printf consente di stampare in output indirizzi di locazioni dimemoria

#include <stdio.h>main() {

int a;int *aPtr;a=7;aPtr=&a;

printf(“The address of a is %p \n The value of aPtr is %p \n\n,&a,aPtr”);printf(“The value of a is %d \n The value of *aPtr is %d \n\n,a,*aPtr”);

printf(“Proving that * and & are complements of each other \n”);printf(“&*aPtr=%p \n *&aPtr=%p \n”,&*aPtr,*&aPtr);return 0;

}


Precedenza degli operatoriPrecedenza degli operatori


Chiamata per riferimento delle Chiamata per riferimento delle funzionifunzioni

Come può essere realizzata in C?Come può essere realizzata in C?Se vogliamo poter modificare il contenuto Se vogliamo poter modificare il contenuto di una variabile x con cui invochiamo una di una variabile x con cui invochiamo una funzione e far sì che tali modifiche funzione e far sì che tali modifiche permangano anche all’uscita dalla permangano anche all’uscita dalla funzione possiamo usare come parametro funzione possiamo usare come parametro formale un puntatore (quindi passare lalla formale un puntatore (quindi passare lalla funzione l’indirizzo di x)…funzione l’indirizzo di x)…Un esempio..Un esempio..


EsempioEsempio/*eleva al cubo una variabile usando una chiamata per /*eleva al cubo una variabile usando una chiamata per

valore*/valore*/#include <stdio.h>#include <stdio.h>int cubeByValue(int);int cubeByValue(int);int main()int main(){{

int number =5;int number =5;printf(“Il valore originale del numero è: %d\n”,number);printf(“Il valore originale del numero è: %d\n”,number);number=cubeByValue(number);number=cubeByValue(number);printf(“il nuovo valore del numero è: %d\n”,number);printf(“il nuovo valore del numero è: %d\n”,number);return 0;return 0;

}}int cubeByValue(int n)int cubeByValue(int n){{

return n*n*n;return n*n*n;}}

Il valore originale del numero è: 5Il nuovo valore del numero è: 125


Cosa succede in memoria…Cosa succede in memoria…


Esempio 2Esempio 2/*eleva al cubo una variabile usando una chiamata per /*eleva al cubo una variabile usando una chiamata per

riferimento*/riferimento*/#include <stdio.h>#include <stdio.h>voidvoid cubeByReference(int *); cubeByReference(int *);int main()int main(){{

int number =5;int number =5;printf(“Il valore originale del numero è: %d\n”,number);printf(“Il valore originale del numero è: %d\n”,number);cubeByReference(&number);cubeByReference(&number);printf(“il nuovo valore del numero è: %d\n”,number);printf(“il nuovo valore del numero è: %d\n”,number);return 0;return 0;

}}void cubeByReference(int *nPtr)void cubeByReference(int *nPtr){{

*nPtr=(*nPtr)*(*nPtr)*(*nPtr);*nPtr=(*nPtr)*(*nPtr)*(*nPtr);}}

Il valore originale del numero è: 5Il nuovo valore del numero è: 125


Cosa succede in memoria…Cosa succede in memoria…int number=5;cubeByReference(&number);cubeByReference(&number);

5number 6200



5number 6200

void cubeByReference(int *nPtr)void cubeByReference(int *nPtr){{


Invochiamo la funzione cubeByReference

Viene allocata memoriaper la variabile puntatorenPtr

Viene copiato in nPtr il valoredell’argomento con cui è statainvocata la funzione&number OVVERO l’indirizzodella locazione di memoria dellavariabile number OVVERO 6200

6200



5number 6200




6200

Si esegue l’istruzione*nPtr=(*nPtr)*(*nPtr)*(*nPtr);*nPtr=(*nPtr)*(*nPtr)*(*nPtr);

*nPtr è il valore contenutonella locazione di memoria puntata da nPtr 5

L’istruzione quindi dice dielevare al cubo 5 e di memorizzareil valore risultante nella locazione dimemoria puntata da nPtr



5number 6200




6200

L’istruzione quindi dice dielevare al cubo 5 e di memorizzareil valore risultante nella locazione dimemoria puntata da nPtr

Il cubo di 5 è 125125


Cosa succede in memoria…Cosa succede in memoria…int number=5;cubeByReference(&number);cubeByReference(&number);printf(“il nuovo valore del numero è: printf(“il nuovo valore del numero è: %d\n”,number);%d\n”,number);return 0;return 0;

5number 6200



Si ritorna il controllo al main che esegue la prossima istruzione

6200

Si stampa il valore di number 125

La memoria allocata per nPtr viene rilasciata

125


Cosa succede in memoria…Cosa succede in memoria…

Passaggio per valore evita di compromettere i valori delle variabilicon cui sono invocate le funzioni (spesso non si vogliono modificaretali valori)Passaggio parametri per riferimento evita di dover allocare, ad ogni invocazionedi funzione, memoria per copiare quantità di dati di input grandi che possono dover essere passati alla funzioneesempio: se la funzione ha come input un vettore abbiamo bisognosolo di un parametro di tipo puntatore in cui copiare la locazione dimemoria associata al primo elemento del vettore


Qualificatore constQualificatore const

Consente di specificare che il valore di una Consente di specificare che il valore di una particolare variabile NON dovrà essere particolare variabile NON dovrà essere modificatomodificatoIl compilatore intercetterà qualsiasi tentativo di Il compilatore intercetterà qualsiasi tentativo di modificare una variabile che sia stata dichiarata modificare una variabile che sia stata dichiarata const e, nel caso in cui tale variabile sia const e, nel caso in cui tale variabile sia modificata, darà un errore o un warning.modificata, darà un errore o un warning. serve a proteggere da errori serve a proteggere da errori nell’implementazione del codicenell’implementazione del codice rendere più rendere più facile il debuggingfacile il debugging


Modi di passare un puntatore a una Modi di passare un puntatore a una funzionefunzione

‘‘Puntatore variabile a dati variabili’Puntatore variabile a dati variabili’– i dati possono essere modificati attraverso il i dati possono essere modificati attraverso il

puntatorepuntatore– Il valore della variabile puntatore potrà essere Il valore della variabile puntatore potrà essere

modificato in modo che il puntatore possa fare modificato in modo che il puntatore possa fare riferimento ad altri datiriferimento ad altri dati


EsempioEsempio#include <stdio.h>#include <stdio.h>void convertToUppercase (char *);void convertToUppercase (char *);main()main(){{

char string[ ]=“caratteri”;char string[ ]=“caratteri”;printf(“la stringa prima della conversione è %s\n”,string);printf(“la stringa prima della conversione è %s\n”,string);convertToUppercase(string); /*converte le lettere minuscole della stringa in maiuscole*/convertToUppercase(string); /*converte le lettere minuscole della stringa in maiuscole*/printf(“dopo la conversione la stringa è %s\n”,string);printf(“dopo la conversione la stringa è %s\n”,string);return 0;return 0;

}}

void convertToUppercase(char *s)void convertToUppercase(char *s){{

while (*s != ‘\0’)while (*s != ‘\0’){{

if (*s >= ‘a’ && *s<= ‘z’)if (*s >= ‘a’ && *s<= ‘z’)*s-=32;*s-=32;

++s;++s;}}

}} La stringa prima della conversione è:pippoDopo la conversione la stringa è PIPPO

Vengono modificati i caratteri dellaStringa. s punta a caratteri diversi della stringadurante l’esecuzione della funzione


Altri casi…Altri casi…Puntatore variabile a dati costanti (i dati non possono essere Puntatore variabile a dati costanti (i dati non possono essere modificati)modificati)

#include <stdio.h>#include <stdio.h>void printCharacters (void printCharacters (const char *);const char *);main()main(){{

char string [ ]=“stampa i caratteri”;char string [ ]=“stampa i caratteri”;printf (“la stringa è:\n”);printf (“la stringa è:\n”);printCharacters (string);printCharacters (string);putchar(‘\n’);putchar(‘\n’);return 0;return 0;

}}void printCharacters(const char *s)void printCharacters(const char *s){{

for (;*s!=‘\0’;s++)for (;*s!=‘\0’;s++)putchar(*s);putchar(*s);

}}la stringa è:

stampa i caratteri


Altri casi…Altri casi…

Puntatore costante a dati variabiliPuntatore costante a dati variabili– il puntatore fa sempre riferimento alla stessa il puntatore fa sempre riferimento alla stessa

locazione di memorialocazione di memoria– Tramite il puntatore si può cambiare il valore della Tramite il puntatore si può cambiare il valore della

locazione di memorialocazione di memoria

int *const ptr;int *const ptr;Puntatore costante a dati costantiPuntatore costante a dati costanti– il puntatore fa sempre riferimento alla stessa il puntatore fa sempre riferimento alla stessa

locazione di memorialocazione di memoria– Il valore della locazione di memoria non può essere Il valore della locazione di memoria non può essere

modificatomodificato

const int *const ptr;const int *const ptr;


EsempioEsempio

#include <stdio.h>#include <stdio.h>main ()main (){{

int x=5,y;int x=5,y;const int *const ptr=&x;const int *const ptr=&x;*ptr=7;*ptr=7; ptr=&y;ptr=&y; return 0;return 0;

}}

Cannot modify a const object

Cannot modify a const object


Bubblesort (versione 2)Bubblesort (versione 2)#include <stdio.h>#include <stdio.h>#define SIZE 10#define SIZE 10void bubbleSort(int *,const int);void bubbleSort(int *,const int);void swap (int *,int*);void swap (int *,int*);main()main(){{

int i,a[SIZE]={2,6,4,8,10,12,89,68,45,37};int i,a[SIZE]={2,6,4,8,10,12,89,68,45,37};printf(“ordine originale \n”);printf(“ordine originale \n”);for (i=0;i<=SIZE-1;i++)for (i=0;i<=SIZE-1;i++)

printf(“%d”,a[i]);printf(“%d”,a[i]);bubbleSort (a,SIZE);bubbleSort (a,SIZE);printf(“dati in ordine crescente \n”);printf(“dati in ordine crescente \n”);for (i=0;i<=SIZE-1;i++)for (i=0;i<=SIZE-1;i++)

printf(“%d”,a[i]);printf(“%d”,a[i]);printf(“\n”);printf(“\n”);return 0;return 0;

}}


BubblesortBubblesortvoid bubbleSort(int *array, const int size)void bubbleSort(int *array, const int size)

{{

int pass,j;int pass,j;

for (pass=1;pass <=size-1;pass++)for (pass=1;pass <=size-1;pass++)

for (j=0;j<=size-2;j++)for (j=0;j<=size-2;j++)

if(array[j]>array[j+1])if(array[j]>array[j+1])

swap(&array[j],&array[j+1]);swap(&array[j],&array[j+1]);

} }


SwapSwap

void swap (int *element1Ptr, int void swap (int *element1Ptr, int *element2Ptr)*element2Ptr)

{{int temp;int temp;temp=*element1Ptr;temp=*element1Ptr;*element1Ptr=*element2Ptr;*element1Ptr=*element2Ptr;*element2Ptr=temp;*element2Ptr=temp;

}}


Caratteri e stringheCaratteri e stringhe

Un carattere può essere visto come un interoUn carattere può essere visto come un interoHa associato un intero, il codice ASCII Ha associato un intero, il codice ASCII

corrispondentecorrispondente



Una stringa è un vettore di caratteri che termina Una stringa è un vettore di caratteri che termina con il carattere nullo ‘\0’con il carattere nullo ‘\0’

Inizializzazione di una stringaInizializzazione di una stringa

char color [ ]= “blue”;char color [ ]= “blue”;

char color [ ]={‘b’,’l’,’u’,’e’,’\0’};char color [ ]={‘b’,’l’,’u’,’e’,’\0’};

bb ll uu ee \0\0

La dimensione delvettore è determinataautomaticamente



Una stringa è un vettore di caratteri che termina Una stringa è un vettore di caratteri che termina con il carattere nullo ‘\0’con il carattere nullo ‘\0’

Inizializzazione di una stringaInizializzazione di una stringa

char word[20];char word[20];

printf (“inserisci stringa \n”);printf (“inserisci stringa \n”);

scanf(“%s”, word);scanf(“%s”, word);

bb ll uu ee \0\0

word indica l’indirizzo della cella di memoria in cui è memorizzato ilprimo elemento delvettore


Manipolazione dei caratteriManipolazione dei caratteriLibreria standard, header <ctype.h>Libreria standard, header <ctype.h>


Manipolazione dei caratteriManipolazione dei caratteri

Libreria standard, header <ctype.h>Libreria standard, header <ctype.h>


Sintesi ctype.hSintesi ctype.h



/*verifica se c è una cifra*//*verifica se c è una cifra*/int isdigit (int c) int isdigit (int c) {{

return ((c>=‘0’)&&(c<=‘9’));return ((c>=‘0’)&&(c<=‘9’));}}/*verifica se c è una lettera*//*verifica se c è una lettera*/int isalpha (int c) int isalpha (int c) {{

return (((c>=‘a’)&&(c<=‘z’))|| ((c>=‘A’)&&(c<=‘Z’)));return (((c>=‘a’)&&(c<=‘z’))|| ((c>=‘A’)&&(c<=‘Z’)));}}



/*restituisce la lettera minuscola corrispondente /*restituisce la lettera minuscola corrispondente se c è una maiuscola, l’argomento inalterato in se c è una maiuscola, l’argomento inalterato in caso contrario*/caso contrario*/

int tolower (int c) int tolower (int c)

{{

if isupper( c )if isupper( c )

c=c-’A’+’a’;c=c-’A’+’a’;

return c;return c;

}}


Utilizzo delle funzioni di libreria per Utilizzo delle funzioni di libreria per la manipolazione dei caratterila manipolazione dei caratteri

#include <stdio.h>#include <stdio.h>#include <ctype.h>#include <ctype.h>int main ( )int main ( ){{

printf(“%s\n%s%s\n%s%s\n%s%s\n%s%s\n\n”, “According to printf(“%s\n%s%s\n%s%s\n%s%s\n%s%s\n\n”, “According to islower:”,islower:”,islower(‘p’)?”p is a”: “p is not a ”,islower(‘p’)?”p is a”: “p is not a ”,““lowercase letter”,lowercase letter”,islower(‘P’)?”P is a”: “P is not a ”,islower(‘P’)?”P is a”: “P is not a ”,““lowercase letter”,lowercase letter”,islower(‘5’)?”5 is a”: “5 is not a ”,islower(‘5’)?”5 is a”: “5 is not a ”,““lowercase letter”,lowercase letter”,islower(‘!’)?”! is a”: “! is not a ”,islower(‘!’)?”! is a”: “! is not a ”,““lowercase letter”);lowercase letter”);))

}}

According to islower:According to islower:p is a lowercase letterp is a lowercase letterP is not a lowercase letterP is not a lowercase letter5 is not a lowercase letter5 is not a lowercase letter! Is not a lowercase letter ! Is not a lowercase letter

(espressione 1)?espressione2:espressione 3;


Esercizio 1Esercizio 1

/*calcola il numero di caratteri in una stringa*//*calcola il numero di caratteri in una stringa*//*Post: restituisce il numero di caratteri della /*Post: restituisce il numero di caratteri della

stringa (escluso il carattere di fine stringa */stringa (escluso il carattere di fine stringa */int sizestringa(char s[])int sizestringa(char s[]){{

int i=0;int i=0;while (s[i]!=‘\0’)while (s[i]!=‘\0’)

i++;i++;return i;return i;

}}


Esercizio 2Esercizio 2

/*individua la prima occorrenza del carattere c /*individua la prima occorrenza del carattere c nella stringa s. Restituisce l’indice di tale prima nella stringa s. Restituisce l’indice di tale prima occorrenza; -1 se il carattere c non compare*/occorrenza; -1 se il carattere c non compare*/

int stringchr (char s[ ], int c)int stringchr (char s[ ], int c){{

int i=0,int i=0,while ((s[i]!=c) && (s[i]!=‘\0’))while ((s[i]!=c) && (s[i]!=‘\0’))

i++;i++;return ((s[i]==‘\0’)?-1:i);return ((s[i]==‘\0’)?-1:i);

}}


Funzioni di libreria sulle stringheFunzioni di libreria sulle stringhe(funzioni per la conversione delle stringhe, stdlib.h)(funzioni per la conversione delle stringhe, stdlib.h)


Esempio di usoEsempio di uso


Funzioni di libreria sulle stringheFunzioni di libreria sulle stringhe(funzioni per la scrittura e lettura di caratteri e stringhe)(funzioni per la scrittura e lettura di caratteri e stringhe)


EsempioEsempio#include<stdio.h>#include<stdio.h>main()main(){{

char c, sentence[80];char c, sentence[80];int i=0;int i=0;puts (“Enter a line of text:”);puts (“Enter a line of text:”);while((c=getchar())!= ‘\n’)while((c=getchar())!= ‘\n’)

sentence[i++]=c;sentence[i++]=c;sentence[i]=‘\0’;sentence[i]=‘\0’;puts(“\n The line entered was:”);puts(“\n The line entered was:”);puts(sentence);puts(sentence);return 0;return 0;

}}

Enter a line of text:This is a test.

The line entered was:This is a test.


Manipolazione di stringheManipolazione di stringhe(string.h)(string.h)


EsempioEsempio


Esempio di usoEsempio di uso


Confronto tra stringheConfronto tra stringhe(string.h)(string.h)


Altre funzioni stringh.hAltre funzioni stringh.h(per un elenco completo vedere il Deitel&Deitel)(per un elenco completo vedere il Deitel&Deitel)


Funzioni di libreria sulle stringheFunzioni di libreria sulle stringhe(string.h--manipolazione delle stringhe e manipolazione (string.h--manipolazione delle stringhe e manipolazione

della memoria)della memoria)


Alcune funzioni della string.hAlcune funzioni della string.h

/*copia la stringa s2 nel vettore s1. Restituisce un puntatore al primo /*copia la stringa s2 nel vettore s1. Restituisce un puntatore al primo carattere della stringa*/carattere della stringa*/

/*Pre: dim del vettore s1 sufficienti per contenere s2*//*Pre: dim del vettore s1 sufficienti per contenere s2*//*Post: s1 contiene la stringa s2*//*Post: s1 contiene la stringa s2*/

void stringcopy(char *s1, char *s2)void stringcopy(char *s1, char *s2){{

for (;*s2 !='\0';s1++,s2++)for (;*s2 !='\0';s1++,s2++)*s1=*s2;*s1=*s2;

*s1='\0';*s1='\0';}}

strcpy


/*Post: confronta s1 e s2. Restituisce: -1 se s1 e' minore in ordine lessicografico di /*Post: confronta s1 e s2. Restituisce: -1 se s1 e' minore in ordine lessicografico di s2; 0 se sono uguali; 1 se s1 e' maggiore in ordine lessicografico di s2 */s2; 0 se sono uguali; 1 se s1 e' maggiore in ordine lessicografico di s2 */

int stringcmp(char *s1, char *s2)int stringcmp(char *s1, char *s2){{

while (*s1==*s2)while (*s1==*s2){{

if (*s1=='\0')if (*s1=='\0')return 0;return 0;

s1++;s1++;s2++;s2++;

}}if (*s1 == '\0')if (*s1 == '\0')

return -1;return -1;else if (*s2 == '\0')else if (*s2 == '\0')

return 1;return 1;elseelse

return (((*s1 - *s2)>0)?1:0);return (((*s1 - *s2)>0)?1:0);}}

Alcune funzioni della string.hAlcune funzioni della string.hstrcmp


SottostringaSottostringa/* Post: restituisce 1 se la prima stringa compare come sottostringa della seconda, 0 /* Post: restituisce 1 se la prima stringa compare come sottostringa della seconda, 0

altrimenti Se la prima stringa e' vuota restituisce 1 (una stringa vuota e' sottostringa di altrimenti Se la prima stringa e' vuota restituisce 1 (una stringa vuota e' sottostringa di q.siasi stringa Se la seconda stringa e' vuota e la prima no allora restituisce 0*/q.siasi stringa Se la seconda stringa e' vuota e la prima no allora restituisce 0*/

int findstr (char *s1, char *s2)int findstr (char *s1, char *s2){{

char *temp_s1;char *temp_s1;char *temp_s2;char *temp_s2;while (s2!='\0')while (s2!='\0'){{

temp_s2=s2;temp_s2=s2;temp_s1=s1;temp_s1=s1;while ((*s1 == *s2)&&(*s1!='\0')&&(*s2!='\0'))while ((*s1 == *s2)&&(*s1!='\0')&&(*s2!='\0')){{

s1++;s1++;s2++;s2++;

}}if (*s1=='\0')if (*s1=='\0')

return 1;return 1;else if (*s2=='\0')else if (*s2=='\0')

return 0;return 0;else else {{

s2=++temp_s2;s2=++temp_s2;s1=temp_s1;s1=temp_s1;

}}

}}return (s1=='\0');return (s1=='\0');

}}

Prof.ssa Chiara Petrioli -- Fondamenti di programmazione, a.a. 2009/2010 Corso di Fondamenti di...

Documents

Transcript of Prof.ssa Chiara Petrioli -- Fondamenti di programmazione, a.a. 2009/2010 Corso di Fondamenti di...