Sicuramente avrete già incontrato nei vostri studi il concetto di variabile, almeno in matematica dove si fa un gran parlare di variabile x, variabile y, funzione a due variabili etc.
In generale una variabile è qualcosa che puo’ assumere, a seconda del contesto, valori diversi. Ad esempio nella funzione f(x) = x+3 la variabile x non ha un valore predeterminato ma assume via via valori diversi a seconda del contesto.
In un ipotetico algoritmo potremmo trovare qualcosa del genere: (attenzione, il codice è esemplificativo non provate a compilarlo)

x = temperatura_cpu();
se x > 30
  accendi_condizionatore();
altrimenti
  spegni_condizionatore();

la variabile x non ha un valore predeterminato ma ciascuna volta che l’istruzione “x = temeratura_cpu();” viene eseguita assumerà un valore diverso.
Ovviamente in programmazione si fa un larghissimo uso delle variabili senza le quali i programmi avrebbero un comportamento deterministico, mentre invece analizzando il valore assunto via via dalle variabili si riesce ad ottenere un comportamento diversificato.

Campo di variabilità

Quando si parla di variabili è indispensabile specificare qual è il campo di variabilità, è necessario chiarire quindi quali sono i valori che la variabile può assumere. Tornando all’esempio matematico, la funzione f(x) = x + 3 non specifica da sola quali sono i valori che la x può assumere, anche se di norma quando si usa la x si sottointende che la variabile può assumere tutti i valori della retta reale, mentre se la variabile è una n allora è sottointeso che possa assumere tutti i valori nei naturali. In ogni caso per maggiore precisione si può sempre specificare i valori assunti con la sintassi f: R->R.
Questa premessa matematica solo per sottolineare che quando si parla di variabile è imprescindibile definire anche il suo campo di variabilità.
Quando poi le variabili entrano a far parte dei nostri programmi definire il campo di variabilità non è solo questione di formalismi, ma diventa una vera e propria necessità tecnica.
Per comprendere il perchè di questa necessità dobbiamo premettere che le informazioni all’interno della memoria del computer occupano più o meno spazio a seconda del tipo, non è difficile immaginare che un singolo carattere “A” occupi in memoria meno spazio di quanta ne occupi tutto il testo della divina commedia. Quindi se nel nostro programma stiamo utilizzando una variabile e il suo valore per definizione non è definito a priori, bisogna stabilire quanto spazio riservarle. Se la variabile non fosse accompagnata da un campo di variabilità come ad esempio “testo lungo massimo 100 caratteri” non potremmo mai sapere quanto spazio riservarle e correremmo sempre il rischio che la variabile necessiti di più spazio di quello che le abbiamo riservato. È un pò come sapere che devono arrivare ospiti a cena ma ignorare se saranno 1, 10,100 e così via.

Tipi di dato

Il campo di variabilità all’interno dei programmi si definisce impostando un tipo per la variabile. Questo modo di fare ovviamente non è nuovo, anche in matematica è lecito definire una funzione f(x) = x + 3 con x ∈ R, il che significa di fatto specificare che x è di tipo Reale.
Tra i linguaggi di programmazione esistono linguaggi che si dicono fortemente, debolmente o non tipizzati. Il C appartiene alla categoria dei debolmente tipizzati, questo significa che se avete dichiarato una variabile di un tipo, e questo tipo di dato occupa una certa quantità di spazio in memoria, allora la variabile potrà essere trattata come se fosse di qualsiasi altro tipo di dato che occupa in memoria la medesima quantità di spazio. Questa è una di quelle caratteristiche che fanno si che il C venga considerato un linguaggio relativamente a basso livello perché non si interessa della semantica e del fatto che abbiamo dichiarato una variabile (ad esempio) per contenere un carattere ed invece poi la utilizziamo per memorizzare un numero, perché se i due tipi di dato occupano la stessa quantità di spazio questo non influenza la struttura della memoria e il C “fa solo quello che gli chiedi”.
Altri linguaggi come il Java, invece, si dicono fortemente tipizzati perchè non godono della stessa libertà del C, ma generano un errore se ti tenta di utilizzare una variabile di un tipo come se fosse di un tipo differente. (Ci sono alcune eccezioni, ma riguardano la programmazione ad oggetti, resta valido il principio generale)

