Gli array come parametri formali

di funzione

Array e puntatori - II • L’indirizzo di base di un array puo` essere dichiarato come

parametro formale di una funzione nei due modi seguenti:
– utilizzando la notazione con parentesi quadrate degli array
Laboratorio di Informatica I – come puntatore
• Esempio: int f(int [ ]); e` equivalente a int f(int *);
Ferdinando Cicalese int f (int a[ ]) e` equivalente a int f( int *a)
{ {
….. …..
} }

Gli array come parametri formali Array come parametri di funzione:

di funzione “InArray”
• Passando il nome di un array, si passa alla funzione l’indirizzo #define DIM 15 • Prototipo di InArray()
void InArray (int[ ], int);
(chiamata per riferimento) main( )
{
int a[DIM];
• In C non è possibile il passaggio di un array per valore printf (“Inserisci %d interi \n”, DIM);
InArray(a, DIM); • Chiamata di InArray()
}
• Se si vuole che una funzione non modifichi l’array passato
come parametro allora lo si deve copiare in un array temporaneo void InArray (int arr[ ], int n) • Definizione di Inarray()
{int i; •Inarray() legge n interi
if (n > 0) dalla schermo e li inserisce
for ( i = 0; i < n; i++)
scanf(“%d”, &arr [ i ]); nell’array arr[ ]
}

Array come parametri di funzione: Array come parametri di funzione:

“InArray (versione con puntatore)” “Sum”
#define DIM 15 • Prototipo di InArray() #define DIM 15 • Prototipi di:
void InArray (int *, int); void InArray (int[ ], int);
– InArray()
main( ) int sum (int[ ], int);
{ • Il primo parametro main( ) – sum ()
int a[DIM]; e` un puntatore {int a[DIM]; • Chiamata di InArray
printf (“Inserisci %d interi \n”, DIM); InArray(a, DIM); • Chiamata di sum
InArray(a, DIM); • Chiamata di InArray() printf (”La somma è %d\n”, sum(a, DIM));
} } • Definizione di sum()
void InArray(int *p, int n) int sum (int a[ ], int n) – La funzione sum()
{ • Definizione di Inarray() { restituisce la somma
int i; •Inarray() legge n interi int i, sum = 0; degli elementi
for (i=0; i < n; i++) dalla schermo e li inserisce for ( i = 0; i < n; i++) a[0],a[1],…,a[n-1]
scanf (“%d”, p++ ); sum += a [ i ];
nell’array arr[ ] return (sum);
}
}

1
 Array nelle chiamate di funzioni: Funzionamento del passaggio di
“Sum (I versione)” a[ ] come parametro di sum
1019
Comincia a 1020
#define DIM 15 sommare dal primo 1021
elemento a[0] 1022
void InArray (int[ ], int); • con la chiamata sum(a , 5) viene
int sum (int[ ], int); passato a sum() l’indirizzo di base di 1023
a[1]
a[] (= 1021) 1024
main() 1025
{ a[2]
1026
int a[DIM]; • la chiamata sum(&a[DIM-2] , DIM-2) passa 1027
a[3]
InArray(a, DIM); 1028
a sum() l’indirizzo di
printf (”Somma = %d\n”, sum(a, DIM) ); a[4] 1029
a[DIM-2] (= 1021 + (DIM - 2)* sizeof (int) ) 1030
printf (”Somma dei primi 5 = %d\n”, sum(a, 5) ); 1031
printf (”Somma degli ultimi 2 =%d\n”, sum(&a[DIM-2], 2) ); a[5]
1032
} 1033
Comincia a sommare a[6] 1034
dal penultimo .
elemento .
.

Array nelle chiamate di funzioni: Array nelle chiamate di funzioni:

