&RUVRGL/DXUHDLQ6FLHQ]HGHOO ,QIRUPD]LRQHGL&HVHQD

6LVWHPLSHUO (ODERUD]LRQHGHOO ,QIRUPD]LRQH

DD

Appunti dalle Lezioni

,OOLQJXDJJLR&

Ciclo di lezioni tenute da:

9LWWRULR*KLQL
e-mail YLWWRULR#FVUXQLERLW

Letture Consigliate:

Brian W. Kernighan, Dennis M. Ritchie,

"/LQJXDJJLR&$16,", ed. Jackson Libri.
 ----------------------------------------------------------------
&DUDWWHULVWLFKHGHOOLQJXDJJLR&

• utilizzo frequente di chiamate a IXQ]LRQL.

• GHEROH FRQWUROOR VXL WLSL GL GDWR. A differenza del Pascal, il C
permette di operare con assegnamenti e confronti su dati di tipo
diverso, in qualche caso solo mediante un type cast (conversione di
tipo) esplicito.
• OLQJXDJJLR VWUXWWXUDWR. Il C prevede costrutti per il controllo di
flusso, quali raggruppamenti di istruzioni, blocchi decisionali (if-else),
selezione di alternative (switch), cicli con condizione di terminazione
posta all’inizio (while, for) o posta alla fine (do) e uscita anticipata dal
ciclo (break).
• SURJUDPPD]LRQHDEDVVROLYHOOR facilmente disponibile
• implementazione dei SXQWDWRUL (ampio uso di puntatori per memoria,
vettori, strutture e funzioni)
• SRUWDELOLWj sulla maggior parte delle architetture.
• disponibilità di OLEUHULHVWDQGDUG.
• la grande libertà messa a disposizione dai puntatori e dagli array rende
facile commettere errori, soprattutto con array e puntatori.

Lo standard per i programmi C in origine era dato dalle caratteristiche

messe a punto da Brian Kernighan. Al fine di rendere il linguaggio piu'
accettabile a livello internazionale, venne messo a punto uno standard
internazionale chiamato ANSI C (American National Standards
Institute).
 1%0HWRGRGLSUHVHQWD]LRQHGHOOLQJXDJJLR&
All’inizio, per poter fare qualche prova da subito, utilizzeremo alcune
funzioni di libreria senza scendere nei dettagli, in attesa di specificarle
meglio nelle lezioni successive.
Ad es. la funz printf, che è complicata da usare, verrà descritta solo nei
caratteri fondamentali, nell'ottica di scendere nei dettagli quando avrete
imparato qualcosina di più sul C.
----------------------------------------------------------------
,OSULPRSURJUDPPDLQOLQJXDJJLR&
Un minimo programma in C e':
PDLQ
^
`
che corrisponde a un programma in Pascal:
SURJUDPPLQLPXP
EHJLQ
HQG

Caratteristiche di ogni programma C:

• 2JQL SURJUDPPD & GHYH FRQWHQHUH XQD H XQD VROD IXQ]LRQH

PDLQ , che rappresenta il programma principale, ed l punto di inizio
dell'esecuzione del programma.

• La parentesi graffa aperta ^ indica l'inizio di un blocco di istruzioni, e

corrisponde al EHJLQ del pascal.
• La parentesi graffa chiusa ` indica la fine di un blocco di istruzioni, e
corrisponde al HQG del pascal.
• Per ogni parentesi graffa aperta ^ deve essercene una chiusa `.

• I commenti possono essere posti ovunque

• L'inizio del commento è dato dalla coppia 
• La fine del commento è indicata da 
• Non si puo' inserire un commento in un altro (vietato l'annidamento
dei commenti.
Ad esempio:
 (VHPSLRGLSURJUDPPDLQ&FRQSUREOHPLQHLFRPPHQWL 
PDLQ
^
 8QFRPPHQWR   (6$772
 &RPPHQWR $QFRUDXQFRPPHQWR 48,(5525( 
`

Il seguente esempio e’ un programma che produce l’output sullo schermo

della frase "Hello World":

LQFOXGHVWGLRK!

