MEMORIA DINAMICA. & Indirizzo * Contenuto. 1. Puntatori. Nozioni base sull uso dei puntatori: Operatori & * In sintesi : /* Definizine variabili */

Transcript

1 MEMORIA DINAMICA 1. Puntatori Nozioni base sull uso dei puntatori: Operatori & * ES /* Definizine variabili */ int x, y; /* Variabili intere */ int *px; /* Puntatore a intero */ x = 10; /* Assegno 10 a x */ px = &x; /* px punta all indirizzo di x */ y = *px; /* Ora y = x = 10 */ /* Gli operatori sono complementari */ *(&x) = x; &(*px) = px; In sintesi : & Indirizzo * Contenuto 1

2 2. Puntatori e vettori Il nome del vettore è equivalente all indirizzo del suo primo elemento. vett = & vett[0] ES /* Definzione delle variabili */ int b[5]; int *bptr; bptr = b ; bptr = &b[0]; Quindi: b[3] *(bptr+3); *(b+3); &b[3] bptr+3; b+3; b[1] bptr[1] 3. Vettori e stringhe ES char color[] = blue ; char *color = blue ; char *s; = char s[]; 2

3 4. Vettori dinamici Parliamo di vettori dinamici quando non sappiamo esattamente la lunghezza del vettore. In C è possibile effettuare tale operazione utilizzando la memoria dinamica. ES /* Definizione variabili */ int num_elem; /* Lunghezza del vettore letto de file o da tastiera */ int *vett; /* Definizione di vettore dinamico */ void main(void) /* Allocazione */ vett = (int *)malloc( num_elem * sizeof(int) ); /* Lettura numeri */ for(i=0; i<num_elem; i++) printf( ); scanf( %d, &vett[i]); /* Deallocazione */ free(vett); 3

4 5. Vettori di puntatori I vettori di puntatori di solito vengono utilizzati con le stringhe. Sono utilissimi in casi come in figura: V[0] pippo V[1] pluto V[2] qui V[3] quo Con i vettori di puntatori posso evitare di sovradimensionare le colonne di una matrice di caratteri, ma ogni elemento del vettore sarà un puntatore ad una stringa allocata dinamicamente. CASO 1: Conosco già la lunghezza del vettore ES /* Definizioni di variabili */ #define N 10 char *vett[n]; /* Vettore di puntatori dimensionato */ void main(void) /* Lettura stringhe da tastiera */ for( i=0; i<n; i++) scanf( %s, stringa); /* Allocazione */ vett[i] = (char *)malloc( (strlen(stringa)+1) * (sizeof(char)) ); strcpy( vett[i], stringa); /* Deallocazione */ for( i=0; i<n; i++) free(vett[i]); 4

5 CASO 2: Non conosco la lunghezza del vettore ES /* VETTORE DINAMICO + VETTORE DI PUNTATORI */ /* Definizione variabili */ char temp[20]; /* Stringa temporanea */ char **vett; /* Vettore di puntatori - si ignora la lunghezza*/ int num_elem; /* Lunghezza vettore introdotta da tastiera o da file */ void main(void) /* Allocazione VETTORE DINAMICO */ vett = (char **)malloc( num_elem * (sizeof(char *)) ); /* A questo punto è come se avessi *vett[num_elem] */ /* Lettura stringhe da tastiera */ for( i=0; i<num_elem; i++ ) scanf( %s, temp); /* Allocazione VETTORE DI PUNTATORI */ vett[i] = (char *)malloc( (strlen(temp)+1) * (sizeof(char)) ); strcpy( vett[i], temp ); /* Deallocazione */ for( i=0; i<n; i++) free(vett[i]); free(vett); 5

6 SINTESI FINALE: Vettore dinamico Non si conosce la sua lunghezza. (num_elem). Formato di solito da numeri. int *vett; Vettore di puntatori Si conosce la lunghezza, ma non la profondità. Formato di solito da stringhe. char *vett[max_righe]; Vettore dinamico + Non si conosce né lunghezza né profondità. Vettore di puntatori È una fusione dei due casi precedenti char **vett; Qui di seguito sono riportati per intero programmi che utilizzano i meccanismi precedentemente illustrati. 6

7 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Alessandro Fassio Ingegneria elettronica * * VETTORE DINAMICO * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <stdio.h> #include <conio.h> #include <string.h> #include <ctype.h> #include <alloc.h> void main (void) int n; int i; int *vett; clrscr(); printf("vettore DINAMICO - acquisizione numeri\n\n"); printf("inserire numero di elementi del vettore\n>> "); scanf("%d", &n); /* Allocazione */ vett = (int *)malloc( n * sizeof(int) ); if(vett == NULL) printf("errore in allocazione!!\n"); for(i=0; i<n; i++) printf("input vett[%d]: ", i+1); scanf("%d", &vett[i]); /* Stampa vettore introdotto */ for(i=0; i<n; i++) printf(" %d ", vett[i]); printf("\nfine\n"); free(vett); 7

