Barninga Z
a- a+

Le variabili: dichiarare le var in C

Le variabili 

 

E' il momento di ripescare CIAO.C e complicarlo un poco. 

#include

void main(void);

void main(void)
{
    unsigned int anni;
    float numero;

    anni = 31;
    numero = 15.66;
    printf("Ciao Ciao! Io ho %u anni
" ,anni);
    printf("e questo è un float: %f
" ,numero);
}

 

Nella nuova versione, CIAO2.C abbiamo introdotto qualcosa di molto importante: l'uso delle variabili. Il C consente di individuare una certa area di memoria mediante un nome arbitrario che le viene attribuito con un'operazione detta definizione della variabile; la variabile è ovviamente l'area di RAM così identificata. Ogni riferimento al nome della variabile è in realtà un riferimento al valore in essa contenuto; si noti, inoltre, che nella definizione della variabile viene specificato il tipo di dato associato a quel nome (e dunque contenuto nella variabile). In tal modo il programmatore può gestire i dati in RAM senza conoscerne la posizione e senza preoccuparsi (entro certi limiti) della loro dimensione in bit e dell'organizzazione interna dei bit, cioè del significato che ciascuno di essi assume nell'area di memoria assegnata alla variabile. 

Con la riga 

unsigned int anni;

viene definita una variabile di nome anni e di tipo unsigned integer (intero senza segno): essa occupa perciò una word nella memoria dell'elaboratore e può assumere valori da 0 a 65535. Va osservato che alla variabile non è associato, per il momento, alcun valore: essa viene inizializzata con la riga 

anni = 31;

che costituisce un'operazione di assegnazione: il valore 31 è assegnato alla variabile anni; l'operatore "=" , in C, è utilizzato solo per le assegnazioni (che sono sempre effettuate da destra a sinistra), in quanto per il controllo di una condizione di uguaglianza si utilizza un operatore apposito ("=="). 

Tuttavia è possibile inizializzare una variabile contestualmente alla sua dichiarazione: 

   

unsigned int anni = 31;

 

è, in C, un costrutto valido. 

Nella definizione di variabili di tipo integral, la parola int può essere sempre omessa, eccetto il caso in cui sia "sola": 

unsigned anni = 31;     // OK! sinonimo di unsigned int
long abitanti;          // OK! sinonimo di long int
valore;                 // ERRORE! il solo nome della variabile NON basta!

Dal momento che ci siamo, anche se non c'entra nulla con le variabili, tanto vale chiarire che le due barre "//" introducono un commento, come si deduce dalle dichiarazioni appena viste. Viene considerato commento tutto ciò che segue le due barre, fino al termine della riga. Si possono avere anche commenti multiriga, aperti da "/*" e chiusi da "*/". Ad esempio: 

/* abbiamo esaminato alcuni esempi
   di dichiarazioni di variabili */

Tutto il testo che fa parte di un commento viene ignorato dal compilatore e non influisce sulle dimensioni del programma eseguibile; perciò è bene inserire con una certa generosità commenti chiarificatori nei propri sorgenti. Non è infrequente che un listato, "dimenticato" per qualche tempo, risulti di difficile lettura anche all'autore, soprattutto se questi non ha seguito la regola... KISS, già menzionata. I commenti tra "/*" e "*/" non possono essere nidificati, cioè non si può fare qualcosa come: 

/* abbiamo esaminato alcuni esempi
   /* alcuni validi e altri no */
   di dichiarazioni di variabili */

Il compilatore segnalerebbe strani errori, in quanto il commento è chiuso dal primo "*/" incontrato. 

Tornando all'argomento del paragrafo, va ancora precisato che in una riga logica possono essere definite (e, volendo, inizializzate) più variabili, purché tutte dello stesso tipo, separandone i nomi con una virgola: 

int var1, var2;      // due variabili int, nessuna delle quali inizializzata
    char ch1 = 'A', ch2; // due variabili char, di cui solo la prima inizializ.
5    float num,                    // dichiarazione di 3 float ripartita su 3
          v1,                     // righe fisiche; solo l'ultima variabile
          terzaVar = 12.4;        // e' inizializzata

Soffermiamoci un istante sulla dichiarazione dei 3 float: la suddivisione in più righe non è obbligatoria, ed ha esclusivamente finalità di chiarezza (dove avremmo sistemato i commenti?). Inoltre, e questo è utile sottolinearlo, l'inizializzazione ha effetto esclusivamente sull'ultima variabile dichiarata, terzaVar. Un errore commesso frequentemente dai principianti (e dai distratti) è assegnare un valore ad una sola delle variabili dichiarate, nella convinzione che esso venga assegnato anche a tutte quelle dichiarate "prima". Ebbene, non è così. Ogni variabile deve essere inizializzata esplicitamente, altrimenti essa contiene... già... che cosa? Cosa contiene una variabile non inizializzata? Ai paragrafi successivi l'ardua sentenza... per il momento, provate a pensarci su. 

Inoltre, attenzione alle maiuscole. La variabile terzaVar deve essere sempre indicata con la "V" maiuscola: 

int terzavar;        //OK!
    char TerzaVar;       //OK!
    double terzaVar;     //ERRORE! terzaVar esiste gia'!

 

Non è possibile dichiarare più variabili con lo stesso nome in una medesima funzione (ma in funzioni diverse sì). A rendere differente il nome è sufficiente una diversa disposizione di maiuscole e minuscole. 

I nomi delle variabili devono cominciare con una lettera dell'alfabeto o con l'underscore ("_") e possono contenere numeri, lettere e underscore. La loro lunghezza massima varia a seconda del compilatore; le implementazioni commerciali più diffuse  ammettono nomi composti di oltre32 caratteri. 

double _numVar;
    int Variabile_Intera_1;
    char 1_carattere;             //ERRORE! il nome inizia con un numero

Anche il void type può essere incontrato nelle dichiarazioni: esso può però essere utilizzato solo per dichiarare funzioni o puntatori, ma non comuni variabili; la parola chiave da utilizzare nelle dichiarazioni è void

Per riassumere, ecco l'elenco dei tipi di dato e delle parole chiave da utilizzare per dichiarare le variabili. 

TIPI DI DATO E DICHIARATORI 

 

TIPO
DICHIARATORI VALIDI
character char
unsigned character unsigned char 
short integer short int, short 
unsigned short integer unsigned short int, unsigned short 
integer int
unsigned integer unsigned int, unsigned 
long integer long int, long 
unsigned long integer unsigned long int, unsigned long 
floating point float 
double precision floating point double 
long double precision floating point long double 
void type void

Un'ultima osservazione: avete notato che nelle stringhe passate a printf() sono comparsi strani simboli ("%u" , "%f")? Si tratta di formattatori di campo e indicano a printf() come interpretare (e quindi visualizzare) le variabili elencate dopo la stringa stessa. La sequenza "%u" indica un intero senza segno, mentre "%f" indica un dato di tipo float. Un intero con segno si indica con "%d" , una stringa con "%s" , un carattere con "%c". 

Dalle pagine che precedono appare chiaro che la dimensione dell'area di memoria assegnata dal compilatore ad una variabile dipende dall'ingombro in byte del tipo di dato dichiarato. In molti casi può tornare utile sapere quanti byte sono allocati (cioè assegnati) ad una variabile, o a un tipo di dato. Allo scopo è possibile servirsi dell'operatore sizeof(), che restituisce come int il numero di byte occupato dal tipo di dato o dalla variabile indicati tra le parentesi. 



Ti potrebbe interessare anche

commenta la notizia

C'è 1 commento
Staff
Ti interessano altri articoli su questo argomento?
Chiedi alla nostra Redazione!