Passaggio parametri puntatore - Dipartimento di Ingegneria ...bloisi/didattica/... · Passando alla funzione i puntatori a due variabili è possibile modificare il valore delle variabili

Corso di Fondamenti di InformaticaIngegneria delle Comunicazioni BCORIngegneria Elettronica BELR

Passaggio parametri puntatore

Parte 6

Domenico Daniele Bloisi

Docenti

Parte I – prof. Silvio Salza

[email protected]@dis.uniroma1.it

http://www.dis.uniroma1.it/~salza/fondamenti.htm

Parte II – ing. Domenico Daniele Bloisi

[email protected]

2010/2011Passaggio parametri puntatoreParte 6

Pagina 2

http://www.dis.uniroma1.it/~bloisi/didattica/fondin f1011.html

Nota: %7E corrisponde alla tilde ~

Informazioni Generali

ing. Domenico Daniele Bloisi, PhD

Dipartimento di Informatica e SistemisticaDipartimento di Informatica e SistemisticaVia Ariosto 25(adiacente Piazza Dante,

A fermate Manzoni, Vittorio Emanuele,Tram 3 fermata via Labicana)

mailto:[email protected]

Pagina 3

mailto:[email protected]

http://www.dis.uniroma1.it/~bloisi


Ricevimento

Martedì 15.00 – 17.00DIS, via Ariosto 25DIS, via Ariosto 25

Aula docenti adiacente aula A4

Si consiglia di inviare una email per conferma edi controllare la bacheca degli avvisi

Pagina 4

http://www.dis.uniroma1.it/~bloisi/didattica/fondin f1011.html#Avvisi


Sommario – Parte 6

• Memoria, indirizzamento e puntatori• Tipo void * e conversioni sui puntatori• Gestione dinamica della memoria• Gestione dinamica della memoria• Tempo di vita delle variabili allocate dinamicamente

• Problemi di deallocazione della memoria• Passaggio dei parametri tramite puntatori

Pagina 52010/2011Passaggio parametri puntatoreParte 6

Tempo di vita delle variabili allocate dinamicamente (1/2)

Per le variabili allocate dinamicamente il tempo di vita corrisponde al periodo che va

� dal momento in cui la variabile viene allocata

� al momento in cui la variabile viene deallocata.

Il tempo di vita di una variabile allocata dinamicamente è definito solo al momento


dinamicamente è definito solo al momento dell'esecuzione del programma.

Tempo di vita delle variabili allocate dinamicamente (2/2)Se una variabile allocata dinamicamente non viene deallocata esplicitamente, il suo tempo di vita termina alla terminazione del programma.vita termina alla terminazione del programma.

Può verificarsi il caso in cui una zona di memoria allocata non sia più accessibile, in quanto non ci sono variabili che la “riferiscono”.Tale zona di memoria rimarrà inutilmente


Tale zona di memoria rimarrà inutilmente occupata per tutta la durata del programma.

Esempio: tempo di vita variabili dinamicheint * creaint (int a) {

int * temp = malloc(sizeof(int));*temp = a;*temp = a;return temp;

}

int main () {int * pt2 = creaint(5);


int * pt2 = creaint(5);printf("*pt2 = %d \n", *pt2);

}

Esecuzione: Tempo di vita variabili dinamiche

Il programma precedente stampa

*pt2 = 5*pt2 = 5

poiché la variabile allocata dalla funzione creaint viene restituita al programma principale e rimane accessibile anche al termine della esecuzione della funzione .


Le variabili create dinamicamente non rispettano le regole di campo di azione.

Esempio: esaurimento della memoria

// sciupaMemoria ;int *temp , k;for (k = 1; 1 ; k++) {for (k = 1; 1 ; k++) {

printf ("k = %d \n", k);temp = malloc (sizeof (int ));

}

L'esecuzione comporta una richiesta infinita di


L'esecuzione comporta una richiesta infinita dimemoria (la condizione del ciclo è sempre verificata).

Esecuzione: esaurimento della memoriaL’esecuzione produrrà una richiesta infinita di memo ria che in C comporta (dopo un numero di cicli piuttost o alto) l’interruzione dell’esecuzione con un messaggio simil e al l’interruzione dell’esecuzione con un messaggio simil e al seguente:

