Pascal/Array

Wikibooks, manuali e libri di testo liberi.
Jump to navigation Jump to search

Analizzeremo in questa unità l'uso degli array, un tipo di dato molto potente che consente di immagazzinare informazioni in modo semplice e veloce.

Vettori[modifica]

Un metodo molto diffuso e comodo di rappresentazione e ordinamento di dati consiste nell'uso di una tabella.
Ad esempio:

Indice 1 2 3 4 5 6 7 8 9 10
Valori valore 1 valore 2 valore 3 valore 4 valore 5 valore 6 valore 7 valore 8 valore 9 valore 10

Se diamo un nome alla tabella, ad esempio Array, possiamo indicare il valore dell'elemento di indice 8 in questo modo:

 Array[8] {indica l'elemento di posizione 8}

così come

 Array[9] {indica l'elemento di posizione 9}

e così via.

Una struttura come quella dell'esempio precedente è chiamata vettore: a ogni posizione (1, 2, ..., 10) nella tabella corrisponde un valore (valore 1, valore 2, ..., valore 10): la prima colonna della tabella in questo caso si chiama indice del vettore.
Il vettore consente di identificare un gruppo di dati con un nome collettivo (Array dell'esempio precedente) e di poter individuare ogni singolo dato attraverso un indice racchiuso tra parentesi quadre, il quale rappresenta la posizione occupata dal dato nella tabella.

Anche in Pascal, così in altri linguaggi di programmazione, si possono strutturare i dati in maniera simile tramite gli array.

Gli array in Pascal[modifica]

Per dichiarare un vettore in Pascal è necessario indicare le diverse posizioni possibili (normalmente si usano i numeri) e il tipo di dato che conterrà ciascun valore dell'array (nella nostra tabella, il tipo di dato dei valori della riga Valore):

var
 nome_variabile: array[1..n] of tipo_del_dato;

che indica che il vettore nome_variabile avrà come posizioni i numeri da 1 a n (la notazione x..y dove x e y sono due valori dello stesso tipo indica tutti i valori compresi tra x e y).
Notare che quello indicato tra parentesi non è altro che un subrange, e quindi sono ammesse anche dichiarazioni come:

 var
 scheda: array['a'..'z'] of integer

e così vale per gli altri tipi di dati, anche quelli enumerativi. Valgono anche dichiarazioni come:

type
    mese : (gen, feb, mar, apr, mag, giu, lug, ago, set, ott, nov, dic);
var
    nomi_mesi: array[mese] of string;

Per accedere ai valori dell'array, è sufficiente comportarsi come con le variabili normale, usando la notazione

nome_array[indice]

Ad esempio:

scheda['a'] := 45;
writeln(scheda['a']);

È possibile dichiarare gli array anche con un altro metodo:

type
  nome_del_tipo=array[1 .. n] of tipo_del_dato;
 var
  nome variabile:nome_del_tipo;

Per leggere e scrivere gli elementi di un vettore di N elementi in Pascal è possibile usare un ciclo for:

for I:=1 to N do
 readln(vettore[I]);

for I:=1 to N do
 writeln(vettore[I]);

All'aumentare del contatore I, il programma scorre i posti del vettore. Nel caso di array che utilizzano indici non interi, si userà ad esempio:

for I := 'a' to 'z' do
 readln(vettore[I]);

Array bidimensionali[modifica]

Prendiamo come esempio questa tabella:

1 2 3 4 5 6 7 8 9 10
1 array[1,1] array[1,2] array[1,3] array[1,4] array[1,5] array[1,6] array[1,7] array[1,8] array[1,9] array[1,10]
2 array[2,1] array[2,2] array[2,3] array[2,4] array[2,5] array[2,6] array[2,7] array[2,8] array[2,9] array[2,10]
3 array[3,1] array[3,2] array[3,3] array[3,4] array[3,5] array[3,6] array[3,7] array[3,8] array[3,9] array[3,10]

Nel vettore, il posto nella tabella è individuato da un indice; nella tabella bidimensionale, invece, da una coppia di indici. Una tabella bidimensionale è anche chiamata matrice.

Una vettore bidimensionale si dichiara in questo modo:

var
 nome_variabile: array[1 .. n,1 .. m] of tipo_del_dato;

oppure, analogamente all'esempio precedente

type
 nome_del_tipo = array[1 .. n, 1 .. m] of tipo_del_dato;
var
 nome variabile: nome_del tipo;

Per leggere e scrivere i dati di una matrice di N righe e M colonne in Pascal si possono usare due cicli for annidati:

for I:=1 to N do
 for J:=1 to M do
  readln(array[I,J]);

for I:=1 to N do
 for J:=1 to M do
  writeln(array[I,J]);

Utilizzi[modifica]

L'utilizzo degli array è molto comodo, perché permette di gestire facilmente grandi quantità di dati. Vediamo ad esempio questo programma per un ipotetico sistema di gestione degli alunni:

program verifica;
var numalunni, puntimax, i : integer;
    punti, voto: array[1..100] of real;
    sommavoti : real;
    op : char;
begin
    write('Quanti alunni? '); readln(numalunni);
    write('Qual era il punteggio massimo? '); readln(puntimax);
    for i := 1 to numalunni do
    begin
        write('Inserisci il punteggio per l''alunno ', i, ' ');
        readln(punti[i]);
    end;
    writeln('I dati sono stati memorizzati');
    {qui si possono effettuare altre operazioni}
    {qui si possono riprendere i dati memorizzati in precedenza}
    sommavoti := 0;
    for i := 1 to numalunni do
    begin
        voto[i] := (punti[i] / puntimax ) * 10;
        writeln('Il voto per l''alunno ', i, ' e'' ', voto[i]:3:1);
        sommavoti := sommavoti + voto[i];
    end;
    readln;
    writeln('La media dei voti e'' ', sommavoti/numalunni:3:1);
    readln;
end.

Un'altra utilità degli array è quella di poter accedere ad un valore anche senza saperne il suo nome, ma solo tramite un valore immesso dall'utente. Ad esempio, volendo convertire il numero di un mese nel nome corrispondente, senza array, bisognerebbe fare ricorso ad un costrutto case... of. Usando i vettori, invece, è sufficiente dichiarare un array nomeMese[1..12] e assegnare ad ogni posizione il nome del mese interessato. Per ottenere poi il nome del mese n, basterà scrivere nomeMese[n].

Esercizi[modifica]

  • Creare un programma che stampi i primi n numeri della successione di Fibonacci (la serie di Fibonacci è una serie di numeri F dove F0 = 0, dove F1 = 1 e ciascun altro dove Fn = Fn-1 + Fn-2)