L’array

L’array

In generale i dati sono le informazioni rappresentate in una forma trattabile con il computer.
In molti problemi si ha la necessità di aggregare molti dati di tipo semplice, per facilitarne la rappresentazione e rendere più veloce il loro ritrovamento.
I dati sono cioè organizzati in un insieme che prende il nome di struttura di dati.
L’array è un insieme di elementi omogenei tra loro. Con una variabile possiamo indicare solo un dato, con l’array possiamo indicare tanti dati dello stesso tipo con un solo nome collettivo di variabile: l’identificatore dell’array. Gli elementi si distinguono uno dall’altro attraverso l’indice che viene assegnato nell’array, e che viene posto accanto all’identificatore dell’array.
L’array è quindi un insieme omogeneo di dati: è un esempio di struttura di dati. Nella terminologia matematica al posto del termine array si usa il termine vettore.
L’array si ottiene in C aggregando variabili dello stesso tipo. Un array si definisce nella zona delle dichiarazioni nel modo seguente:

tipo NomeArray[dimensione];

Alla normale dichiarazione di variabile si aggiunge semplicemente, tra parentesi quadre, il numero di elementi (dimensione) che compongono l’array.
Le componenti di un array possono essere non solo numeriche, ma di uno qualsiasi dei tipi standard del linguaggio C.
Per esempio, la seguente dichiarazione crea un array di 10 coefficienti di tipo double:

double coeff[10];

La numerazione degli indici nel linguaggio C inizia da 0 e quindi gli elementi dell’array sono: coeff[0], coeff[1], …, coeff[9].
Nel programma la componente dell’array viene indicata dal nome dell’array, seguito dall’indice della componente, racchiuso tra due parentesi quadre.
Per esempio, si può usare un’istruzione di assegnazione:

coeff[i] = 7;

oppure produrre in output i valori delle componenti di un array con un ciclo for:

for (i=0; i<10; i++)
{
printf(“%f \n”, coeff[i]);
}

Se una variabile è definita di tipo array, deve essere sempre usata all’interno del programma accompagnando l’identificatore della variabile con un indice.
L’indice è solitamente una variabile di tipo int.
È possibile inizializzare un array assegnando i valori alle componenti in fase di dichiarazione, come nell’esempio seguente:

double numeri[3] = {2.5, 1.2, 3.0};

I valori sono indicati all’interno delle parentesi graffe e separati dalla virgola.
Negli esempi precedenti, sono state utilizzate variabili stringa come la seguente:

char nome[30];

La notazione è coerente con la dichiarazione degli array, in quanto nel linguaggio C le stringhe sono considerate come un array di caratteri. Quindi il tipo stringa è una struttura di tipo array le cui componenti sono del tipo char.
Per esempio, si consideri il seguente programma:

#include <stdio.h>
char stringa[10]=”abcdefghi”;
int main(void) {
int i;
for(i=0;i<9;i++)
{
printf(“Stringa[%d] = %c \n”,i, stringa[i]);
}
return 0;
}

Esso produce in output il valore di ogni componente dell’array stringa:

Stringa[0] = a
Stringa[1] = b
Stringa[2] = c
Stringa[3] = d
Stringa[4] = e
Stringa[5] = f
Stringa[6] = g
Stringa[7] = h
Stringa[8] = i

Come si vede dal programma, l’array ha dimensione 10, ma la stringa è formata da 9 caratteri (dall’indice 0 all’indice 8). Infatti il compilatore, nella rappresentazione interna, aggiunge automaticamente al termine di una stringa costante il carattere Nul del codice ASCII che corrisponde alla sequenza di escape \0 (carattere terminatore di stringa), in modo che il programma possa trovarne la fine.
Pertanto la dimensione effettiva dell’array è superiore di una unità al numero di caratteri che formano la stringa.

Un’ultima considerazione sugli array riguarda il passaggio di parametri alle funzioni. Quando un array viene passato come parametro ad una funzione, in realtà viene passata la locazione (cioè l’indirizzo) della prima componente dell’array. All’interno della funzione, il parametro diventa una variabile come le altre: il nome dell’array è a tutti gli effetti una variabile contenente un indirizzo, cioè un puntatore. Di conseguenza quando occorre effettuare il passaggio per referenza di un array alla funzione, basta indicare il nome dell’array. Si deve anche osservare che il passaggio per referenza è il solo modo di passare un array come parametro.

ESEMPIO: Acquisire da tastiera due array e sommare le loro componenti

L’esercizio si divide in due parti. Nella prima parte si deve affrontare il problema di acquisire da tastiera gli elementi di ciascun vettore.
Per memorizzare tali elementi si utilizza una struttura di tipo array.
La seconda parte è relativa alla somma degli elementi dei vettori: per ottenere il risultato è necessario accumulare il valore di ciascun componente del vettore.

Programma C

/* Somme.c: somma le componenti di due array */
#include <stdio.h>
#define max 100

/* prototipi delle funzioni */
int ChiediDimensione(void);
void CaricaVettore(int v[], int d);
int Somma (int v[], int d);

/* funzione principale */
int main(void)
{
int n;
int v1[max], v2[max];
int tot1, tot2;
n = ChiediDimensione();
printf(“Carica gli elementi del primo vettore \n”);
CaricaVettore(v1,n);
printf(“Carica gli elementi del secondo vettore \n”);
CaricaVettore(v2,n);
tot1 = Somma(v1,n);
tot2 = Somma(v2,n);
printf(“Somma del primo vettore = %d \n”,tot1);
printf(“Somma del secondo vettore = %d \n”,tot2);
return 0;
}

/* dimensione dell’array */
int ChiediDimensione(void) {
int d;
do
{
printf(“Dimensione degli array: “);
scanf(“%d”, &d);
} while (d<1 || d>max);
return d;
} /* ChiediDimensione */

/* caricamento delle componenti */
void CaricaVettore(int v[], int d) {
int i;
for (i=0; i<d; i++)
{
printf(“Elemento di posto %d: “, i);
scanf(“%d”, &v[i]);
}
return;
} /* CaricaVettore */
/* somma delle componenti */
int Somma (int v[], int d)
{
int i;
int s = 0;
for(i=0;i<d;i++) s+=v[i];
return s;
} /* Somma */

Nel programma precedente si può osservare che la specificazione della dimensione degli array v, che sono parametri formali delle funzioni, può essere tralasciata.