Variabili. Programma principale: funzione main. Funzioni

Transcript

1 Un programma descrive al computer, in estremo dettaglio, la sequenza di passi (istruzioni) necessari a svolgere un determinato compito o risolvere un particolare problema. Un linguaggio di programmazione di alto livello come il C++ permette di scrivere un programma in maniera intuitiva una volta che se ne conosca la sintassi e la semantica. Le istruzioni del programma in C++ non sono direttamente eseguibili dal computer e vanno perciò tradotte (compilate) in linguaggio macchina. Variabili Le variabili sono gli oggetti su cui le istruzioni del C++ agiscono. Tutti gli oggetti che vengono utilizzati all interno di un programma di C++ devono essere note al programma prima del loro utilizzo. Rendere noto un oggetto (dichiarazione) significare scrivere una istruzione in cui si afferma che un certo nome da quel momento in poi identifica una variabile con un tipo di dato (int, float, char...) specifico. Una dichiarazione di una variabile è del tipo: tipo_di_dato nome_variabile; Programma principale: funzione main Ogni programma C++ deve contenere una (ed una sola) funzione principale, quella cioè che viena eseguita quando il programma compilato viene eseguito. Questa funzione principale viene chiamata main, e nella sua forma più semplice deve essere della forma: int main() { return 0; } Funzioni Un blocco di istruzioni C++ può essere raggruppato in una funzione, in modo che ogni volta che si debba utilizzare quel blocco di istruzioni, invece di scriverle esplicitamente nel programma, si possa richiamare il nome della funzione che rappresenta quel blocco di istruzioni. In C++ le funzioni si scrivono come: tipo_di_dato NomeFunzione(tipo_di_dato parametro1,..., tipo_di_dato parametron) { istruzioni; } L identificatore di tipo di dato (ad es. int, double o char) prima del nome della funzione indica qual è il tipo di dato del risultato restituito dalla funzione tramite un comando return. Il NomeFunzione permette di richiamare la funzione all interno di un programma attraverso il suo nome. Tra parentesi tonde dopo il nome della funzione si trova la lista (eventualmente vuota, come nel caso della funzione principale main()) dei parametri il cui valore viene fornito come ingresso alla funzione. Ogni funzione conosce infatti unicamente le variabili dichiarate al suo interno e quelle passate come parametri. All interno delle parentesi graffe dopo la lista dei parametri c è il corpo della funzione, cioè la sequenza di istruzioni che vengono eseguite dalla funzione.

2 Notare che alla fine della lista dei parametri non c è il punto e virgola, indicando che il blocco di istruzioni all interno delle successive parentesi graffe fanno effettivamente parte della funzione e ne sono il corpo. Prototipi Come le variabili devono essere dichiarate prima di poter essere utilizzate, così anche l esistenza di una funzione deve essere nota prima che essa possa essere utilizzata. Il compilatore, per una analisi della correttezza sintattica e semantica del programma scritto, si accontente di richiedere che sia nota la forma esteriore di una funzione (il suo prototipo), formata dal tipo di dato di ritorno, il nome della funzione e la sua lista di parametri. Il prototipo di una funzione generica sarà dunque: tipo_di_dato NomeFunzione(tipo_di_dato parametro1,...,tipo_di_dato parametron); Notare che alla fine del prototipo della funzione c è il punto e virgola, che indica la fine dell istruzione. Se l analisi sintattica e semantica è corretta, il passo della compilazione che si occupa del collegamento delle varie funzioni utilizzate (linker), cercherà il codice sorgente della funzione. File sorgente e file di intestazione Per poter compilare un programma, le istruzioni C++ devono essere salvate in uno o più file di testo con estensione.cpp (file sorgente). All interno dei file sorgente che vengono compilati assieme deve esserci una ed una sola funzione main(), e deve essere presente il codice sorgente di tutte le funzioni ausiliarie che vengono utilizzate dal programma. Dal momento che però le funzioni devono essere note prima di essere utilizzate, è importante l ordine in cui vengono scritte nei file sorgenti. Inoltre i prototipi delle funzioni presenti in file sorgenti diversi devono essere esplicitamente scritte all inizio dei file in cui non sono definite per poter essere utilizzate. Per semplificare questo meccanismo, e far sì che l ordine in cui sono scritte le funzioni non influenzi la compilazione, è possibile raccogliere i prototipi delle funzioni in un file di intestazione: esso è un file di testo con estensione.h (abbreviazione di header), all interno del quale sono presenti solo prototipi di funzioni. Se scrivo delle funzioni in un file Funz1.cpp, è buona norma mettere i loro prototipi nel file Funz1.h. I file di intestazione vanno inclusi all interno dei file sorgenete attraverso la direttiva al compilatore: #include NomeHeader.h I file di intestazione definiti dall utente vanno identificati fra virgolette, mentre quelli contenenti i prototipi delle funzioni di qualche libreria standard di C++ vanno scritti fra i simboli di maggioe e minore: #include <iostream> #include <cmath> Librerie di funzioni Un insieme di funzioni possono essere compilate e raccolte in librerie. In tale maniera è possibile saltare il passo della compilazione di tali funzioni, essendo sufficiente il passo di collegamento (link).

