Esercizi con Array. Unità 7. Corso di Laboratorio di Informatica Ingegneria Clinica BCLR. Domenico Daniele Bloisi

Transcript

1 Corso di Ingegneria Clinica BCLR Domenico Daniele Bloisi

2 Docente Ing. Domenico Daniele Bloisi, PhD Ricercatore Dipartimento di Ingegneria Informatica, Automatica e Gestionale Antonio Ruberti Via Ariosto 25 (adiacente Piazza Dante, Manzoni Tram 3 fermata via Labicana) bloisi@dis.uniroma1.it home page: Pagina 2

3 Ricevimento In aula, subito dopo le lezioni Su appuntamento (tramite invio di una ) presso: Dipartimento di Ingegneria Informatica, Automatica e Gestionale Antonio Ruberti, via Ariosto 25 - II piano, stanza A209 Si invitano gli studenti a controllare regolarmente la bacheca degli avvisi Pagina 3

4 Orari Lunedì Aula 4, via del Castro Laurenziano 7A Martedì Aula 15, Laboratorio Didattico via Tiburtina 205 Mercoledì Aula 4, via via del Castro Laurenziano 7A Pagina 4

5 Puntatori e array Un'array di elementi può essere pensato come disposto in un insieme di locazioni di memoria consecutive. Consideriamo il seguente esempio: int a[10], x; int *ptr; a[0] = 15; ptr = &a[0]; x = *ptr; /* ptr punta all'indirizzo di a[0] */ /* x = contenuto della cella puntata da ptr (in questo caso, a[0]) */ Pagina 5

6 Cosa accade idealmente in memoria int a[10], x; int *ptr; a[0] = 15; 166? x a[0] ??? a[1] a[2] a[3] indirizzi di memoria 179? ptr 148? a[9] nome variabile Pagina 6

7 Cosa accade idealmente in memoria ptr = &a[0]; a[0] 166? x??? a[1] a[2] a[3] ptr 148? a[9] Pagina 7

8 Cosa accade idealmente in memoria x = *ptr; x a[0] ??? a[1] a[2] a[3] ptr 148? a[9] Pagina 8

9 Aritmetica dei puntatori Al fine di scandire i valori contenuti nell array a è possibile incrementare ptr con istruzioni del tipo ++ptr E possibile anche utilizzare una espressione del tipo (ptr + i) che è equivalente ad a[i], con i = 0, 1, 2, 3,..., 9. Pagina 9

10 Accesso ad array tramite puntatori Esempio *(ptr + i) = 30; Attenzione: in C non c è alcun controllo sul superamento dei limiti di un array, pertanto è possibile oltrepassare i limiti dichiarati per un array e sovrascrivere altri blocchi di memoria. Pagina 10

11 Esercizio Si scriva un programma che manipoli un array c di char tramite un puntatore c_ptr. L array deve avere valore iniziale ['L' 'U' 'C' 'A'] Applicando le nozioni di aritmetica dei puntatori a c_ptr si vuole trasformarlo in ['M' 'I' 'N' 'O'] Pagina 11

12 Soluzione #include <stdio.h> #include <stlib.h> int main() { char c[4] = {'L', 'U', 'C', 'A'; int i; for(i = 0; i < 4; i++) { printf("%c\n", c[i]); printf("\n"); char* c_ptr = c; //equivalente a char* c_ptr = &c[0]; *c_ptr = 'M'; *(++c_ptr) = 'I'; *(c_ptr + 1) = 'N'; *(c_ptr + 2) = 'O'; for(i = 0; i < 4; i++) { printf("%c\n", c[i]); return EXIT_SUCCESS; Pagina 12

13 Rapporto tra array puntatori In C esiste un legame stretto tra array e puntatori. Ad esempio, se ptr è un puntatore a int e a è un array di int, è possibile scrivere ptr = a; invece di ptr = &a[0]; Pagina 13

14 Rapporto tra array puntatori a[i] può essere scritto come *(a+i) cioè &a[i] a + i Inoltre, si può applicare l operatore [] a un puntatore, ottenendo il seguente significato ptr[i] *(ptr+i) Pagina 14