dynamic(1320) malloc: *** mmap(size=16777216) faile d (error code=12) *** error: can’t allocate region


Nota: Ad ogni ripetizione del ciclo, la memoria allo cata al ciclo precedente risulta inaccessibile.

Problemi di deallocazione della memoriaint *pt1;pt1 = malloc(sizeof(int)); // allocazione della variabile*pt1 = 1;*pt1 = 1;printf("*pt1 = %d\n", *pt1); // uso della variabilefree(pt1);// la locazione di memoria rimane accessibile dopo f ree!!!printf("after free\n");printf("*pt1 = %d\n", *pt1);// la stessa locazione di memoria potrebbe essere ri -allocata!!!int *pt2 = malloc(sizeof(int));printf (" after malloc \ n");


printf (" after malloc \ n");printf("*pt2 = %d\n", *pt2);

Esecuzione


Discussione: problemi di deallocazione della memoriaIn questo caso, si può verificare che la memoria ri manga accessibile anche dopo il rilascio, ed addirittura che sia ancora immutata (anche se non è garantito).ancora immutata (anche se non è garantito).

In aggiunta, la riallocazione immediata potrebbe riallocare la variabile nella stessa posizione della memoria e quindi con lo stesso valore (ma anche que sto non è garantito).


In ogni caso, entrambe le situazioni sopra delineate sono da evitare accuratamente, in quanto fonti di errori e di comportamenti instabili del programma.

Puntatori appesi

Si consideri il seguente frammento di codice

int *pt1;pt1 = malloc(sizeof(int)); *pt1 = 1;printf("*pt1 = %d\n", *pt1);int *pt2;pt2 = pt1;printf("prima di free(pt1)\n");printf ("*pt2 = %d \ n", *pt2);


printf ("*pt2 = %d \ n", *pt2);free(pt1);printf("dopo di free(pt1)\n");printf("*pt2 = %d\n", *pt2);

Esecuzione: Puntatori appesi

*pt1 = 1prima di free(pt1)*pt2 = 1*pt2 = 1dopo di free(pt1)*pt2 = 4001536

In questo caso, il rilascio della memoria puntata d alla variabile pt1 lascia la variabile pt2 puntare ad una locazione di memoria rilasciata e quindi suscettibil e di modifiche arbitrarie da parte del sistema operativo .

Questa situazione di puntatore appeso (dangling) è d a evitare assolutamente in quanto fonte di errori dif ficili da individuare.


modifiche arbitrarie da parte del sistema operativo .

Passaggio di parametri (1/2)

L’uso di variabili di tipo puntatore consente di simulare la modalità di passaggio dei parametri per riferimento.per riferimento.

Nel passaggio di parametri per valore, in genere utilizzato per i dati di tipo primitivo, il paramet ro formale può essere considerato come una variabile locale che viene inizializzata al momento

Pagina 172010/2011

variabile locale che viene inizializzata al momento della chiamata della funzione con il valore corrispondente al parametro attuale.

Passaggio parametri puntatoreParte 6

Passaggio di parametri (2/2)

Il passaggio di parametro per valore effettuato con il tipo puntatore consente di aggirare una proprietà cruciale del passaggio di parametri proprietà cruciale del passaggio di parametri per valore, cioè la garanzia che la funzione non abbia effetti sul programma chiamante (ad eccezione della restituzione del valore calcolato).


Esempio: passaggio parametripuntatore