“Sum (II versione)” “Sum (III versione)”
void InArray (int[ ], int); •Questa void InArray (int[ ], int);
int sum (int * , int); int sum (int * , int);
funzione sum() main()
main()
{
ha un {
int a[DIM]; puntatore int a[DIM];
InArray(a, DIM); come primo InArray(a, DIM);
printf (”Somma = %d\n”, sum (a, DIM) ); parametro printf (”Somma = %d\n”, sum (a, DIM) );
printf (”Somma primi 5 = %d\n”, sump(a, 5) ); printf (”Somma primi 5 = %d\n”, sump(a, 5) );
printf (”Somma degli ultimi 2 =%d\n”,sum (&a[DIM-2], 2 ) ); printf (”Somma degli ultimi 2 =%d\n”,sum (&a[DIM-2], 2 ) );
}
• p+i e` }
int sum (int *p, int n) l’indirizzo dell’ int sum (int *p, int n)
{int i, sum = 0; i-esimo {int i, sum = 0; • incrementa p ad ogni
for ( i = 0; i < n; i++) elemento for ( i = 0; i < n; i++, p++ )
sum += * p ; iterazione
sum += * ( p + i ) ; dell’array.
return (sum); return (sum); • somma l’intero
} } puntato da p

Allocazione dinamica di array Le funzioni della libreria

standard per l’allocazione
• void * calloc (int n, unsigned int dim)
• Il compilatore effettua un’allocazione statica di un array in
– alloca spazio contiguo in memoria per n elementi,
base alle dimensioni specificate nella dichiarazione ciascuno di dimensione dim
– inizializza tutti i bit (in tale spazio di memoria) a zero
• Per allocare un array (ad es. di interi) dinamicamente: – in caso di successo restituisce un puntatore di tipo void
che punta all’indirizzo base; in caso di insuccesso
– si dichiara un puntatore (ad intero)
restituisce un puntatore a null
– si alloca una zona di memoria di dimensioni adeguate
• Esempio:
– si usa come se fosse un array
int *p;
– al termine si libera la memoria
p = calloc( 10, sizeof (int) );

2
 Le funzioni della libreria Le funzioni della libreria
standard per l’allocazione standard per l’allocazione
• void * malloc (unsigned int dim_totale) • void free (void *ptr)
– alloca spazio in memoria per dim_totale bytes – se ptr non è null libera la zona di memoria puntata da
– non inizializza la memoria ptr
– in caso di successo restituisce un puntatore di tipo void – se ptr è null non ha nessun effetto
– provoca errore se la memoria puntata da ptr è stata già
che punta allo spazio richiesto; in caso di insuccesso
deallocata
restituisce un puntatore a null
• Esempio:
• Esempio:
int *p; int *p;
p = malloc( 10 * sizeof (int) ); p = calloc( 10, sizeof (int) );
free(p);

Esempio di allocazione dinamica Esempio2: allocazione dinamica

• Il file di intestazione • Il file di intestazione
#include <stdlib.h> #include <stdlib.h>
int sum (int[ ], int);
stdlib.h contiene i stdlib.h contiene i
int sum (int[ ], int);
void InArray (int *, int);
prototipi di calloc() e prototipi di calloc() e
void InArray (int *, int);
malloc() malloc()
main() main()
{ {
int *a, num; int *a, num;
printf (“quanti elementi vuoi inserire?”); • Allocazione di num elementi printf (“quanti elementi vuoi inserire?”);
• Allocazione(mediante malloc)
scanf (“%d”,&num);
di tipo int mediante calloc – cast a (int *)
scanf (“%d”,&num);
– dim interi
a = calloc ( num, sizeof(int) ); a = (int *) malloc ( num * sizeof(int) );
InArray (a, num); InArray (a, num);
• Chiamata di InArray • Chiamata di InArray
printf (“%d”, sum (a , num) ); printf (“%d”, sum (a , num) );
free (a); •Viene liberata la free (a); •Viene liberata la
} memoria allocata memoria allocata
}

Allocazione dinamica Allocazione dinamica

void InArray (int *, int); void InArray (int *, int);
void printarray (int *, int); void printarray (int *, int); Riscrivere lo stesso
main() main() programma utilizzando
{ { la funzione malloc.
int *a, num; int *a, num; Provare a:
printf (“quanti elementi vuoi inserire?”); printf (“quanti elementi vuoi inserire?”);
scanf (“%d”,&num); scanf (“%d”,&num); allocare spazio per n
valori
a = (int *) calloc ( num, sizeof(int) ); a = (int *) calloc ( num, sizeof(int) );
InArray (a, num); •Chiamata di printarray() InArray (a, num); inserirne solo n-2
printarray(p,num); printarray(p,num); stampare gli n valori
free (a); free (a); contenuti nello spazio
} •Definizione di printarray() } allocato
void printarray (int *p, int size) void printarray (int *p, int size)
{ int i; • Stampa l’intero puntato { int i;
for (i=0; i < size; i++) da p e poi incrementa il for (i=0; i < size; i++)
printf (“%d\n”, *(p++) ); puntatore printf (“%d\n”, *(p++) );
} }