15 L'ordine di priorità, dalla più alta alla più bassa, degli operatori in C è: ()[] ->.! ~ - * & sizeof cast (associatività da destra a sinistra) * / % + - < <= >= > ==!= & ^ &&?: (associatività da destra a sinistra) = += -= *= /= %= &= ^= = <<= >>= (associatività da destra a sinistra), Salvo le eccezioni specificate, gli operatori con la stessa priorità presentano associatività da sinistra a destra, cioè a - b + c è valutato (a - b) + c.

16 Riepilogo Espressione Equivale a Significato *p++ *(p++) Il valore di p viene incrementato dopo averlo utilizzato per accedere alla locazione di memoria puntata. *++p *(++p) Il valore di p viene incrementato prima di utilizzarlo per accedere alla locazione di memoria puntata. ++*p ++(*p) Il valore della locazione di memoria puntata da p viene incrementato prima dell utilizzo di p per accedere alla locazione di memoria puntata. (*p)++ (*p)++ Il valore contenuto della locazione di memoria puntata da p viene incrementato dopo aver utilizzato p per accedere alla locazione di memoria puntata. Pagina 16

17 /* 1*/ #include <stdio.h> /* 2*/ int main() { /* 3*/ int *p, b[2] = {1, 2; /* 4*/ p = b; /* 5*/ if(*p++ >= b[1]) { /* 6*/ printf("entro nel ramo then\n"); /* 7*/ /* 8*/ else { /* 9*/ printf("entro nel ramo else\n"); /*10*/ /*11*/ printf("b[0] = %d b[1] = %d\n", b[0], b[1]); /*12*/ p = b; /*13*/ if(*++p >= b[1]) { /*14*/ printf("entro nel ramo then\n"); /*15*/ /*16*/ else { /*17*/ printf("entro nel ramo else\n"); /*18*/ /*19*/ printf("b[0] = %d b[1] = %d\n", b[0], b[1]); /*20*/ p = b; /*21*/ if(++*p >= b[1]) { /*22*/ printf("entro nel ramo then\n"); /*23*/ /*24*/ else { /*25*/ printf("entro nel ramo else\n"); /*26*/ /*27*/ printf("b[0] = %d b[1] = %d\n", b[0], b[1]); /*28*/ return 0; /*29*/ Cosa stampa questo programma? Pagina 17

18 Output entro nel ramo else b[0] = 1 b[1] = 2 entro nel ramo then b[0] = 1 b[1] = 2 entro nel ramo then b[0] = 2 b[1] = 2 Pagina 18

19 Esercizio Si scriva una funzione in linguaggio C che prenda in ingresso un array di 3 interi a e restituisca un puntatore a un array creato dinamicamente e contenente i valori di a posizionati in ordine inverso. Esempio Se a = [1, 2, 3] si vuole ottenere un puntatore a un array creato dinamicamente pari a [3, 2, 1] Pagina 19

