ELEMENTI DI INFORMATICA Università degli Studi di Cagliari Corso di Laurea in Ingegneria Elettronica ELEMENTI DI INFORMATICA http://agile.diee.unica.it A.A. 2011/2012 Ing. Giuseppe Destefanis Diee, secondo piano Tel. 070-6755774 mail: giuseppe.destefanis@diee.unica.it Linguaggio C

Operatori * e & Per ottenere l'indirizzo di una variabile si usa l'operatore di indirizzo “&”. Per accedere ad una variabile riferita da un puntatore si usa l'operatore di indirezione “*”.

Puntatori #include<stdio.h> int main() { int num=0; int *p; p=&num; printf("%d\n",num); //0 printf("%d\n",*p); //0 }

Puntatori 1 Dichiarare una variabile puntatore consente di allocare spazio in memoria per un puntatore. Con l'istruzione int *p; dichiaro un puntatore a intero p, ma non lo faccio puntare a nessuna variabile. Un puntatore va sempre inizializzato prima del suo utilizzo. Lasciare puntatori pendenti può creare problemi.

Puntatori 2 int num=0; int *p; p=&num; num p num

Puntatori 3 #include<stdio.h> int main() { int num=0; int *p; p=&num; printf("%d\n",num); //0 *p=5; printf("%d\n",*p); //5 printf("%d\n",num); //5 }

Puntatori 4 #include<stdio.h> int main() //due puntatori per lo stesso oggetto { int num=0; int *p=&num; int *p2=p; printf("%d\n",num); //0 printf("%d\n",*p); //0 printf("%d\n",*p2); //0 }

Puntatori 5 #include<stdio.h> int main() //Puntatori a costante { int num=3; const int *p=&num; *p=3; //Errore! p è un puntatore costante printf("%d\n",num); //3 num=4; printf("%d\n",*p); //4 }

Puntatori 6 #include<stdio.h> int main() { int n1=3, n2=4; int *p1=&n1, *p2=&n2; int **p3=&p2; *p3=p2; printf("%d\n",**p3); //4 }

Puntatori 7 //non scambia #include<stdio.h> void scambia(int num1, int num2) { int appoggio=num1; num1=num2; num2=appoggio; } int main() int n1, n2; printf("Inserire due numeri:\n"); scanf("%d%d",&n1,&n2); printf("%d\t%d\n",n1,n2); scambia(n1,n2);

Puntatori 8 //scambia #include<stdio.h> void scambia(int *num1, int *num2) { int appoggio=*num1; *num1=*num2; *num2=appoggio; } int main() int n1, n2; printf("Inserire due numeri:\n"); scanf("%d%d",&n1,&n2); printf("%d\t%d\n",n1,n2); scambia(&n1,&n2);

Puntatori 9 //puntatori come valori restuiti #include<stdio.h> int *min(int *num1, int *num2) { if(*num1<*num2) return num1; else return num2; } int main() int n1, n2, *p; printf("Inserire due numeri:\n"); scanf("%d%d",&n1,&n2); printf("%d\t%d\n",n1,n2); p=min(&n1,&n2); printf("%d”,*p);

Puntatori 10 //puntatori come valori restuiti !! Errata !! #include<stdio.h> int *min(int *num1, int *num2) { int n1,n2; n1=*num1; n2=*num2; if(*num1<*num2) return &n1; else return &n2; } int main() int n1, n2, *p; printf("Inserire due numeri:\n"); scanf("%d%d",&n1,&n2); printf("%d\t%d\n",n1,n2); p=min(&n1,&n2); printf("%d”,*p);

Puntatori e array (1) #include<stdio.h> int main() { int vett[5]; int *p=vett; *p=1; *(p+1)=2; p+=3; *(p-1)=3; *p=4; *(p+1)=5; p=vett; for(int i=0; i<5; i++) printf("%d\n",*(p+i)); }

Puntatori e array (2) #include<stdio.h> int main() { int vett[5]; int *p=vett; for(int i=0; i<5; i++) p[i]=i; for(int i=0; i<5; i++) printf("%d\t",p[i]); printf("\n"); for(int i=0; i<5; i++) printf("%d\t",vett[i]); }

Puntatori e array (3) //operatore [] è commutatività #include<stdio.h> int main() { int vett[5]; int *p=vett; for(int i=0; i<5; i++) p[i]=i; for(int i=0; i<5; i++) { printf("%d\t",vett[i]); printf("%d\t",*(vett+i)); printf("%d\t",*(i+vett)); printf("%d\t",i[vett]); } printf("\n");

Puntatori e array (4) #include<stdio.h> void modificaArray(int v[], int dim){ for(int i=0; i<dim; i++) v[i]=1; } int main() { int dim=5; int vett[dim]; for(int i=0; i<dim; i++) vett[i]=i; for(int i=0; i<dim; i++) printf("%d\t",vett[i]); printf("\n"); modificaArray(vett,dim);

Stringhe (1) Una stringa è formata da una serie di caratteri racchiusi tra doppi apici. “Sono una stringa” Le stringhe possono contenere sequenze di escape: “Sono una stringa\n” “Sono \t una \t stringa\n”

Stringhe (2) In C una stringa letterale è un array di char. La stringa “ciao” viene memorizzata come un vettore di cinque caratteri: Le stringhe possono essere vuote, e in quel caso la stringa “” viene memorizzata come un carattere null: c i a o \0 \0

Stringhe (4) Poiché le stringhe sono array di char, possiamo usare una stringa ovunque il C ammetta un puntatore di tipo char. /* char *pun; pun=”ciao”; //il puntatore pun punta alla prima lettera della //stringa */

