Dichiarazioni

Ogni identificatore che il programmatore intende utilizzare in un programma C++, sia esso per una variabile, una costante simbolica, di tipo o di funzione (fanno eccezione le etichette), va dichiarato prima di essere utilizzato. Ci sono diversi motivi che giustificano la necessitÀ di una dichiarazione; nel caso di variabili, costanti o tipi:

consente di stabilire la quantitÀ di memoria necessaria alla memorizzazione di un oggetto;

determina l'interpretazione da attribuire ai vari bit che compongono la regione di memoria utilizzata per memorizzare l'oggetto, l'insieme dei valori che puÃ’ assumere e le operazioni che possono essere fatte su di esso;

permette l'esecuzione di opportuni controlli per determinare errori semantici;

fornisce eventuali suggerimenti al compilatore;

nel caso di funzioni, invece una dichiarazione:

determina numero e tipo dei parametri e il tipo del valore tornato;

consente controlli per determinare errori semantici;

Le dichiarazioni hanno anche altri compiti che saranno chiariti in seguito.

Tipi primitivi

Un tipo È una coppia <V, O>, dove V È un insieme di valori e O È un insieme di operazione per la creazione e la manipolazione di elementi di V.

In un linguaggio di programmazione i tipi rappresentano le categorie di informazioni che il linguaggio consente di manipolare. Il C++ fornisce quattro tipi fondamentali:

char

int

float

double

Il tipo char È utilizzato per rappresentare piccoli interi e caratteri; int È utilizzato per rappresentare interi in un intervallo piÙ grande di char; infine float e double rappresentano entrambi valori in virgola mobile, float per valori in precisione semplice e double per quelli in doppia precisione.

Ai tipi fondamentali È possibile applicare i qualificatori signed, unsigned, short e long per selezionare differenti intervalli di valori; essi inoltre non sono liberamente applicabili a tutti i tipi: short si applica solo a int, signed e unsigned solo a char e int e infine long solo a int e double. In definitiva sono disponibili i tipi:

char

short int

int

long int

signed char

signed short int

signed int

signed long int

unsigned char

unsigned short int

unsigned int

unsigned long int

float

double

long double

Il tipo int È per default signed e quindi il generico tipo int È equivalente al corrispondente tipo signed, invece i tipi char, signed char e unsigned char sono considerati tipi distinti. I vari tipi sopra elencati, oltre a differire per l'intervallo dei valori rappresentabili, differiscono anche per la quantitÀ di memoria richiesta per rappresentare un valore di quel tipo.

Il seguente programma permette di conoscere la dimensione di ciascun tipo come multiplo di char (di solito rappresentato su 8 bit):

#include <iostream.h>

void main()

Una veloce spiegazione sul listato:

la prima riga (#include <iostream.h>) richiede l'uso di una libreria per eseguire l'output su video; la libreria iostream.h dichiara l'oggetto cout il cui compito È quello di visualizzare l'output che gli viene inviato tramite l'operatore di inserimento <<.

L'operatore sizeof(<Tipo>) restituisce la dimensione di Tipo, mentre endl inserisce un ritorno a capo e forza la visualizzazione dell'output. Infine main È il nome che identifica la funzione principale, ovvero il corpo del programma.

Tra i tipi fondamentali sono definiti gli operatori di conversione, il loro compito È quello di trasformare un valore di un tipo in un valore di un altro tipo. Non esamineremo per adesso l'argomento, esso verrÀ ripreso in una apposita appendice.

Variabili e costanti

Siamo ora in grado di dichiarare variabili e costanti. La sintassi per la dichiarazione delle variabili È

<Tipo> <Lista Di Identificatori> ;

Ad esempio:

int a, b, B, c;

signed char Pippo;

unsigned short Pluto; // se omesso si intende int

Innanzi tutto ricordo che il C++ È case sensitive, cioÈ distingue le lettere maiuscole da quelle minuscole, infine si noti il punto e virgola che segue sempre ogni dichiarazione.

La prima riga dichiara quattro variabili di tipo int, mentre la seconda una di tipo signed char. La terza dichiarazione È un po' particolare in quanto apparentemente manca la keyword int, in realtÀ poiché il default È proprio int essa puÃ’ essere omessa; in conclusione la terza dichiarazione introduce una variabile di tipo unsigned short int. Gli identificatori che seguono il tipo sono i nomi delle variabili, se piÙ di un nome viene specificato essi devono essere separati da una virgola.

È possibile specificare un valore con cui inizializzare ciascuna variabile facendo seguire il nome dall'operatore di assegnamento = e da un valore o una espressione che produca un valore del corrispondente tipo:

int a = -5, b = 3+7, B = 2, c = 1;

signed char Pippo = 'a';

unsigned short Pluto = 3;

Se nessun valore iniziale viene specificato, il compilatore inizializza le variabili con 0.

La dichiarazione delle costanti È identica a quella delle variabili eccetto che deve sempre essere specificato un valore e la dichiarazione inizia con la keyword const:

const a = 5, c = -3; // int È sottinteso

const unsigned char d = 'a', f = 1;

const float = 1.3;

Scope e lifetime

La dichiarazione di una variabile o di un qualsiasi altro identificatore si estende dal punto immediatamente successivo la dichiarazione (e prima dell'eventuale inizializzazione) fino alla fine del blocco di istruzioni in cui È inserita (un blocco di istruzioni È racchiuso sempre tra una coppia di parentesi graffe). CiÒ vuol dire che quella dichiarazione non È visibile all'esterno di quel blocco, mentre È visibile in eventuali blocchi annidati dentro quello dove la variabile È dichiarata.

Il seguente schema chiarisce la situazione:

// Qui X non È visibile

} // X ora non È piÙ visibile

All'interno di uno stesso blocco non È possibile dichiarare piÙ volte lo stesso identificatore, ma È possibile ridichiararlo in un blocco annidato; in tal caso la nuova dichiarazione nasconde quella piÙ esterna che ritorna visibile non appena si esce dal blocco ove l'identificatore viene ridichiarato:

// qui È visibile int X

} // X ora non piÙ visibile

All'uscita dal blocco piÙ interno l'identificatore ridichiarato assume il valore che aveva prima di essere ridichiarato:

cout << X << endl; // stampa di nuovo int X

}

Una dichiarazione eseguita fuori da ogni blocco introduce un identificatore globale a cui ci si puÃ’ riferire anche con la notazione ::<ID>. Ad esempio:

int X = 4; // dichiarazione esterna ad ogni blocco;

void main()

Abbiamo appena visto che per assegnare un valore ad una variabile si usa lo stesso metodo con cui la si inizializza quando viene dichiarata. L'operatore È detto risolutore di scope e, utilizzato nel modo appena visto, permette di riferirsi alla dichiarazione globale di un identificatore.

Ogni variabile oltre a possedere uno scope, ha anche un propria durata (lifetime), viene creata subito dopo la dichiarazione (e prima dell'inizializzazione! ndr) e viene distrutta alla fine del blocco dove È posta la dichiarazione; fanno eccezione le variabili globali che vengono distrutte alla fine dell'esecuzione del programma. Da ciÒ si deduce che le variabili locali (ovvero quelle dichiarate all'interno di un blocco) vengono create ogni volta che si giunge alla dichiarazione, e distrutte ogni volta che si esce dal blocco; È tuttavia possibile evitare che una variabile locale (dette anche automatiche) venga distrutta all'uscita dal blocco facendo precedere la dichiarazione dalla keyword static :

void func()

La variabile x viene creata e inizializzata a 5 ogni volta che func() viene eseguita, e viene distrutta alla fine dell'esecuzione della funzione; la variabile c invece viene creata e inizializzata una sola volta, quando la funzione viene chiamata la prima volta, ma viene distrutta solo alla fine del programma. Le variabili statiche conservano sempre l'ultimo valore che viene assegnato ad esse e servono per realizzare funzioni il cui comportamento È legato a computazioni precedenti (all'interno della stessa esecuzione del programma). Infine la keyword static non modifica lo scope.