LQWPDLQ
^
SULQWI +HOOR:RUOG?Q 
H[LW  
`

• In C, ci vuole un punto e virgola  dopo ogni istruzione.

• L’istruzione "SULQWI  " chiama la funzione printf che visualizza cio’
che gli viene passato come argomento (\n indica l’andata a capo), e
ricorda la write del Pascal.

• L’istruzione "H[LW  " chiama la funzione exit che termina il

programma e restituisce al sistema operativo il codice 0.

• In C non esiste la distinzione che esiste in pascal tra funzioni e

procedure, in C sono tutte funzioni, che possono restituire un qualche
risultato oppure no. Le chiamate ad ogni funzione in C si effettuano
chiamando il nome della funzione seguita dalle parentesi tonde, aperta
e chiusa, all’interno delle quali vengono passati i parametri necessari.
Anche se la funzione non richiede nessun parametro, il suo nome deve
essere seguito dalle parentesi tonde aperta e chiusa.
 --------------------------------------------------------------------------------------------------------------------------------

6YLOXSSRGLXQ3URJUDPPDLQOLQJXDJJLR&
Lo sviluppo di un programma in C richiede le seguenti fasi:
Scrittura, Compilazione, Esecuzione e Debugging.
• 6FULWWXUDGHO3URJUDPPDLQ/LQJXDJJLR&
• Per creare un file contenente un programma C si usa un qualsiasi text
editor quale "edit" "notepad" in pc con sistemi operativi dos-windows,
oppure vi, emacs, xedit in host con s.o. unix.
• Il nome del file deve avere l’estensione "F", ad esempio, prog.c.
• Il contenuto, ovviamente, deve rispettare la sintassi C.
• &RPSLOD]LRQH
• La compilazione di un programma scritto in C si effettua mediante
programmi detti FRPSLODWRUL quali Microsoft C Compiler (cl.exe) in
sistemi dos-windows, o Gnu C Compiler (gcc) in sistemi Unix.
• Questi compilatori in realtà svolgono 3 funzioni: SUHSURFHVVLQJ,
FRPSLOD]LRQH YHUD H SURSULD (eventualmente passando da uno step
intermedio che consiste nella generazione di file in codice assembly)
per generare dei moduli oggetto, OLQNLQJ (collegamento) dei vari
moduli oggetto e delle eventuali librerie.
• queste tre funzioni, in ambiente unix sono solitamente eseguite da tre
programmi diversi (preprocessor, compiler, linker) che vengono attivati
da un programma di gestione anch'esso comunemente detto
compilatore. In ambienti microsoft spesso preprocessing e
compilazione sono eseguiti da uno stesso programma, ed il linking è
effettuato da un altro programma chiamato dal compilatore. Esiste
inoltre un utility (il make) che permette di eseguire le varie fasi solo per
quei files che sono stati modificati più recentemente (in particolare i
files modificati dopo l'esecuzione dell'ultima compilazione), limitando
in tal modo il lavoro del compilatore.
COMPILATORI A LINEA DI COMANDO
\ ambiente DOS-WINDOWS UNIX-LINUX
fase \ (Microsoft) (GNU)
gestione nmake.exe make
preprocessing cl.exe cpp
compilazione cl.exe gcc
linking link.exe ld
• (VHFX]LRQHHGHEXJJLQJ:
• L’eseguibile ottenuto mediante compilazione e link viene eseguito per
verificarne il funzionamento e scoprire eventuali errori.
• N.B. Un programma sviluppato in C che sembra funzionare dopo la
prima compilazione ha sicuramente degli errori nascosti !!!!
•
• Esistono in commercio i cosiddetti "ambienti di sviluppo integrati" quali
ad es il Microsoft Visual C, che nascondono all’utente questi aspetti della
compilazione, mediante un’interfaccia visuale, e che consentono di
effettuare il debugging in maniera più facile, seguendo passo a passo
l'esecuzone del programma.

----------------------------------------------------------------
,O0RGHOORGL&RPSLOD]LRQHSHULO&
Gli step essenziali della compilazione per un programma sviluppato in C
sono rappresentati nel seguente schema:
&6RXUFH&RGH

Preprocessor

Compiler
Assembly Code

Assembler
Libraries

Object Code

Linker

([HFXWDEOH&RGH

• NOTA BENE: Il passaggio attraverso il linguaggio assembly solitamente

non è necessario, e viene utilizzato solo a scopo di debugging.
• ,O3UHSURFHVVRUH
Il preprocessore prende in input un file di codice sorgente C e:

1) processa le cosiddette GLUHWWLYH DO SUHSURFHVVRUH, che sono

essenzialmente:
• ,QFOXVLRQHGLILOH
LQFOXGH <nomefile>
prende il file nomefile e lo inserisce al posto della direttiva
• 'HILQL]LRQHGL0DFUR
GHILQH SIMBOLO DefinizioneDiSimbolo
definisce una Macro, e da quel momento, ogni volta che il
preprocessore incontra SIMBOLO lo sostituisce con
DefinizioneDiSimbolo. Es. #define LENGTH 100
• &RPSLOD]LRQH&RQGL]LRQDOH
LIGHI6,0%2/2
istruzioni C /* eseguite se prima esiste #define SIMBOLO */
HOVH
istruzioni C /* eseguite se prima NON esiste #define SIMBOLO */
HQGLI

2) elimina i commenti contenuti nel sorgente.

3) genera così un nuovo file senza commenti e senza più necessità di

effettuare sostituzioni, pronto per essere processato dal compilatore.

Un esempio di come lavora il processore:

prima prima dopo il passaggio col

processore

/* file KHDGHUK */ /* file SURYDF */ /* file SURYD( */

extern int i; #include "header.h" extern int i;
extern double f; extern double f;
/* size vettore */
/* fine header.h */ #define SIZE 10 int vettore[10];

int vettore[SIZE];
• ,O&RPSLODWRUH
Il compilatore prende in input il codice ottenuto come output dal
preprocessore, e crea il codice assembly, cioè un codice che
(semplificando) è mappabile 1 a 1 con il codice macchina ma è scritto in
una forma umanamente comprensibile.

• / $VVHPEODWRUH
Prende in input il codice assembly, e crea il codice oggetto, cioè del
codice macchina (comprensibile per il calcolatore) in cui ancora
esistono dei riferimenti non risolti.

• ,O/LQNHU
detto anche collegatore, si occupa di prendere in input i vari files di
codice oggetto, sia quelli generati dall'assemblatore, o direttamente dal
compilatore a partire al codice del programmatore, sia quello delle
librerie disponibili, e di generare il file eseguibile, collegando tutti i
riferimenti a variabili e funzioni da un file all'altro.

In particolare si occupa di collegare, senza farlo vedere all'utente, una

porzione di codice oggetto, reso disponibile come libreria, che:
• DSSURQWD O DPELHQWH SHU LO SURFHVVR TXDQGR TXHVWR YD LQ
HVHFX]LRQH e
• SDVVD LO FRQWUROOR DOOD IXQ]LRQH PDLQ che l'utente deve avere
definito.
Questa porzione di codice si occupa ad esempio, ma non solo, di
consegnare al programma i parametri passati tramite la riga di comando,
e questo senza che l'utente se ne debba occupare.
Le librerie sono importanti perchè contengono il codice che esegue
funzioni quali ad es le funzioni matematiche e le funzioni di I/O.

In un certo senso, le librerie del C, assomigliano alle 8QLW GHO 3DVFDO,

che, come ricorderete vengono accedute mediante la clausola XVHV, e che
mettono a disposizione funzioni procedure e variabili.

Non tutte le librerie sono disponibili su tutte le architetture di

calcolatori. Il ristretto insieme di funzioni definito da ANSI viene però
reso disponibile dalla maggior parte dei compilatori.

Molti compilatori mettono a disposizione librerie proprietarie, che se da

un lato facilitano la programmazione all'utente, dall'altro lato rendono
difficile il porting del programma, cioè il trasferimento del programma
su una architettura diversa.

E' necessario in genere LQGLFDUHTXDOLOLEUHULHLOOLQNHUGHYHXWLOL]]DUH,

passando al linker stesso alcuni flag nella linea di comando.
Alcune librerie sono utilizzate per default, altre devono essere
esplicitamente nominate.

Gli ambienti integrati in genere nascondono o almeno facilitano la

soluzione delle problematiche relative alla scelta delle librerie da
utilizzare.
 ----------------------------------------------------------------
4XDOHFRPSLODWRUH&XWLOL]]DUHSHULO&RUVRGL6LVWHPL"

Gli studenti hanno a disposizione nel laboratorio al primo piano, dei

Personal Computer con sistemi operativi Windows NT Workstation e
Windows 95.
Per gli esercizi e le prove è previsto l'utilizzo dell'ambiente integrato
Microsoft Visual C 6.0.
Tale ambiente può essere fatto partire cliccando col mouse sul bottone
Start e, seguendo i menu che via via si aprono, seguendo il percorso:
Start→Programs→lab→MicrosoftVisualStudio6.0→MicrosoftVisualC++6.0
 &RPHXVDUHO¶$PELHQWH,QWHJUDWR
0LFURVRIW9LVXDO&

Il Visual C++ Microsoft 6.0 permette di generare applica_

zioni:
• sia in C ANSI, utilizzando le funzioni di librerie standard
• sia in C++ (il C a oggetti) utilizzando alcune funzioni di
libreria proprietarie (cioè non standard ma tipiche di
Microsoft) e dedicate agli oggetti, le cosiddette MFC
(Microsoft Foundation Class).

Tali applicazioni possono presentarsi all’utente mediante:

• la classica interfaccia testo standard,
• oppure un’interfaccia grafica a finestre tipica di Windows.

Per quanto di interesse di questo corso, e soprattutto per chi

comincia ora ad interessarsi di linguaggio C, è bene fare
pratica utilizzando l’LQWHUIDFFLDWHVWRFODVVLFD.

I prossimi lucidi mirano appunto a fornire alcune indica_

zioni su come utilizzare l’ambiente integrato per program_
mare secondo il modo classico a finestra di testo, che nello
ambiente integrato Microsoft viene indicato con il termine
di modo “&RQVROH”.
11
 ,O3URMHFWGL069&

Quando un utente vuole scrivere un programma usando il

Visual C++ deve per prima cosa creare un QXRYR3URJHWWR.

I SURMHFWGL069& sono una specie di database in cui

vengono memorizzate informazioni riguardanti:
• 6LVWHPD2SHUDWLYR su cui l’applicazione deve lavorare.
• 7LSRGL,QWHUIDFFLD che l’utente vuole (Testo o Grafica).
• 7LSRGLDSSOLFD]LRQH da generare (un eseguibile o una
libreria, una libreria statica o una libreria dinamica DLL)
• Quali ILOHVVRUJHQWL (.c .h) implementano l’applicazione.
• Che tipo di 2S]LRQL l’utente vuole ('HEXJJLQJ Si o No e
se si di che tipo, 2WWLPL]]D]LRQH per migliorare la velocità
di esecuzione o per diminuire la dimensione del file
eseguibile generato).
• $OWUHLQGLFD]LRQL .

Una volta specificate queste indicazioni, l’utente scrive il

suo programma, eventualmente apportando modifiche al
Project (es. aggiungendo nuovi files sorgenti) e mediante
alcuni comandi, lanciati per mezzo di finestre a menu
può compilare, eseguire e debuggare il suo programma.

12
 /H&RQILJXUD]LRQLGLXQ3URMHFW 
Ogni progetto viene scritto all’interno di una propria
directory, in cui l’utente scrive i propri files, e in cui
MSVC scrive alcuni suoi files in cui salva le informazioni
sul progetto e sullo stato di avanzamento della compilazione
Quindi evitate di cancellare files aventi estensioni tipo:
.prj , .pch , perchè potrebbero contenere informazioni
importanti.
All’interno di uno stesso Progetto, MSVC prevede due
possibili FRQILJXUD]LRQLFLRqGXHSRVVLELOLVHWWDJJLGHL
SDUDPHWULGLRWWLPL]]D]LRQHHGHEXJJLQJ e altri.
Queste due configurazioni sono indicate con i termini,
“'HEXJ” e “5HOHDVH” e sono fatte con lo scopo di permet_
tere al’utente, se vuole, di impostare nello stesso progetto
le opzioni in due modi differenti:
• Nella configurazione 'HEXJ di solito l’utente sceglie
RS]LRQLGLGHEXJJLQJSHVDQWL, per testare e seguire l’esecu_
zione del programma mediante i comandi dell’ambiente
integrato.
• Invece nella configurazione “5HOHDVH” l’utente setta una
FRQILJXUD]LRQHSLVQHOOD, in cui la mancanza di opzioni di
debugging e la presenza di opzioni di ottimizzazione ren_
dono il SURJUDPPDSLYHORFH.
Con un comando annidato nel Menu Project (Configuration)
l’utente di volta in volta sceglie su quale configurazione
lavorare 13
 /H&RQILJXUD]LRQLGLXQ3URMHFW 
L’MSVC crea una sottodirectory per ciascuna delle
configurazioni settate, ed in queste sottodirectory scrive
l’eseguibile eventualmente generato qualora la compila_
zione sia andata a buon fine.

Con un comando annidato nel Menu Project

(Configuration) l’utente di volta in volta sceglie su
quale configurazione lavorare

14
 &RPH&UHDUHXQ1XRYR3URMHFW 
Vediamo passo a passo come creare un nuovo project
in MSVC, in modo da poter cominciare con le prime prove.

Supponiamo di essere un utente di nome YLWWRULR,

e di voler creare una applicazione di nome SURJ
che stia nella directory F?XWHQWL?YLWWRULR?SURJ

Per fare ciò si deve lanciare MSVC, ottenendo la seguente

finestra, in cui poi si seleziona il menu )LOH e dentro File
il menu1HZ

15
 &RPH&UHDUHXQ1XRYR3URMHFW 
• Cliccando sul Menu1HZ otteniamo la seguente finestra,
in cui selezioniamo nei menu in alto il menu 3URMHFW.
• Appaiono alcuni tipi di applicazione da creare, e noi
scegliamo il tipo :LQ&RQVROH$SSOLFDWLRQ,
• poi nella casella di testo 3URMHFW1DPH in alto a destra
scriviamo il nome del progetto da creare 3URJ
• nella casella/RFDWLRQ scriviamo la directory in cui
salvare i files nostri e del project. F?XWHQWL?YLWWRULR?3URJ
Selezioniamo il Bottone &UHDWH1HZ:RUNVSDFH.
Concludiamo con un invio o click su OK.

16
 &RPH&UHDUHXQ1XRYR3URMHFW 

• Appare una nuova finestra Win32 Console application,

• Selezionate “$Q(PSW\3URMHFW”
• clikkate su finish.

17
&RPH&UHDUHXQ1XRYR3URMHFW 

• Appare finalmente la ILQHVWUDFRQLOQXRYRSURJHWWR,

• Bisogna ora VHWWDUHOHRS]LRQLSHULO3URJHWWR

• Selezionate il Menu 3URMHFW e cliccate su 6HWWLQJ, per

fare apparire la finestra in cui definire tuttii settaggi
per il progetto.

18
 'RYH6HWWDUHOH2S]LRQL
•Bisogna ora VHWWDUHOHRS]LRQLSHULO3URJHWWR
• Selezionate il Menu 3URMHFW e cliccate su 6HWWLQJ, per
fare apparire la finestra su cui definire tuttii settaggi
per il progetto.
• Di solito le opzioni di Default sono già adatte all’uso
dell’utente medio.
• Man mano che diventerete esperti, potrete modificarle
a seconda di esigenze particolari.
• 3HURUDODVFLDWHOHFRVuFRPHVRQR

19
 &RPH&UHDUHXQ1XRYR)LOH
Se Dovete FUHDUHXQQXRYRILOHVVRUJHQWHLQ&
• Andate nel Menu )LOH, clikkate su 1HZ, appare la
finestra che vi chiede che tipo di file volete aprire.
• Selezionate la voce &6RXUFH)LOHV
• Selezionare il Bottone $GG7R3URMHFW
• Scrivere nella casella File Name il nome del file che
si vuole creare, supponiamo che sia 3ULPRF
• Scrivere nella casella Location la directory del progetto
supponamo sia F?XWHQWL?YLWWRULR?SURJ
• Cliccate su OK e appare una finestra di editing con
il file Primo.c GDVFULYHUH

20
 &RPH,QVHULUHQHO3URMHFW
XQ)LOH*,$¶(VLVWHQWH
Se dovete LQVHULUHQHOSURMHFWXQILOH&FKHHVLVWHJLj
• Andate nel Menu 3URMHFW, clikkate su $GG7R3URMHFW
• appare un nuovo menu, cliccate su Files
• appare la finestra che vi chiede quale file volete inserire
lo scegliete e siete a posto

In modo simile, se volete LQVHULUHQHOSURMHFWXQILOH&

FKH121HVLVWH
• Andate nel Menu 3URMHFW, clikkate su $GG7R3URMHFW
• appare un nuovo menu, cliccate su 1HZ
• appare la finestra che vi chiede TXDOHWLSR di file volete
inserire, scegliete C++ Source e un nome con cui
chiamare il file, e si apre una nuova finestra di editing.

21
 &RPH6FULYHUHLO3URJUDPPD
• Ora si tratta di scrivere il Programma, ma come
scriverlo bene sarà l’argomento delle prossime lezioni.

22
 &RPH&RPSLODUH(VHJXLUH
H'HEXJJDUHLO3URJUDPPD
Nel menu in alto , selezionate la voce %XLOG,
e cliccate su:

• %XLOG$OO per effettuare la compilazione completa di

tutti i files del Progetto ed il linking.
• ([HFXWH per eseguire il Programma.
• 6WDUW'HEXJ per debuggare.

23