Stringhe (5) I puntatori possono essere indicizzati: char c; c=”ciao”[1]; // c vale “i” Esempio: //conversione di un numero tra 0 e 15 in esadecimale; char esadecimale(int numero) { if (numero>=0 && numero<=15) return “0123456789ABCDEF”[numero]; else return “\0”; }

Stringhe (6) Inizializzazione di una stringa: char stringa[14]=”prova stringa”; Il compilatore inserisce i caratteri “prova stringa” nel vettore stringa e poi aggiunge il carattere null (\0) in modo tale che il vettore possa essere usato come stringa. E' equivalente scrivere: char stringa[14]={'p','r','o','v','a','','s','t','r','i','n','g','a','\0'};

Stringhe (7) Se l'inizializzatore di una stringa fosse troppo corto, il compilatore aggiungerebbe caratteri nulli aggiuntivi: char stringa[14]=”prova”; Se l'inizializzatore di una stringa fosse più lungo della variabile stringa? Cosa succede per i vettori?

Stringhe (8) La situazione non viene ammessa per le stringhe come non viene ammessa per i vettori. Il C consente che l'inizializzatore abbia la stessa lunghezza della variabile: char stringa[5]=”prova”; Non c'è spazio per il carattere “\0”, il compilatore non tenta di metterne uno e il vettore non è utilizzabile come stringa.

Stringhe (9) La dichiarazione di una variabile stringa può omettere la sua lunghezza che in tal caso verrà calcolata dal compilatore: char str[]=”prova”; Il compilatore riserva 6 caratteri per il vettore str sufficienti per contenere i caratteri presenti nella parola “prova” più il “\0”.

Stringhe (10) #include<stdio.h> int main() { char str[]="prova"; char *s="prova"; //s[2]='p'; operazione non ammessa! str[2]='p'; printf("%s\n",s); printf("%s\n",str); }

Stringhe (11) #include<stdio.h> int main() { char str[]="prova"; s="prova"; str[2]='p'; printf("%s\n",s); printf("%s\n",str); puts(s); puts(str); }

Stringhe (12) #include<stdio.h> int main() { char str[4]; scanf(“%s”,str); //comportamento indefinito; puts(str); }

Stringhe (13) #include<stdio.h> int main() { char str[4]; gets(str); //comportamento indefinito; puts(str); }

Stringhe (14) #include<stdio.h> int main() { char str[4]; gets(str); //se la stringa ha più di 4 caratteri? //comportamento indefinito puts(str); }

Libreria C per le stringhe Le stringhe in C non possono essere copiate o confrontate per mezzo degli operatori. Subiscono le stesse limitazioni dei vettori. Esiste però una libreria che fornisce un ricco insieme di funzioni adatte ad eseguire operazioni sulle stringhe. I programmi che necessitano di eseguire operazioni su stringhe devono includere la libreria “string.h” con il codice: #include<string.h>

strcpy() La funzione strcpy() ha la seguente firma: char *strcpy(char *s1, const char* s2); Tale funzione copia la stringa puntata da s2 nel vettore puntato da s1. Copia in s1 i caratteri di s2 sino al “\0”. s2 è const poiché non viene modificata.

strcpy() (2) #include<stdio.h> #include<string.h> int main() { char str[5]="ciao"; char str1[5]; strcpy(str1,str); puts(str1); puts(str); }

strncpy() Nella chiamata: strcpy(str1,str); la funzione strcpy() non ha modo di verificare che la stringa puntata da str stia nel vettore puntato da str1. Chiamare la funzione strncpy(str1, str, sizeof(str1)); è un modo più sicuro per copiare una stringa. Nel caso in cui str sia più grande di str1 non creo problemi: memorizzo in str1 soltanto la porzione di str che ci sta.

strlen() Restituisce la lunghezza della stringa: int main () { char s[10]=“ciao”; int l; l = strlen(s); printf(“La lunghezza della stringa è: %d”, l); }

strcat() Concatena il contenuto della stringa passata come secondo parametro alla stringa passata come primo parametro: #include<stdio.h> #include<string.h> int main () { char sorgente[10]="pippo"; char destinazione[10]="pluto"; int l; strcat(destinazione, sorgente); printf("Il valore è: %s\n", destinazione); }

strcmp() Confronta il contenuto di due stringhe e restituisce: 0 se le stringhe sono identiche <0 se la stringa passata come primo parametro è minore della stringa passata come secondo parametro. >0 se la stringa passata come primo parametro è maggiore della stringa passata come secondo parametro. La relazione d’ordine tra stringhe è definita dalla relazione d’ordine della codifica ASCII dei caratteri che la compongono: ‘0’ < ‘9’ < ‘A’ < ‘Z’ < ‘a’ < ‘z’

strcmp() #include<stdio.h> #include<string.h> int main () { char s1[10]="abc"; char s2[10]="def"; int c; c = strcmp(s1, s2); if (c==0) { printf("uguali"); } else if (c<0) { printf("s1 < s2\n"); } else { printf("s1 > s2\n"); }

strcmp() #include<stdio.h> #include<string.h> int main () { char s1[10]="abc"; char s2[10]="def"; int c; c = strcmp(s1, s2); if (c==0) { printf("uguali"); } else if (c<0) { printf("s1 < s2\n"); } else { printf("s1 > s2\n"); }

Esempio(1) #include<stdio.h> #include<string.h> void foo(char *s){ if(s[0] == '\0'){ return; }else{ foo(&s [1]); putchar(s[0]); } int main () { char s[10]="abcdef"; foo(s); return 0;