void swap(int *a, int *b) {void swap(int *a, int *b) {int temp;temp = *a;*a = *b;*b = temp;

}


Esempio: passaggio parametripuntatoreint main (){

int x, y;x = 12; y = 27;x = 12; y = 27;printf("x = %d \n", x);printf("y = %d \n", y);swap(&x, &y);printf("after swap \n");printf("x = %d \ n", x);

Pagina 202010/2011

printf("x = %d \ n", x);printf("y = %d \n", y);

}


Esecuzione

x = 12y = 27y = 27after swapx = 27y = 12


Passaggio parametri puntatore

Nonostante il passaggio di parametri sia per valore , il risultato dell’esecuzione della funzione swap consiste proprio nel modificare il valore di due variabili d el proprio nel modificare il valore di due variabili d el programma principale.

Passando alla funzione i puntatori a due variabili è possibile modificare il valore delle variabili punt ate, anche se il valore delle variabili puntatore rimane inalterato .

Pagina 222010/2011

inalterato .

L’uso dei puntatori nel passaggio di parametri per valore consente di effettuare in pratica il passaggio di p arametri per riferimento.


Passaggio per valore VS passaggio tramite puntatori

void swap(int *a, int *b) {int temp;temp = *a;*a = *b;

swap(&x, &y);

definizione invocazione*a = *b;*b = temp;

}

void swapVal(int a, int b) {int temp;temp = a;a = b;

swapVal(x, y);

definizione invocazione

definizione invocazione

Pagina 232010/2011

a = b;b = temp;

}

Cosa succede se si invoca swapVal(&x, &y); ?


Esecuzione


Chiamata tramite parametri puntatore (per indirizzo): funzione chiamanteQuando la funzione viene chiamata, devono essere passati come parametri gli indirizzi delle variabili

• il passaggio degli indirizzi potrà essere ottenuto • il passaggio degli indirizzi potrà essere ottenuto applicando l’operatore di indirizzo & alla variabile che deve essere modificata

• sono passate le “celle” fisiche dove i valori sono memorizzati

int a; int b;2a&a


int a; int b;a = 2; b = 3;f(&a, &b);

2

3

a

b

&b

Chiamata per indirizzo

Nell’intestazione della funzione chiamata deve essere usato l’operatore di deriferimento per le variabili passate per indirizzoper indirizzo

void f(int *pa, int *pb){

*pa = 6;*pb = 7;

&apa

&pa

&pb


*pb = 7;}&bpb

Chiamata per indirizzo: esecuzione

int a; int b;a = 2; b = 3;f(&a, &b);6a

&a

f(&a, &b);

void f(int *pa, int *pb){

pa

&pa

&pb

6

7

a

b

&b

int *pa = &a;


{*pa = 6;*pb = 7;

}

pb

&pb

Vantaggi del passaggio per riferimento

Il passaggio di parametri di tipo puntatore è particolarmente utile quando i dati che devono essere scambiati tra funzione chiamata e essere scambiati tra funzione chiamata e programma chiamante sono voluminosi.

Il passaggio per riferimento risulta molto più efficiente sia in termini di occupazione di memoria che di tempo di calcolo (infatti,

Pagina 282010/2011

memoria che di tempo di calcolo (infatti, occorre la copia del solo puntatore ai dati, non di tutto l’insieme dei dati).


Valori restituiti di tipo puntatoredouble *puntatore (double a) {

double *r = malloc(sizeof(double));*r = a;*r = a;return r;

}

int main () {double *pd = puntatore(5.4);printf("pd = %p\n", pd);printf("*pd = %f \ n", *pd);

Pagina 292010/2011

printf("*pd = %f \ n", *pd);return 0;

} la funzione puntatore crea un puntatore ad una variabile di tipo double e la inizializza con il valore passato come argomento


Esercizi

Esercizio 6.5

Scrivere un programma che legga tre valori in tre distinte variabili small , medium, large , e ne scambi i distinte variabili small , medium, large , e ne scambi i valori in modo da avere il più grande nella variabi le large , il più piccolo nella variabile small ed il restante nella variabile medium. Definire una funzione per lo scambio dei tre valori che utilizzi il passaggio di parametri puntatore.


Esercizi

Esercizio 6.6

Scrivere una funzione che dati due valori interi a e brestituisca quoziente e resto della divisione a/b . restituisca quoziente e resto della divisione a/b . Scrivere un programma di prova per tale funzione,leggendo l’input da tastiera.


Appendice: memoria

0

Memoria

La memoria del calcolatore può essere idealmente descritta come un insieme di celle ORDINATOUNIVOCAMENTE


n

Appendice: assegnazione

int x = 1;0

12359156L’istruzione di assegnazione permette di “scrivere” un valore all’interno di una cella simboleggiata da un nome di variabile

x


nvariabile

Appendice: valore di una variabile

int x = 1;printf("x = %d\n", x);

0

Produce

x = 112359156

Tramite il nome di una variabile è possibile “leggere” il contenuto

x


npossibile “leggere” il contenuto della cella simboleggiata da quella variabile

Appendice: indirizzo di una variabile

int x = 1;printf("&x = %d\n", &x);

0

Produce

&x = 235915612359156

Tramite l’operatore & applicato al nome di una variabile è possibile

x


nnome di una variabile è possibile “leggere” l’indirizzo della cella simboleggiata da quella variabile

Appendice: puntatore

int x = 1;int *x_ptr;

2359154 2359156 x_ptrint *x_ptr;x_ptr = &x;

printf("*x_ptr = %d\n", *x_ptr);printf("&x_ptr = %d\n", &x_ptr);printf("x_ptr = %d\n", x_ptr);

Produce

12359156

2359154 2359156

x

x_ptr


*x_ptr = 1&x_ptr = 2359154x_ptr = 2359156n

Appendice: valore tramite un puntatore

2359154 2359156 x_ptr

12359156

2359154 2359156

x

x_ptr

Tramite l’operatore * applicato al nome di un puntatore è possibile “leggere” il contenuto della cella il cui indirizzo è contenuto nella cella simboleggiata da quel


n

cella simboleggiata da quel puntatore

Soluzioni

Esercizio 6.2

Scrivere un programma che legga 10 numeri interi e restituisca il minimo, usando variabili di tipo pun tatore restituisca il minimo, usando variabili di tipo pun tatore ad int anziché variabili di tipo int .


Soluzioni#include <stdio.h>#include <stdlib.h>

int main() {int i, v, min;int i, v, min;int *min_ptr, *v_ptr;min_ptr = &min;v_ptr = &v;printf("inserisci 10 interi:\n");scanf("%d", v_ptr);//printf("ho letto %d\n", *v_ptr);*min_ptr = *v_ptr;for(i = 1; i < 10; i++) {

scanf("%d", v_ptr);//printf("ho letto %d \ n", *v_ptr);


//printf("ho letto %d \ n", *v_ptr);if(*v_ptr < *min_ptr)

*min_ptr = *v_ptr;}printf("minimo = %d\n", *min_ptr);return 0;

}

Soluzioni

Esercizio 6.3

Scrivere il programma dell’esercizio precedente tramite allocazione dinamica della memoria. Dealloca re tramite allocazione dinamica della memoria. Dealloca re la memoria utilizzata prima della terminazione del programma.


Soluzioni#include <stdio.h>#include <stdlib.h>

int main() {int i, *min, *v;int i, *min, *v;min = malloc(sizeof(int));v = malloc(sizeof(int));printf("inserisci 10 interi:\n");scanf("%d", v);//printf("ho letto %d\n", *v);*min = *v;for(i = 1; i < 10; i++) {

scanf("%d", v);//printf("ho letto %d\n", *v);if(*v < *min)


if(*v < *min)*min = *v;

}printf("minimo = %d\n", *min);free(v); free(min);return 0;

}

Soluzioni

Esercizio 6.4

Scrivere una funzione che dato in ingresso un puntatore ne stampi la dimensione in byte, il valor e, puntatore ne stampi la dimensione in byte, il valor e, l’indirizzo di memoria ed il valore della variabile puntata. Scrivere un programma che ne verifichi il comportamento.


Soluzionivoid infoPtr_int(int **ptr) {

printf("dimensione del puntatore: %d\n", sizeof(*ptr));

printf("valore del puntatore: %p \ n", *ptr);printf("valore del puntatore: %p \ n", *ptr);printf("indirizzo del puntatore: %p\n", &(*ptr));printf("dimensione della variabile puntata: "

"%d\n", sizeof(**ptr));printf("valore della variabile puntata: %d\n\n",

**ptr);}int main() {

Si provi a scrivere una funzionevoid


int main() {int i = 5, *ptr_i;ptr_i = &i;infoPtr_int(&ptr_i);

}

voidinfoPtr_double(double **ptr)

Documents

Passaggio parametri puntatore - Dipartimento di Ingegneria ...bloisi/didattica/... · Passando alla funzione i puntatori a due variabili è possibile modificare il valore delle variabili