FONDAMENTI DI INFORMATICA
Prof. PIER LUCA MONTESSORO Ing. DAVIDE PIERATTONI
Facoltà di Ingegneria
Università degli Studi di Udine
Linguaggio C
Compilazione, linking e preprocessor
Questo insieme di trasparenze (detto nel seguito slide) è protetto dalle leggi sul copyright e dalle disposizioni dei trattati internazionali. Il titolo ed i copyright relativi alle slides (ivi inclusi, ma non limitatamente, ogni immagine, fotografia, animazione, video, audio, musica e testo) sono di proprietà degli autori prof. Pier Luca Montessoro e ing. Davide Pierattoni, Università degli Studi di Udine.
Le slide possono essere riprodotte ed utilizzate liberamente dagli istituti di ricerca, scolastici ed universitari afferenti al Ministero della Pubblica Istruzione e al Ministero dell’Università e Ricerca Scientifica e Tecnologica, per scopi istituzionali, non a fine di lucro. In tal caso non è richiesta alcuna autorizzazione.
Ogni altro utilizzo o riproduzione (ivi incluse, ma non limitatamente, le riproduzioni su supporti magnetici, su reti di calcolatori e stampe) in toto o in parte è vietata, se non esplicitamente autorizzata per iscritto, a priori, da parte degli autori.
L’informazione contenuta in queste slide è ritenuta essere accurata alla data della pubblicazione. Essa è fornita per scopi meramente didattici e non per essere utilizzata in progetti di impianti, prodotti, reti, ecc. In ogni caso essa è soggetta a cambiamenti senza preavviso. Gli autori non assumono alcuna responsabilità per il contenuto di queste slide (ivi incluse, ma non limitatamente, la correttezza, completezza, applicabilità, aggiornamento dell’informazione).
In ogni caso non può essere dichiarata conformità all’informazione contenuta in queste slide.
In ogni caso questa nota di copyright e il suo richiamo in calce ad ogni slide non devono mai essere rimossi e devono essere riportati anche in utilizzi parziali.
Nota di Copyright
Programma sorgente, compilatore, file oggetto, file eseguibile
programma sorgente (uno o più file ASCII)
compilatore
file oggetto (binari)
librerie (simili ai file oggetto)
file eseguibile (binario)
...
...
linker
...
Compilazione
• Il C è un linguaggio di alto livello: la descrizione dei comandi da eseguire è molto astratta, se confrontata con il linguaggio macchina o l’assembler
• Il C è un linguaggio compilato: un programma, detto compilatore, traduce uno o più file ASCII contenenti i comandi in C in un unico file con la sequenza di
istruzioni in codice macchina
• A differenza dei linguaggi interpretati, la traduzione avviene una volta per tutte, e non a “runtime”
• Il C è un linguaggio portabile: a partire da un unico file sorgente, è possibile generare programmi
eseguibili per architetture hardware diverse
Compilazione
programma sorgente (uno o più file ASCII)
Compilatore UNIX
file eseguibile per UNIX
...
Linker UNIX
Compilatore Win32
Librerie UNIX
file eseguibile per Win32
Linker Win32 Librerie
Win32
File oggetto (binari) File oggetto (binari)
Portabilità
• La portabilità del codice deriva dal fatto che i linguaggi di alto livello sono standardizzati
• Il linguaggio C, nella versione standard ANSI, consente di scrivere programmi portabili sulla
maggioranza delle architetture hardware esistenti
• Sono disponibili compilatori e ambienti di sviluppo C (IDE: Integrated Development Environment) per tutte le piattaforme software (DOS/Win32, UNIX, Linux, MacOS, VMS, Solaris…)
• La dipendenza dal sistema operativo è tuttavia
sensibile nelle procedure di basso livello (chiamate di sistema, I/O su dispositivi periferici...)
Linking
• Il compilatore genera una traduzione in uno o più file oggetto, privi dei comandi di interfacciamento con l’hardware e il sistema operativo
• Tali comandi sono disponibili in formato eseguibile nelle librerie di sistema: queste contengono parti di programma di uso comune, disponibili già compilate
• Il collegamento tra i file oggetto e i file di libreria da essi richiesti viene effettuato dal linker
• Il linker genera un file eseguibile contenente le parti di codice macchina copiate dalle librerie (linking
statico), oppure dei collegamenti dinamici alle librerie necessarie (linking dinamico, es. le DLL in Win32)
Il preprocessor
• Prima della compilazione vera e propria, ogni sorgente C viene analizzato dal preprocessor
• Il preprocessor interpreta ed esegue tutti i comandi (o direttive) corrispondenti alle righe di codice introdotte dal carattere #
• Le funzionalità del preprocessor sono:
– inclusione di file (direttive #include)
– sostituzione delle macro (direttive #define) – macro dotate di argomenti
– compilazione condizionale
Inclusione di file
• Ogni linea di codice della forma
#include <nomefile>
viene sostituita con il contenuto del file nomefile
• Se il nome del file è racchiuso tra apici,
#include "nomefile"
la ricerca del file avviene nella stessa directory in cui è presente il file sorgente
• Nel caso di una direttiva #include <nomefile>, la ricerca del file da includere avviene in genere nel
direttorio in cui risiedono gli header file delle librerie
Inclusione di file
• Le direttive di inclusione più frequenti sono quelle relative agli header file delle librerie
• La direttiva #include <stdio.h> consente di
includere nel file sorgente tutti i prototipi di funzione e i tipi di dati dichiarati nell’header file stdio.h
• L’inclusione permette anche di raggruppare in un file unico tutte le dichiarazioni relative a programmi
complessi e/o distribuiti su più file sorgenti
Coerenza nelle dichiarazioni e definizioni delle variabili
/* pippo1.c */
#include <stdio.h>
#include "pippo.h"
float x;
int main() {
int k = funzione_1();
x = PIGRECO;
…
/* pippo2.c */
#include <stdio.h>
#include "pippo.h"
extern float x;
int funzione_1(void) {
float y = 2 * PIGRECO;
x = y + 4;
… /* pippo.h */
#define PIGRECO 3.14 int funzione_1 (void);
...
Sostituzione delle macro
• Una definizione della forma
#define nome testo_da_sostituire è la sostituzione di macro più semplice
• Tutte le successive occorrenze di nome vengono sostituite con testo_da_sostituire
• Lo scope (visibilità) della sostituzione va dal punto in cui compare la direttiva fino alla fine del file sorgente
• Qualsiasi nome può essere sostituito con qualsiasi testo:
#define forever for ( ; ; )
#define PIGRECO 3.14
Macro dotate di argomenti
• Una sostituzione più complessa può essere
#define max(A, B) ((A) > (B) ? (A) : (B))
• max è una macro dotata di argomenti, anche se assomiglia a una chiamata di funzione
• In tale caso, ogni occorrenza di un parametro formale viene rimpiazzata con il corrispondente parametro
reale
• Pertanto nel file sorgente la linea:
x = max(p+q, r+s);
viene espansa nel codice
x = ((p+q) > (r+s) ? (p+q) : (r+s));
Sostituzione delle macro
• Le sostituzioni avvengono soltanto sui token
• I parametri formali all’interno di stringhe tra apici non vengono sostituiti
• Quindi se YES è un nome definito da
#define YES 1
la sua occorrenza in printf ("YES"); resta inalterata
Sostituzione delle macro
• La definizione di un nome può essere annullata con la direttiva #undef
• #undef può essere utile per assicurarsi che una funzione sia definita come tale, e non come una macro
• Ad esempio:
#undef getchar
...
int getchar (void) { … }
garantisce che nel sorgente non vi sia alcuna macro dal nome getchar, in quanto getchar è già il nome di una funzione di libreria
Macro
• Una macro è dunque una forma compatta in grado di rappresentare espressioni complesse o insiemi di
istruzioni mediante parametri
• Le macro più semplici sono prive di parametri, e si usano per definire costanti simboliche
• Le macro dotate di parametri possono talvolta evitare la creazione di funzioni, specie quelle soggette a
frequenti chiamate durante l’esecuzione
• Alcune funzioni di libreria vengono implementate con delle macro, per velocizzare l’esecuzione dei
programmi più complessi
Compilazione condizionale
• Alcune direttive consentono il controllo dell’attività di preprocessing
• E’ possibile inserire o eliminare segmenti di codice in modo selettivo, in base al valore di determinate
condizioni durante la compilazione
• La direttiva #if valuta un’espressione costante
intera: se questa è ≠≠ 0, le linee di codice tra #if e il successivo #endif vengono incluse nella
compilazione #define VERBOSE 1
#if VERBOSE
<blocco di codice>
Compilazione condizionale
• Costrutti condizionali più articolati, del tipo
“if…then…else”, si ottengono con le direttive #if,
#else e #elif
• In un sorgente portabile su più piattaforme software è frequente trovare istruzioni del tipo:
#define SYSTEM <nome_del_sistema_operativo>
…
#if SYSTEM == UNIX
#define HEADER "unix.h"
#elif SYSTEM == MSDOS
#define HEADER "msdos.h"
#else
#define HEADER == "default.h"
#endif
Compilazione condizionale
• Le direttive #ifdef e #ifndef controllano se un particolare nome è già stato definito
#ifdef DEBUG
<istruzioni di debug: stampa di variabili...>
#endif
#ifndef HEADER
#define HEADER "default.h"
#endif