I tipi di dato primitivi del C

Prima di definire quali sono i tipi di dato primitivi del C bisogna precisare che vista la diffusione del linguaggio e del proliferare di compilatori per le architetture piu diverse, non è difficile riscontrare differenze tra il proprio compilatore e la definizione ufficiale del linguaggio.
I tipi di dato ufficiali utilizzabil in C sono i seguenti:

• char: Utilizzato per memorizzare un singolo carattere, occupa generalmente un Byte (8 bit)
• int: Utilizzato per memorizzare numeri interi, occupa generalmente 4 byte (32bit) quindi può memorizzare numeri interi compresi nel range da −2.147.483.648 fino a +2.147.483.647 (ricordiamo che 2^32 = 4.294.967.296)
• float: Utilizzato per memorizzare numeri a virgola mobile con precisione singola, occupa 4 Byte come un int.
• double: Utilizzato per memorizzare numeri in virgola mobile con precisione doppia, occupa 8 Byte (128bit)

Oltre a questi semplici tipi di dato esistono dei modificatori, che possono affiancare il tipo di dato creando:

• long int:
• short int:

per questi modificatori è stata lasciata carta bianca sull’implementazione ai produttori di compilatori, le uniche regole che lo standard detta sono:

1. Il tipo Short Int deve essere almeno di 16 bit.
2. Il tipo Long int deve essere almeno di 32 bit.
3. Il tipo Short int non non può essere più grande del tipo Int
4. Il tipo Int non può essere più grande del tipo Long Int.

Altri due modificatori sono:

• Signed
• Unsigned

che si possono affiancare a char e int per creare signed/unsigned char e signed/unsigned int.
Di default le variabili di tipo char e int vengono definite signed quindi il loro range di variabilità e rispettivamente [-127;+128] e [−2.147.483.648; +2.147.483.647] mentre se dichiarate unsigned con lo stesso numero di bit possiamo spostare il range di variabilità portandolo a [0;255] e [0;4.294.967.296]

La dichiarazione delle variabili

Dopo tanta teoria mi sembra il caso di vedere qualche piccolo esempio di come vengono dichiarate le variabili in C.
All’interno di un blocco di codice è buona norma scrivere la dichiarazione delle variabili prima di tutte le altre istruzioni, in questo modo il codice di mantiene pulito e più facile da leggere.
La dichiarazione di una variabile segue la sintassi

tipo_di_dato nome_variabile;

Questa istruzione avvisa il compilatore che nel codice verrà utilizzata una variabile di nome nome_variabile ed il tipo è tipo_di_dato ed è quindi necessario riservarle in memoria lo spazio sufficiente.

Vediamo in questo esempio come vengono dichiarate variabili:

int main (int argc, char **argv)
{
        int variabileIntera;
        float variabileFloat;
        short int variabileShortInt;
        …
        …
}

In questo esempio abbiamo dichiarato tre variabli, una di tipo int, una di tipo float e una di tipo short int. Sul mio pc queste tre istruzioni fanno si che il compilatore riservi 10 byte di memoria per queste tre variabili, 4 byte per l”int ed il float e 2 per lo short int.

Esistono alcune regole che permettono di risparmiare righe di codice quando si scrive un programma, per esempio è possibile dichiarare più variabili dello stesso tipo nella stessa riga di codice separandole da una virgola.

int main (int argc, char **argv)
{
        int primaVariabile, secondaVAriabile;
}

oppure è possibile dichiarare una variabile e assegnarle immediatamente un valore

int main (int argc, char **argv)
{
        int variabileIntera = 42;
}

Attenzione a non cadere in errore, questo codice:

int main (int argc, char **argv)
{
        int variabileUno, variabileDue = 42;
}

assegna il valore 42 solo a variabileDue, non ad entrambe le variabili.

