Lezione 4

Introduzione al linguaggio C
Gli array
nome del vettore (tutti gli elementi
hanno lo stesso nome, c)
Vettori
• Vettore (Array)
– Gruppo di posizioni (o locazioni di memoria)
consecutive
– Hanno lo stesso nome e lo stesso tipo di
dato
c[0]
c[1]
6
c[2]
0
c[3]
72
c[4]
• Per fare riferimento ad un elemento, specificare
– il nome del vettore
– numero di posizione (o indice)
• Formato: nomevettore[numeroposizione]
– il primo elemento è alla posizione 0
– se c è un vettore di n elementi:
c[0], c[1]...c[n-1]
-45
c[5]
1543
-89
c[6]
0
c[7]
62
c[8]
-3
c[9]
1
c[10]
c[11]
6453
78
numero di posizione all’interno del
vettore c
Array ad una dimensione
La forma generale per dichiarare un array monodimensionale è:
tipo nome_variabile[dimensione];
tipo dichiara il tipo di dato degli elementi che costituiscono
l’array
dimensione definisce quanti elementi contiene l’array
Quando l’array è dichiarato, il compilatore alloca un blocco di
memoria per contenere l’array
È possibile accedere ad un singolo elemento dell’array tramite
un indice, che descrive la posizione di un dato elemento
all’interno dell’array stessa.
…continua
Per un array monodimensionale la dimensione totale in byte
occupata viene calcolata in questo modo:
Byte totali = n. di byte variabile_tipo_base X n. di elementi
Nota
L’esempio seguente dichiara un array
chiamato vettore che ha dieci elementi:
intero
int vettore[10];
In C il primo elemento di qualsiasi array ha indice
zero
In questo caso, dato che vettore ha 10 elementi, ha
valori di indice che andranno da 0 a 9.
il primo elemento in vettore è rappresentato da
vettore[0] e l’ultimo da vettore[9].
Esempi di dichiarazione dei vettori
int c[ 10 ];
float myArray[ 3284 ];
• Per dichiarare più vettori dello stesso tipo
– formato simile alle variabili
int b[ 100 ], x[ 27 ];
• Gli elementi di un vettore possono essere utilizzati come
le altre variabili
c[0] = 3;
printf( "%d", c[0] );
– E’ possibile eseguire operazioni nell’indice. Se x = 3,
c[5-2] == c[3] == c[x]
Inizializzazione di un array
Ci sono 2 forme per inizializzare un’array come per tutte le
altre variabili:
•In fase di dichiarazione :
tipo nome_variabile[ ]={e1,…,en};
•tramite indicizzazione diretta all’interno del programma
quando occorre, ad es:
int a[2]; /* dichiarazione array*/
...
a[0]=23; /* inizializzazione array*/
a[1]=100;
Note
• Inizializzare un vettore
int n[5] = {1, 2, 3, 4, 5 };
– Se gli inizializzatori non sono sufficienti, gli
elementi rimanenti sono azzerati
– Se sono troppi, errore di sintassi
int n[5] = {0};
• azzera tutti gli elementi
– In C non ci sono controlli sulla dimensione dei
vettori
• Se la dimensione non è dichiarata gli inizializzatori la
determinano
int n[] = { 1, 2, 3, 4, 5 };
– 5 inizializzatori, quindi il vettore ha 5 elementi
Inizializzazione illegale
In C non è possibile assegnare un array ad un altro.
Pertanto scrivere così è ILLEGALE:
int a[10],b[10];
a=b; /* ERRORE!!! */
Per trasferire il contenuto di un array in un altro è
necessario assegnare individualmente ogni valore
per esempio utilizzando un ciclo for.
1 /*
2
Histogram printing program */
3 #include <stdio.h>
4 #define SIZE 10
5
6 int main()
7 {
8
int n[ SIZE ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
9
int i, j;
10
11
printf( "%s%13s%17s\n", "Element", "Value", "Histogram" );
12
13
for ( i = 0; i <= SIZE - 1; i++ ) {
14
15
16
17
18
19
20
21
22
23 }
printf( "%7d%13d
", i, n[ i ]) ;
for ( j = 1; j <= n[ i ]; j++ )
printf( "%c", '*' );
printf( "\n" );
}
return 0;
/* print one bar */
Esecuzione
Esecuzione
Element
Element
00
11
22
33
44
55
66
77
88
99
Value
Value
19
19
33
15
15
77
11
11
99
13
13
55
17
17
11
Histogram
Histogram
*******************
*******************
***
***
***************
***************
*******
*******
***********
***********
*********
*********
*************
*************
*****
*****
*****************
*****************
**
Esempi di utilizzo dei vettori
• Vettori di caratteri
– La stringa "hello" è in realtà in vettore static di
caratteri
– I vettori di caratteri possono essere inizializzati
usando stringhe letterali
char string1[] = "first";
• le stringhe terminano con il carattere nullo '\0'
• string1 ha in realtà 6 elementi
char string1[] = { 'f', 'i', 'r', 's', 't', '\0' };
…continua
– Accesso ai singoli caratteri
• string1[ 3 ] è il carattere 's'
– Il nome del vettore è l’indirizzo del primo elemento
del vettore stesso, pertanto non è necessario
l’operatore & in scanf
scanf( "%s", string2 ) ;
• Legge i caratteri finchè incontra uno spazio
bianco
• Può scrivere anche oltre la fine del vettore
1
/*
2
Treating character arrays as strings */
3
#include <stdio.h>
4
5
int main()
6
{
7
char string1[ 20 ], string2[] = "string literal";
8
int i;
9
10
printf(" Enter a string: ");
11
scanf( "%s", string1 );
12
printf( "string1 is: %s\nstring2 is: %s\n"
13
"string1 with spaces between characters is:\n",
14
string1, string2 );
15
16
for ( i = 0; string1[ i ] != '\0'; i++ )
17
printf( "%c ", string1[ i ] );
18
19
printf( "\n" );
20
return 0;
21 }
Enter
Enter aa
string1
string1
string2
string2
string1
string1
HH ee ll ll
string:
string: Hello
Hello there
there
is:
is: Hello
Hello
is:
is: string
string literal
literal
with
with spaces
spaces between
between characters
characters is:
is:
oo
Array di dimensioni variabili
In C (ANSI C89) non è possibile definire array di
dimensione variabile; il loro utilizzo, anche se accettato
da alcuni compilatori, è illegale. La dimensione di ogni
array deve essere conosciuta in fase di compilazione.
Programma non conforme
allo standard ANSI C89
#include <stdio.h>
int main()
{
int i;
scanf("%d",&i);
if(i>10)
{
float a[i];
}
return 0;
}
Programma Corretto
#include <stdio.h>
int main()
{
int i;
scanf("%d",&i);
if(i>10)
{
float a[100];
}
return 0;
}
Ancora sulla dimensione
• La dimensione dell’array può essere specificata
tramite
• una costante letterale:
int array[12];
array[12];
• Una costante simbolica creata con #define:
#define MONTHS 12
int array[MONTHS];
array[MONTHS];
Assenza di controllo dei limiti
degli array
Il C non effettua alcun controllo sui limiti degli array.
In altre parole è possibile inizializzare un array di
dimensione N con più di N valori senza avere alcun
messaggio di errore in compilazione
È compito del programmatore garantire che tutti gli
array siano abbastanza grandi da contenere ciò per cui
sono stati creati
int a[ ]={1,2,3,4,5};
int b[3];
a[8]=9; /* errore ho sforato in memoria */
for(i=0;i<5;i++) b[i]=a[i]; /* non dà errore */
Vettori multidimensionali
• Vettori con più indici
– Tabelle con righe e colonne (vettori m per n)
– Vettori bidimensionali o matrici : il primo indice
identifica la riga, il seconda la colonna
Colonna 0
Colonna 1
Colonna 2
Colonna 3
Riga 0
a[0][0]
a[0][1]
a[0][2]
a[0][3]
Riga 1
a[1][0]
a[1][1]
a[1][2]
a[1][3]
Riga 2
a[2][0]
a[2][1]
a[2][2]
a[2][3]
indice di colonna
nome del vettore
indice di riga
Array bidimensionali
Gli array a più dimensioni vengono inizializzati allo stesso
modo di quelli monodimensionali, ad esempio:
int sqrs[4][2] = {
0
1
Indice
1,1,
destro
0
1
1
2,2,
3,9,
1
2
4
4,16
};
2
3
9
Inizializza un array chiamato
sqrs con i numeri da 1 a 4 ed i
3
4
16
loro quadrati.
Indice sinistro
Note
• Inizializzazione
int b[2][2]={1,2,3,4};
• int b[ 2 ][ 2 ] = { { 1, 2 }, { 3, 4 } };
1
2
3
4
– I valori saranno raggruppati per riga all’ interno di
parentesi graffe
– Se non sono sufficienti, gli elementi non
inizializzati sono posti a zero
int b[ 2 ][ 2 ] = { { 1 }, { 3, 4 } };
• Per riferirsi ad un elemento
– Specificare la riga, poi la colonna
printf( "%d", b[ 0 ][ 1 ] );
1
0
3
4
Esempio
Indice destro
#include <stdio.h
<stdio.h>
stdio.h>
int main()
{
int i,j,val[3][4];
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
{
val[i][j]=(i*4)+j+1;
val[i][j]=(i*4)+j+1;
}
}
return 0;
}
0
1
2
3
0
1
2
3
4
1
5
6
7
8
2
9
10
11
12
Indice sinistro
val[1][2]
n. byte=righe x colonne x n. byte del tipo
int val[3][4];
Address(val[i][j])=Address(val[0][0])+i*4+j
Array bidimensionali
#define M 5
#define N 9
int main()
{
int num[M][N];
…
return 0;
}
void funzione(num,M,N)
{
int num[M][N]; /*ILLEGAL
DECLARETION*/
…
return 0;
}
Array 3-dimensionale
Esercizi
1. Scrivere un programma che inizializza un
vettore monodimensionale di interi e poi
copia il vettore in un altro vettore di stessa
dimensione.
2. Scrivere un programma che stampa i
numeri primi minori di 100 (Eratostene)
3. Scrivere un programma che calcola il mcd
di due numeri positivi (Euclide)
4. Scrivere un programma che ordina n numeri
casuali con il metodo bubblesort