20 Soluzione int* f(int a[3]) { int *b = (int*)malloc(3*sizeof(int)); if(b == NULL) { return NULL; else { int i; for(i = 0; i < 3; i++) { b[i] = a[2-i]; return b; Pagina 20

21 Note 1. Poiché la dimensione di a è nota a priori (espressa esplicitamente nella specifica), il prototipo della funzione sarà int* f(int a[3]) con la lunghezza del parametro array in ingresso specificata (in questo caso 3) 2. Nel caso in cui la malloc dovesse fallire, essa restituirà un valore NULL, in modo da permettere alla funzione chiamante f (ad es. main) di poter gestire l errore. Pagina 21

22 Programma di prova int main() { int d[3] = {1, 2, 3; int i; for(i = 0; i < 3; i++) { printf("%d ", d[i]); printf("\n"); int *e = f(d); if(e!= NULL) { for(i = 0; i < 3; i++) printf("%d ", e[i]); free(e); //libero la memoria allocata in f else printf("errore in f.\n"); return EXIT_SUCCESS; Pagina 22

23 Free... int *e = f(d); if(e!= NULL) { for(i = 0; i < 3; i++) printf("%d ", e[i]); free(e); //libero la memoria allocata in f printf("dopo free\n"); for(i = 0; i < 3; i++) { printf("%d ", e[i]); printf("\n");... Pagina 23

24 Output dopo free Pagina 24

25 Differenze tra array e puntatori Puntatori e array sono diversi: - un puntatore è una variabile, per cui è possibile scrivere: ptr = a e anche ptr++ - un array non è una variabile, quindi: a = ptr e a++ sono istruzioni NON VALIDE Pagina 25

26 Allocazione dinamica di matrici In C è possibile creare una matrice allocando memoria dinamicamente. A tale scopo, si può utilizzare un puntatore a puntatore. Esempio int **m; L idea è quella di creare una struttura a due livelli, con Al primo livello, un array di puntatori Al secondo livello, una serie di array, contenenti i dati della matrice. Pagina 26

27 Allocazione dinamica di matrici int i; int** m; m = (int **)malloc(rows*sizeof(int*)); for(i = 0; i < ROWS; i++) { m[i] = (int *)malloc(columns*sizeof(int)); ROWS = 3 COLUMNS = 2 array di puntatori a int array di int Pagina 27

28 Allocazione dinamica di matrici m[0][1] = 5; m[2][0] = 6; ROWS = 3 COLUMNS = 2 5 array di puntatori a int 6 array di int Pagina 28

29 Esercizio Si scriva una funzione creamat che, presi in ingresso due interi r e c, restituisca una matrice r x c creata dinamicamente. Si realizzi un programma di prova che utilizzi creamat per creare la matrice stampandone il contenuto a video. Pagina 29

30 Funzione creamat int** creamat(int r, int c) { int i; int** m; m = (int **)malloc(r * sizeof(int*)); if(m == NULL) return NULL; for(i = 0; i < r; i++) { m[i] = (int *)malloc(c * sizeof(int)); if(m[i] == NULL) return NULL; return m; Pagina 30

31 main int main() { int r = 2, c = 4; int i, j; int **m = creamat(r, c); if(m == NULL) return EXIT_FAILURE; m[0][0] = 3; m[0][1] = 6; m[0][2] = 8; m[0][3] = 9; m[1][0] = 12; m[1][1] = 54; m[1][2] = 6; m[1][3] = 89; for(i = 0; i < r; i++) { for(j = 0; j < c; j++) { printf("%d ", m[i][j]); printf("\n"); return EXIT_SUCCESS; Pagina 31

32 Deallocazione di una matrice allocata dinamicamente Cosa accade se si esegue free(m)? Viene deallocata solo una parte della memoria per la matrice! Pagina 32

33 Deallocazione di una matrice allocata dinamicamente Prima di eseguire free(m) è necessario effettuare una free su ogni riga free(m[0]); Pagina 33

34 Deallocazione di una matrice allocata dinamicamente Deallocazione corretta for(i = 0; i < r; i++) { free(m[i]); free(m); Pagina 34

35 main int main() { int r = 2, c = 4; int i, j; int **m = creamat(r, c); if(m == NULL) return EXIT_FAILURE; m[0][0] = 3; m[0][1] = 6; m[0][2] = 8; m[0][3] = 9; m[1][0] = 12; m[1][1] = 54; m[1][2] = 6; m[1][3] = 89; for(i = 0; i < r; i++) { for(j = 0; j < c; j++) { printf("%d ", m[i][j]); printf("\n"); for(i = 0; i < r; i++) { free(m[i]); free(m); return EXIT_SUCCESS; Pagina 35

36 Accesso ad una matrice tramite aritmetica dei puntatori Sia A una matrice 5x4 allocata dinamicamente. Per accedere all elemento A[3][2] è possibile utilizzare l aritmetica dei puntatori nel seguente modo: *(*(A+3)+2) A(0,0) A(3,2) 3 4 Pagina 36

37 Accesso ad una matrice tramite aritmetica dei puntatori *(*(A+3)+2) (A+3) è il quarto puntatore dell array che rappresenta le righe *(A+3) è l indirizzo del primo elemento della quarta riga *(A+3)+2 è l indirizzo del terzo elemento della quarta riga *(*(A+3)+2) è il contenuto della cella puntata dal puntatore al terzo elemento della quarta riga Pagina 37