Inizializzazione delle variabili

L’operazione di dichiarazione di una variabile, abbiamo detto più volte, si occupa solo di riservare il giusto numero di byte nella memoria, ma non fa null’altro, soprattutto va notato che l’area della memoria destinata alla variabile non viene “azzerata” in alcun modo, ma resta “sporca” dei dati del programma che l’ha utilizzata prima.
Questo è causa di molti mal di testa ai programmatori meno esperti, perché se nel nostro programma tentiamo di leggere il valore di una variabile appena istanziato otterremo ogni volta valori diversi, perché il valore dipende da quello che è rimasto sulla memoria dai programmi precedenti. Per questo bisogna accertarsi sempre che la prima operazione effettuata su una variabile non sia quella di leggerne il valore, ma bensì quello si assegnarlo. Il processo di assegnare un valore alla variabile appena dichiarata si chiama Inizializzazione.

int main (int argc, char **argv)
{
        int variabileIntera = 0;
        …
        se variabileIntera = 0
allora
…
altrimenti
…
}

int main (int argc, char **argv)
{
        int variabileIntera;
        …
        se variabileIntera = 0
allora
…
altrimenti
…
}

L’operazione di inzializzazione dipende dal tipo della variabile da inizializzare, in questo momento abbiamo incontrato solo variabili di tipo numerico (int, long int etc) e la variabile char che contiene un solo carattere ascii. per queste due variabili l’inzializzazione si fa in questo modo:

Sui nomi delle variabili

Se credete che attribuire un nome ad una variabile sia una cosa semplice allora avete ancora scritto poche righe di codice 🙂

Oltre alle regole dettate dal C che sono:

1. Il primo carattere del nome di una variabile deve essere una lettera o un underscore ( _ );
2. i caratteri successivi possono essere lettere, numeri o underscore.

e che non creano di norma alcun problema, resta il problema di assegnare dei nomi

• significativi: supponiamo di trovare una riga di codice in cui c’è scritto: if (pippo > 18 ) then purtroppo l’aver chiamato la variabile pippo non ci aiuta nella comprensione del codice, mentre se avessimo scritto if (anni > 18) then tutto sarebbe più chiaro. Di solito per essere rendere un nome significativo si possono concatenare due nomi, creando per esempio variabili come annoDiNascita, speseBancarie, numMatricola etc.
• coerenti: esistono diverse scuole di pensiero su come dovrebbero essere scritti i nomi delle variabli (link) ma la cosa più importante indipendentemente da quale stile vogliate seguire è essere coerenti. Se decidete di utilizzare nomi come annoDiNascita non utilizzate nello stesso progetto variabili che si chiamano anno_di_matrimonio perché questa incoerenza vi farà perdere un mare di tempo. Una mia personale convenzione è quella di utilizzare l’iniziale minuscola e poi tutte le iniziali delle eventuali parole successive maiuscole.
• brevi: ok per la significatività, ma una variabile che si chiama temperaturaCPURilevataDalTermostatoInterno è veramente troppo!
• facili da scrivere: TeMpErATuRa non è un nome molto comodo da scrivere, soprattutto se doveste scriverlo cento volte nel vostro progetto!

Prossimamente

Nella prossima lezione metteremo in pratica quello che abbiamo imparato in questa lezione, scriveremo un programma che utilizzi un pò di variabili e vedremo gli operatori logico / matematico di base.

Letture consigliate:

Il linguaggio C. Principi di programmazione e manuale di riferimento (Accademica)
Brian W. Kernighan – Dennis M. Ritchie
Editore: Pearson | Lingua: Italiano | Brossura: 313 pagine
Prezzo Listino: EUR 27,00
Prezzo Promozione: EUR 22,95 con Spedizione gratuita

C. Corso completo di programmazione
Paul J. Deitel – Harvey M. Deitel
Editore: Apogeo | Lingua: Italiano | Brossura: 640 pagine
Prezzo Listino: EUR 39,00
Prezzo Promozione: EUR 33,15 con Spedizione gratuita