8 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Alessandro Fassio Ingegneria elettronica * * VETTORE DI PUNTATORI * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <stdio.h> #include <conio.h> #include <string.h> #include <ctype.h> #include <alloc.h> #define N 9 #define MAX 15 void main (void) char *vett[n]; char nome[max]; int i; clrscr(); printf("vettore DI PUNTATORI - acquisizione stringhe\n\n"); for(i=0; i<n; i++) printf("input elemento %d: ", i+1); scanf("%s", nome); /* Allocazione */ vett[i] = (char *)malloc( (strlen( nome ) +1) * sizeof(char)); if( vett[i]==null ) printf("errore in allocazione!!\n"); strcpy( vett[i], nome); /* Stampa di controllo */ printf("\nnomi introdotti:\n"); for( i=0; i<n; i++) printf("%s\n", vett[i]); printf("\nfine\n"); /* Deallocazione */ for( i=0; i<n; i++) free(vett[i]); 8

9 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Alessandro Fassio Ingegneria elettronica * * VETTORE DINAMICO + VETTORE DI PUNTATORI * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <stdio.h> #include <conio.h> #include <string.h> #include <alloc.h> #define N 15 void main (void) int i; char str[n]; int n; /*Numero di dati che voglio introdurre */ char **vett; /*Vettore dinamico e di puntatori */ clrscr(); printf("vettore DINAMICO E DI PUNTATORI - con stringhe\n\n"); printf("introdurre numero di dati:\n"); scanf("%d", &n); /* Allocazione vettore dinamico */ vett = (char **)malloc( n * sizeof(char *) ); if( vett == NULL ) printf("errore in allocazione.\n"); for( i=0; i<n; i++) printf("input stringa %d: ", i+1); scanf("%s", str); /* Allocazione vettore di puntatori */ vett[i] = (char *)malloc( (strlen(str)+1) * sizeof(char)); 9

10 if( vett[i] == NULL ) printf("errore in allocazione.\n"); strcpy( vett[i], str); /* Stampa */ printf("nomi introdotti:\n"); for(i=0; i<n; i++) printf("%s\n", vett[i]); printf("\nfine\n"); /* Deallocazione */ for(i=0; i<n; i++) free(vett[i]); free(vett); 10

11 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Alessandro Fassio Ingegneria elettronica * * Lettura e stampa classifica di calcio * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ VETTORE DINAMICO + STRUCT (con campi statici) #include <stdio.h> #include <conio.h> #include <string.h> #include <alloc.h> typedef struct char nome_sq[30]; int punti; classifica; classifica *vett; char nome_file[30]; int num_squadre; /* Prototipi */ void errore(void); int leggi_file(void); void stampa(int num_squadre); void main (void) clrscr(); printf("inserisci il nome del file:\n"); scanf("%s", nome_file); num_squadre = leggi_file(); printf("\n CLASSIFICA:\n\n"); stampa(num_squadre); printf("\nfine\n\n"); free(vett); /************************************************************************ ERRORE *************************************************************************/ void errore(void) printf("errore!!\n"); 11

12 /************************************************************************ LETTURA FILE *************************************************************************/ /* file: A:\S.TXT */ int leggi_file(void) FILE *fptr; int squadre=0, i, npunti; fptr=fopen( nome_file, "r"); if( fptr==null ) errore(); /* Leggo quante squadre ci sono nel file */ fscanf(fptr, "%d", &squadre); /* Allocazione */ vett = (classifica *)malloc( squadre * sizeof(classifica) ); if( vett==null ) errore(); /* Lettura e memorizzazione nella struct */ for( i=0; i<squadre; i++) fscanf( fptr,"%s %d", vett[i].nome_sq, &vett[i].punti); fclose(fptr); return(squadre); /************************************************************************ STAMPA *************************************************************************/ void stampa(int num_squadre) int i; for(i=0; i<num_squadre; i++) printf("%-16s %d\n", vett[i].nome_sq, vett[i].punti); return; 12

13 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Alessandro Fassio Ingegneria elettronica * * VETTORE DIN-PUNT CON STRUCT (campi statici e dinamici) * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <stdio.h> #include <conio.h> #include <string.h> #include <alloc.h> typedef struct char *nome; char *cognome; int cod; persona; persona *vett; char s1[20], s2[20]; char nome_file[20]; void main (void) int i, n, dato; FILE *fptr; clrscr(); printf("nome file.\n >> "); scanf("%s", nome_file); /* Apertura del file A:\P.TXT */ fptr=fopen(nome_file, "r"); if( fptr==null ) printf("errore apertura file\n"); fscanf(fptr, "%d", &n); 13

14 /* Allocazione vettore dinamico */ vett = (persona *)malloc( n *sizeof(persona)); if(vett==null) printf("errore allocazione 1\n"); /* Lettura file */ for(i=0; i<n; i++) fscanf(fptr, "%s %s %d", s1, s2, &dato); /* Allocazione vettore di puntatori*/ vett[i].nome = (char *)malloc( (sizeof(char)) * (strlen(s1)+1) ); vett[i].cognome = (char *)malloc( (sizeof(char)) * (strlen(s2)+1) ); if( (vett[i].cognome==null) (vett[i].nome==null) ) printf("errore allocazione 2\n"); strcpy(vett[i].nome, s1); strcpy(vett[i].cognome, s2); vett[i].cod=dato; fclose(fptr); /* Stampa */ for(i=0; i<n; i++) printf("%-15s %-15s %d\n", vett[i].nome, vett[i].cognome, vett[i].cod); /* Deallocazione */ for(i=0; i<n; i++) free(vett[i].nome); free(vett[i].cognome); free(vett); 14