3 Le librerie standard del C++ vengono collegate automaticamente al programma scritto dal programmatore, qualora una delle loro funzioni venisse utilizzata. Così, una volta che siano inclusi i prototipi delle funzioni presenti nella libreria iostream in modo che le funzioni siano note al programma, durante la compilazione ed il collegamento, le librerie vengono automaticamente collegate. Array Un array (o vettore) e una sequenza di dati dello stesso tipo. Permette di gestire un insieme di dati sequenziali utilizzando un solo identificativo (il nome della variabile array), e di accedere ad ogni dato attraverso la sua posizione nella sequenza. La dichiarazione di una variabile array è del tipo: tipo_di_dato nome_variabile[dimensione_array]; In tale maniere si crea un array chiamato nome_variabile, il cui numero di elementi è dimensione_array, e i cui elementi sono tutti del tipo di dato (int, char, float,...) tipo_di dato. Nella dichiarazione di tale variabile, le parentesi quadre identificano che si sta creando un vettore, e il valore compreso tra di esse indica la dimensione del vettore (il numero di elementi consecutivi per cui viene riservato dello spazio in memoria). Dopo aver dichiarato l array, è possibile accedere ad ogni elemento tramite l indicizzazione, cioè indicando la posizione dell array alla quale vogliamo accedere per leggerla o per scriverci un valore: nome_variabile[posizione]; La posizione deve essere un numero intero compreso fra 0 e (dimensione_array-1). Puntatori Alle volte pò essere utile poter accedere al valore di una posizione di memoria (o di una variable) attraverso un riferimento ad essa, cioè attraverso il suo indirizzo di memoria. Il C++ fornisce la possibilità di utilizzare delle variabili puntatore, che sono delle variabili che contengono un indirizzo. Le variabili puntatore in realtà, devono contenere già al loro interno l informazione su come interpretare il valore che si trova all indirizzo che contengono (che puntano), perciò nella loro dichiarazione è necessario indicare il tipo di dato a cui si riferiscono. La dichiarazione di una variabile puntatore è del tipo: tipo_di_dato *nome_variabile; L asterisco indica che la variabile chiamata nome_variabile contiene l inidirizzo di un dato tipo_di_dato. Per accedere al valore contenuto nell indirizzo di una variabile puntatore, si utilizza l operatore di dereferenziamento che è l asterisco *. Ad es: double *puntatore; double valore; valore=*puntatore; dichiaro una variabile puntatore a double ed una variabile double. Con l istruzione di assegnazione accedo al valore contenuto nell indirizzo contenuto in puntatore attraverso il dereferenziamento, e assegno tale valore alla variabile valore. E possibile parimenti ottenere l indirizzo di una variabile attraverso l operatore & :

4 double *puntatore; double valore; puntatore=&valore; In tal modo assegno alla variabile puntatore il valore dell indirizzo della variabile valore. Relazione fra puntatori e array Quando si dichiara una variabile array, la variabile in realtà rappresenta solo l indirizzo del primo elemento del vettore, e l operazione di indicizzazione mi permette di leggere i dati spostando la posizione di lettura in maniera relativa rispetto al primo elemento. Dunque, essendo una variabile array semplicemente l indirizzo del suo primo elemento, potrei pensare di utilizzare una variabile puntatore per fare la stessa cosa. In effetti posso utilizzare le parentesi quadre per spostarmi di un certo numero di dati a partire da un indirizzo tenuto in una variabile puntatore, allo stesso modo in cui lo faccio per un array: double *puntatore; puntatore[2]; In tal modo, a partire dall indirizzo contenuto in puntatore, mi sposto dello spazio di due double in memoria e leggo un double a partire da tale posizione: bisogna però fare attenzione che la memoria all indirizzo contenuto in puntatore e non è riservata come quando si dichiara un array. Si può assegnare una variabile array ad una variable puntatore, ed in tal modo entrambe punteranno al primo elemento del vettore: double *puntatore; double vettore[10]; puntatore=vettore; Oppure posso utilizzare operatori aritmetici su variabili vettore come se fossero puntatori: char vettore[10]; vettore=vettore+1; l indirizzo contenuto in vettore sarà adesso l indirizzo del secondo elemento dell array originale, dal momento che all inidirizzo originale ho aggiunto al dimensione di una variabile char. Infatti ogni volta che ci si sposta da un indirizzo di un numero intero di posizioni, ci si sposta di un numero intero di elementi del tipo di dato del vettore o dell array. Visibilità delle variabili Una coppia di parentesi graffe delimita un blocco di codice. Ogni variabile dichiarata all interno di un blocco di codice viene eliminata quando il programma termina di eseguir le istruzioni in esso contenute e ne esce: le variabili sono perciò visibili solo localmente in ogni blocco di codice racchiuso tra due parentesi graffe. Una variable dichiarata all interno di un blocco, con lo stesso nome di una variabile dichiarata all esterno del blocco, rappresenta una variabile differente a tutti gli effetti, e nasconde la variabile dichiarata esternamente. Tutte le modifiche e le operazioni compiute nel blocco di codice agiranno sulla variabile locale, e non saranno disponibili un volta che si esca dal blocco:

