Esercitazione Visibilità di variabili e funzioni

1. EsercitazioneVisibilità di variabili e funzioni Calcolatori elettronici II Prof. A. Mazzeo Dott. Sara Romano

2. Il linguaggio C • E’ un linguaggio di programmazione che segue il paradigma della programmazione imperativa; • Svolge le operazioni in modo sequenziale (esecuzione delle istruzioni dall'alto verso il basso); • E’ un linguaggio a medio livello (è considerato il linguaggio di più basso livello tra quelli di alto livello); • E’ ampiamente utilizzato per programmare driver, sistemi operativi o comunque applicazioni che richiedono un controllo diretto sulle periferiche. Wikibooks http://it.wikibooks.org/wiki/C

3. I programmi C • Il linguaggio C utilizza i file come contenitori di programmi; • Un programma C è costituito da un insieme di “oggetti” che possono appartenere a due categorie distinte: • Funzioni; • Variabili. • A questi oggetti viene assegnato un nome nel punto in cui vengono definiti nel programma; • Il modo in cui i nomi sono usati per accedere a tali elementi (visibilità) da un determinato punto nel programma è disciplinato da regole (linkage). http://publications.gbdirect.co.uk/c_book

4. Le funzioni • Le funzioni sono i moduli di programma; • Sono sempre esterne, non possono essere definite all’interno di altre funzioni; • Il main è una funzione speciale: • Deve essere unica all’interno del programma; • È la funzione che viene eseguita all’avvio del programma.

5. Struttura dei programmi C Struttura generale di un programma C

6. Compilazione • La compilazione di un programma C si compone in due fasi: traduzione in codice oggetto e produzione dell’eseguibile.

7. Il linker • Il linker raccoglie i file-oggetto e crea il file eseguibile; • Per fare questo ha bisogno di collegare i riferimenti incrociati a simboli di variabili e funzioni. • Esempio: se nel file File1.o si fa riferimento alla funzione f() dichiarata nel file File2.o, nel programma risultante tale riferimento deve essere risolto con degli indirizzi appropriati.

8. Visibilità degli oggetti • Gli oggetti in C possono essere: • Interni • Esterni • La distinzione tra i due ha a che fare con le funzioni: ogni oggetto dichiarato esternamente alla funzione viene detto esterno, altrimenti viene detto interno. • Le funzioni sono tutte esterne (nessuna funzione può essere dichiarata all’interno di un’altra funzione).

9. Linkage • L’accessibilità degli oggetti (tra diversi file o all’interno dello stesso file) viene definita come linkage. • Tre tipi possibili: • External linkage; • Internal linkage; • No linkage. • Gli argomenti e le variabili interne alle funzioni sono prive di linkage

10. Campo di azione nel file sorgente • Il file sorgente, che si ottiene dalla compilazione, è suddiviso in componenti costituite essenzialmente dalla dichiarazione di variabili e di funzioni (prototipi inclusi). • L'ordine in cui appaiono queste componenti determina la visibilità reciproca (si può accedere solo a quello che è già stato dichiarato).

11. External linkage • Gli oggetti con external linkage sono al livello più esterno del programma. Questo tipo di linkage si applica alle funzioni e a tutto ciò che viene dichiarato all’esterno delle funzioni. • Tutte le istanze con un nome che hanno external linkage si riferiscono allo stesso oggetto nel programma.

12. Internal linkage • Questo tipo di linkage viene utilizzato per dichiarare oggetti visibili solo all’interno del file dove sono dichiarati e non nell’intero programma. • I nomi con internal linkage si riferiscono soltanto all’oggetto all’interno del file sorgente.

13. Variabili locali • Parola chiave auto o nessuna dichiarazione; • Sono interne ad un blocco individuato da {…} (es: interne ad una funzione); • Scope (ambito di visibilità): • visibili (accessibili) solo all’interno del blocco di definizione; • Ciclo di vita: • create al momento della dichiarazione, cessano di esistere quando si esce dal blocco; • Sono inizializzate con valori casuali. • Non mantengono il valore tra due riferimenti successivi a meno che non si usa la keyword static.

14. Esempio di variabili locali #include <stdio.h> void main(void) { int i, j; … funz(); } void funz() { int i; static int j; } i e j sono variabili automatiche, ovvero locali alla funzione main e funz. Sono create al momento della dichiarazione e cessano di esistere quando si esce dal blocco. variabile locale che conserva il suo valore fra l’uscita e il successivo rientro nella funzione in cui è stata dichiarata

15. Variabili esterne (globali) • Sono dichiarate una sola volta esternamente a qualsiasi blocco; • Devono essere rese note alle funzioni o ad altri moduli tramite la parola chiave extern (eccetto il caso in cui la dichiarazione preceda la funzione o il blocco in uno stesso modulo (es: all’inizio di un modulo, come avviene nella pratica)). • Scope (ambito di visibilità): • Se rese note ad un blocco con l’uso di extern: ovunque nel programma; • Se rese note ad un blocco senza l’uso di extern: ovunque, nello stesso modulo, a partire dalla loro dichiarazione in avanti; • Ciclo di vita: • Esistono e conservano il loro valore ovunque siano visibili all’interno del programma (es: uscita e successivo rientro da funzioni o blocchi);

16. Esempio: unico file #include <stdio.h> int i, j; void main(void) { extern int i, j; int x; i = 2; j = 3; x = i + j; } Variabili globali. In questo caso la dichiarazione può essere omessa

17. Esempio: diversi file File1.c File2.c .... int b=0; static int k=1; double f3(...) {...} .... main() {...} int a=0; extern int b; extern double f3(...) {...} int f1(...) {...} float f2(...) {...} La funzione main non ha visibilità degli oggetti a, b, f1, f2 e f3. L’oggetto a è visto e riferibile da f1 e f2. La variabile b, k e la funzione f3 sono definite nel file2.c La variabile k è “privata” per il file2.c nel senso che è globale per i soli moduli del file in cui è dichiarata.

18. Dichiarazione e definizione • Dichiarazione di una variabile: rende note le proprietà di tale oggetto (principalmente il suo tipo); • Definizione di una variabile: rende note le proprietà e provoca l’allocazione di un’area di memoria riservata a quella variabile. Tra tutti i file che costituiscono il programma, uno solo deve contenere la definizione di una variabile esterna. Definizione di i e j Dichiarazione di i e j int i; float j; funz(..) {...} extern int i; extern float j; funz3(..) {...}

19. Esercitazione • ARM Project Manager

20. Creazione codice sorgente

21. File C di esempio int a = 3; int b = 5; extern int c; extern int d; extern int sommaNumeri(int,int); int main(void) { int risultato; risultato=sommaNumeri(a,b); return 0; } int c=16; static int d=15; int sommaNumeri (int a, int b){ static int x; x=12; return a+b; } Scope.c Scope2.c

22. Salvataggio del codice sorgente

23. Creazione progetto

24. Aggiungere i file al progetto

25. Opzione compilatore

26. Build project

27. File del progetto

28. Scope.c int a = 3; int b = 5; extern int c; extern int d; int sommaNumeri (int, int); int main(void) { int risultato; risultato=sommaNumeri(a,b); return 0; }

29. Scope.s Inizializzazione a=3 e b=5 A e b sono variabili globali e possono essere utilizzate da altri object file

30. IMPORT / EXPORT • IMPORT symbol • La direttiva IMPORT fornisce un collegamento tra l’oggetto etichettato con symbol (che è definito in un object file separato) e l’object file in cui vi è tale direttiva. Il collegamento viene risolto dal linker. • EXPORT symbol • La direttiva EXPORT dichiara che l’oggetto etichettato con symbol può essere utilizzato a link time da altri object file.

31. Scope2.c int c=16; static int d = 15; int sommaNumeri (int a, int b){ int static x; x=12; return a+b; }

32. Scope2.s Inizializzazione c=16 e d=15 c è globale mentre d è statica

33. Esecuzione con il Debug

34. Indirizzo base dell’area dati

42. Esempio variabili locali int a = 3; extern int c; extern int d; int sommaNumeri (int, int); int main(void) { int b = 5; int risultato; risultato=sommaNumeri(a,b); return 0; } Scope.c

46. Esempio: se utilizzo d? int c=16; static int d = 15; int sommaNumeri (int a, int b){ int static x; x=12; return a+b; } int a = 3; int b = 5; extern int c; extern int d; int sommaNumeri (int, int); int main(void) { int risultato; risultato=sommaNumeri(a,d); return 0; } Scope2.c Scope.c