Preparazione per l'orale di Elementi di programmazione

Array e stringhe

Definizione di un array

Un array è un insieme omogeneo di dati (dello stesso tipo). Ad esempio, int array[100] sono tutti interi, non ci possono essere float all'interno. Il singolo elemento dell'array è individuato da un indice che ne specifica la posizione. L'indice assume valori da 0 a n-1 (0 è la base, dato che si inizia a contare da 0), e n è la dimensione massima dell'array.

NOTA: andare oltre la dimensione massima porta al "segmentation fault" (aree di memoria non occupate dall’array), infatti spesso la dimensione massima è dichiarata abbastanza grande, ad esempio N_MAX==100.

Dichiarazione di un array

Per la dichiarazione dell'array devono essere definiti:

tipo nome [dimensione max];

Es: int v[100];

Inizializzazione di un array

Un array può essere inizializzato in due modi diversi (in fase di dichiarazione):

• int array[10] = {elementi...}; in questo modo la dimensione è ben specificata indipendentemente dagli elementi.
• int array[] = {elementi}; il compilatore, in base a quanti valori ci metti dentro, deduce la dimensione dell'array.

Dopo aver dichiarato l'array, è possibile inizializzarne un singolo elemento specificando l'indice. Esempio: int array[10]; array[2] = 1; l'array in posizione 3 avrà il valore 1. L'array può anche essere riempito grazie a un ciclo for e un indice che si incrementa.

Architettura hardware

Il tipo definisce quanti byte occorrono per memorizzare ogni singolo elemento del vettore. Lo spazio di memoria necessario per tutto l'array è sizeof(tipoArray) * dimensione array. Il nome dell'array è l'indirizzo del primo elemento: il valore all'indirizzo di memoria "nomeArray + 3 * sizeof(tipoArray)" è il quarto elemento (Array[3]). Un array di tipo int ha dimensione 4 byte. Quindi ogni elemento dell’array occuperà 4 byte.

Stringhe

La stringa è un array di caratteri:

Si dichiara come un array: char stringa[dimensione];

Si inizializza in fase di dichiarazione: char stringa[dimensione] = "parola"; (dimensione definita) o char stringa[] = "parola"; (dimensione dedotta dal compilatore).

Per leggere una stringa da tastiera si usa scanf (ma legge solo fino al primo spazio). Esistono funzioni apposite per le stringhe: gets(stringa); legge da tastiera anche con gli spazi; puts(stringa); è equivalente di printf("%s", stringa);

Matrici

Una matrice è un array bidimensionale, composto da N righe e M colonne. Quando la matrice ha lo stesso numero di righe e di colonne si dice matrice quadrata. In memoria, la matrice è disposta in modo sequenziale, come gli array. Tuttavia, il programmatore non percepirà questa disposizione, vedendo la matrice con la sua forma.

Quando si dichiara una matrice, si seguono gli stessi passaggi della dichiarazione di un array, esempio:

tipo NOME[nRighe][nColonne]; Es: int matrice[2][4]; int matrice[N][N];

Si può, come per gli array, dichiarare e inizializzare una matrice: int matrice[2][2] = {1, 2, 3, 4};

Il numero di elementi massimo che una matrice può contenere è nRighe x nColonne. Il nome della matrice equivale all’indirizzo di memoria del primo elemento. Quando si dichiara una matrice, bisogna SEMPRE specificarne le dimensioni, altrimenti il programma non verrà compilato.

Gestione in memoria

Come si vede nell’immagine, C memorizza per riga (come un array):

Es: una matrice tipo [1,4,7][2,5,8][3,6,9] viene memorizzata come: [1,4,7,2,5,8,3,6,9]

Per conoscere l’elemento: nomeMatrice + i * numeroRighe * sizeof(tipoMat) + j * sizeof(tipoMat)

Files binari

Il linguaggio C permette di operare su file costituiti da sequenze lineari di byte, conservati nella memoria di massa.

Esistono 2 tipi di files:

• Binario: un file di tipo .bin in cui le informazioni sono scritte in linguaggio macchina
• Formattato: un file di tipo .txt in cui le informazioni sono scritte sotto forma di caratteri ASCII

NOTA: nei moderni sistemi operativi, per ovviare alla lentezza delle memorie di massa, le operazioni su di essa vengono fatte in momenti in cui l’elaboratore è più scarico per motivi di efficienza.

Funzioni per operare su file

Nella libreria stdio.h esistono alcune funzioni per operare su file.

• Apertura: Viene creato un canale tra il programma e l'istanza del file nel filesystem con fopen.
• Scrittura: Vengono inviati bytes dal programma al filesystem attraverso il canale con fwrite (binario), fprintf (formattato), fputs (formattato stringhe), fputc (formattato carattere).
• Lettura: Vengono inviati bytes dal filesystem al programma con fread (binario), fscanf (formattato), fgets (formattato stringhe), fgetc (formattato carattere).
• Chiusura: Viene svuotato il canale e rilasciate le risorse utilizzate per la gestione del file con fclose.

Apertura del file

Per aprire un file, innanzitutto bisogna creare una variabile FILE POINTER, cioè un puntatore a file in questo modo: FILE *fp;

Dopodiché, bisogna utilizzare la funzione fopen.

fp = fopen("nome file", "operazioniDaEseguire");

In questo modo si assegna al puntatore fp il file da aprire. La variabile fp verrà usata per altre operazioni come la chiusura ecc.

Esempio fopen:

fp = fopen("input.txt", "r");

In questo caso si sta andando ad aprire il file "input.txt". Il secondo parametro specifica il tipo di operazione che si andrà a fare sul file.