5 int x; x=0; { int x; x=1 ; } cout << x; Le variabili all interno ed all esterno della coppia di graffe, pur chiamandosi con lo stesso nome, sono a tutti gli effetti differenti: la variabile dichiarata fuori dalle parentesi viene nascosta da quella all interno durante l esecuzione delle istruzioni all interno delle parentesi graffe, così l assegnazione del valore 1 a x vale unicamente per la variabile interna. L istruzione di visualizzazione cout è al di fuori delle parentesi graffe, la dichiarata localmente a quel blocco di codice non è più visibile, e dunque il valore visulaizzato sarà 0. Passaggio dei parametri: per valore e per riferimento Quando delle variabili vengono passate come ingresso di una funzione, il loro valore viene copiato in corrispondenti variabili locali alla funzione in esecuzione. Questo è quello che va sotto il nome di passaggio dei parametri per valore, perchè non viene realmente passata la variabile alla funzione, ma solo il suo valore. Questo fa sì che il risultato di eventuali modifiche apportate a tale valore all interno della funzione (che è un blocco di codice), non si rifletta sulla corrispondente variabile originale il cui valore è stato passato alla funzione. Il C++ mette a disposizione la possibilità di passare i parametri per riferimento ad una funzione, in modo che la funzione al suo interna veda non il valore della variabile, ma un riferimento (l indirizzo) alla variabile originale. In tal modo, ogni modifica alla variabile locale della funzione agisce all indirizzo della variabile originale, modificandola effettivamente. In questo modo le modifiche ad un parametro passato per riferimento saranno disponibili una volta che la funzione sia terminata. Per dichiarare che un parametro è passato per riferimento e non per valore si utilizza il segno & : tipo_dato nome_funzione(tipo_dato per_valore, tipo_dato &per_riferimento); In tale esempio la funzione nome_funzione ha come ingressi due parametri, di cui il primo è passato per valore (modalità standard), mentre il secondo è passato per riferimento, essendoci il simbolo di e commerciale davanti al nome della variabile. Allocazione statica della memoria Durante la compilazione di un programma, le dimensione di tutte le variabili deve essere nota, in modo che il compilatore possa calcolare l esigenza di memoria del programma, che all inizio della sua esecuzione richiede tale spazio al sistema operativo per funzionare. Questa strategia va sotto il nome di allocazione statica della memoria, cioè il programma utilizza una quantità fissata ed immutabile di memoria durante la sua esecuzione. Questo fa sì che non sia possibile, ad esempio, modificare la dimensione di un vettore durante la esecuzione di un programma scrivendo delle istruzione del tipo: int dimensione; cin >> dimensione; double vettore[dimensione]; perchè la dimensione del vettore (allocato staticamente) può essere nota solo durante l esecuzione del programma,

6 Allocazione dinamica della memoria Nel caso fosse necessario o auspicabile poter riservare della memoria durante l esecuzione, per poter accomodare lo spazio necessario al programma mano a mano che si renda necessario, il C++ fornisce al programmatore la possibilità di allocare della memoria attraverso l istruzione new. La strategia di riservare lo spazio in memoria quando sia necessario, senza doverlo conoscere all inizio dell esecuzione del programma e durante la compilazione, va sotto il nome di allocazione dinamica della memoria. Bisogna ricordare, che allocando staticamente la memoria, il C++ si prende carico di gestire da un lato l allocazione della memoria necessaria per tutte le variabili utilizzate dal programma, e dall altro la loro cancellazione e rilascio della memoria alla fine dell esecuzione. Utilizzando l allocazione dinamica, tale compito cade invece sulle spalle del programmatore, che può richiedere memoria aggiuntiva durante l esecuzione, ma deve assicurarsi che tale memoria sia rilasciata alla fine del programma. Ogni volta che si alloca della memoria per una variabile tramite l operore new, bisogna assicurare che tale variabile sia cancellata esplicitamente attraverso l operatore delete. La sintassi dell operatore new è: tipo_dato *puntatore; puntatore = new tipo_dato; Cioè l operatore riserva dello spazio in memoria pari alla dimensione di tipo_dato e restituisce l indirizzo di memoria in cui tale dato si trova. La cancellazione di una variabile allocata dinamicaminte sarà: delete puntatore; Nel caso si voglia allocare (e poi cancellare) un array la sintastti è leggermente diversa: int dimensione; cin >> dimensione; tipo_dato *puntatore; puntatore = new tipo_dato[dimensione]; delete [] puntatore; La dimensione del vettore non è nota a priori, ma solo durante l esecuzione del programma quando si chiede all utente di inserire la dimensione del vettore desiderato. L operatore new restituisce l indirizzo del primo elemento dell array desiderato. Quando si deve cancellare un array, bisogna segnalare all operatore delete che si vuole cancellare un vettore (una sequenza di dati), e non solo il dato di cui la variabile puntatore è l indirizzo. Per fare ciò si utilizza la sintassi del comando delete seguito dalle parentesi quadre che indicano che il puntatore seguente è l indirizzo di un array.