Introduzione alla
programmazione
Scrivere programmi
• Per risolvere un problema, occorre
specificare un algoritmo
• Un algoritmo può essere scritto in diversi
linguaggi, compreso il linguaggio naturale
usato per la comunicazione tra persone
• Un algoritmo deve essere scritto in un
linguaggio comprensibile all’esecutore
• Se vogliamo che sia il computer ad eseguire
un algoritmo, esso deve essere scritto in un
linguaggio di programmazione
• Un algoritmo scritto in un linguaggio di
programmazione si chiama programma
Scelta di un opportuno
linguaggio di programmazione
• Nello scrivere un programma,
incontriamo esigenze contrastanti:
– usare un linguaggio facilmente
comprensibile dal calcolatore, quindi
dettagliato e preciso
– usare un linguaggio facilmente
comprensibile dal programmatore, quindi
sintetico, simile al linguaggio naturale
La scelta del calcolatore:
0100
0010
0001
0010
0000
1100
0100
0110
0010
0000
0011
0010
1000
0000
0101
1111
00000000
00100000
00000000
00100001
00100000
00001101
00000000
00100001
00100001
00100000
00000001
00100000
00000100
00100001
00000000
00000000
La scelta del programmatore:
1. Se il numero più piccolo dei due divide
esattamente (cioè con resto 0) il più
grande allora stop, quello è il MCD.
2. altrimenti, calcola il resto della divisione
dei due numeri, e ripeti dal passo 2
usando come numeri il resto ed il
minore dei numeri di partenza
I linguaggi di programmazione
ad alto livello
• Sono linguaggi che cercano un compromesso tra i
due estremi
• Ogni calcolatore è caratterizzato da un linguaggio
di programmazione di basso livello o linguaggio
macchina, il cui testo è una sequenza di bit (0 e 1)
che il calcolatore interpreta, eseguendo una
sequenza di azioni
• I linguaggi di programmazione ad alto livello sono
più vicini al linguaggio umano scritto e quindi
facilitano la descrizione di algoritmi da parte dei
programmatori
• Tali linguaggi hanno la proprietà di poter essere
ricondotti, in maniera non ambigua, al linguaggio
macchina. Questa riconducibilità è la base per la
interpretazione o compilazione del linguaggio
stesso
La macchina astratta C
Componenti della macchina C
• Un’ unità di memoria
• Un’unità di ingresso, Standard Input
– dalla quale leggo dati
• Un’unità di uscita, Standard Output
– sulla quale scrivo dati
• La memoria (e anche Standard Input e Standard
Output) è divisa in celle elementari, contenenti
ciascuna un dato
• Le celle di memoria sono i “contenitori” (le variabili)
che avevamo introdotto parlando di algoritmi
– le chiamiamo “variabili” perchè il loro contenuto
può cambiare durante l'esecuzione del
programma
Variabili e identificatori
• I dati che posso mettere in una variabile (o che posso
leggere/scrivere da/a Standard Input ed Output) possono
essere di vari tipi:
– numeri
– caratteri
– stringhe (successioni finite di caratteri, immagazzinati in
celle consecutive)
• Facciamo le seguenti semplificazioni / idealizzazioni per la
macchina C:
– non c'è nessun limite al numero delle celle
– non c'è nessun limite al valore numerico contenuto
• Indichiamo le variabili (e facciamo loro riferimento) mediante
dei “nomi”, o, meglio detto, mediante identificatori simbolici
(x, a, alfa, pippo…come in figura)
Identificatori simbolici
• Un identificatore simbolico è una successione di
lettere e cifre e segno con al primo posto una
lettera
– per esempio: a, x, alfa, pippo, a1, xy23, Giuseppe,
DopoDomani...
– non sono identificatori invece:2abc, 4x, 7
• Le lettere maiuscole sono distinte dalle
corrispondenti lettere minuscole
– Var1, var1 e VAR1 sono tre diversi identificatori
• Per evitare ambiguità non è possibile usare lo
stesso identificatore per indicare diversi elementi
né usare diversi identificatori per lo stesso
elemento
Parole chiave
• Alcuni identificatori sono predefiniti e riservati,
– sono predefiniti perché sono associati a priori a qualche
elemento del linguaggio
– sono riservati perché non possono essere usati dal
programmatore con significati differenti da quello
predefinito
• Esempi di identificatori riservati:
– scanf e printf: indicano operazioni elementari di
ingresso/uscita e non possono essere impiegate in un
programma C per indicare, per esempio, una variabile
• Parola chiave: parola predefinita del linguaggio di
programmazione; anch’essa riservata
– non può fungere da normale identificatore
• Per facilitarne l’identificazione, le parole chiave saranno
scritte in neretto
Struttura di un programma C
• Un programma C è fatto di
– una intestazione
– una sequenza di istruzioni (racchiusa tra
parentesi graffe { })
• Intestazione:
– identificatore predefinito main, seguito da
parentesi rotonde ()
• Istruzioni:
– i “comandi” che noi diamo al computer, scritti
nel linguaggio C
Scheletro di programma C
main() {
...
...
...
...
...
}
Tipi di istruzioni in C
• Vogliamo poter mettere dei valori nelle variabili (nei
“contenitori”)
– istruzione di assegnamento
• Vogliamo poter “comunicare” con il mondo esterno (chiedere
all'utente di immettere dei valori, fargli vedere dei risultati)
– istruzioni di ingresso/uscita
• Vogliamo poter fare delle scelte su che cosa fare (quali passi
eseguire) in base a certe condizioni(se ... allora ...
altrimenti ...)
– istruzione condizionale
• Vogliamo poter ripetere delle operazioni (fino a che non si
verfica una qualche condizione)
– istruzione iterativa
Istruzioni di assegnamento
• Assegna a una variabile il valore di un’espressione
• Consiste nel simbolo = preceduto
dall’identificatore di una cella di memoria e seguito
da un’espressione che definisce un valore, e
terminato da un ';':
– identificatore = espressione;
– NB: Il simbolo di '=' indica l'assegnamento, non
l'uguaglianza
• L’espressione può essere costituita da:
– valori costanti
– identificatori di variabili
– una loro combinazione ottenuta mediante i normali
operatori aritmetici (+,-, *, /) e parentesi, come nelle
consuete espressioni aritmetiche
Esempi di assegnamento
• Esempi :
–
–
–
–
–
x = 23;
w = 'a';
y = z;
r3 = (alfa*43–xgg)*(delta–32*ijj);
x = x+1;
• Esecuzione di istruzione di assegnamento:
– valutazione dell’espressione
– memorizzazione del risultato nella variabile a
sinistra di '='
Istruzioni di ingresso/uscita
• L’istruzione scanf permette all’utente di immettere
un dato attraverso lo standard input
scanf(x);
Il valore immesso dall’utente viene inserito nella
variabile x
• L’istruzione printf permette al calcolatore di inviare
allo standard output (tipicamente: il monitor) il
valore di una variabile o di un’espressione
printf(x);
Il valore della variabile x viene inviato allo standard
output
printf((x+y)/10);
Il valore dell’espressione (x+y)/10 viene inviato allo
standard output
scanf(a);
a,b
(a>b)
scanf(b);
xa
yb
q  x/y
r  x-q*y
sì
printf(y);
y è l’MCD
r = 0?
no
xy
yr
Casi particolari di espressioni
• carattere: per evitare ambiguità con gli
identificatori, i caratteri vengono racchiusi
tra apici:
printf('a');
• le stringhe, similmente vengono racchiuse
tra doppi apici:
printf("alfa");
– questa è un'abbreviazione per la sequenza
printf('a');
printf('l');
printf('f');
printf('a');
Esempi di programma
• Un programma che stampa a video “Buongiorno a
tutti”:
main(){
printf(“Buongiorno a tutti”);
}
• Un programma che legge da tastiera due numeri
(che vengono memorizzati nelle variabili a e b), e
ne stampa la somma a video:
main(){
scanf(a);
scanf(b);
printf(a+b);
}
Istruzioni semplici e complesse
• Le istruzioni di assegnamento e di
ingresso/uscita eseguono un’operazione
elementare
• Esistono istruzioni complesse la cui
esecuzione consta del compimento di più
operazioni in sequenza: le istruzioni
condizionate e quelle iterative
• Istruzioni condizionali: controllo di
condizione + eventuale esecuzione di
istruzioni
• Istruzioni iterative: controllo di condizione
+ eventuale esecuzione ripetuta di
istruzioni
Istruzioni condizionali
• Le istruzioni condizionali consentono
di eseguire due diverse sequenze di
istruzioni in alternativa, in base al
verificarsi o meno di una condizione
sequenza
di istruzioni
1
sì
condizione?
no
sequenza
di istruzioni
2
Istruzioni condizionali in C
• La parola chiave è if:
if (condizione)
{ sequenza di istruzioni }
• Se la condizione è vera, la sequenza di
istruzioni viene eseguita, altrimenti no.
• Altra parola chiave: else (altrimenti)
• else introduce le istruzioni che devono
essere eseguite se la condizione è falsa
Esempio
if(y > 100)
{ x = 2;
y = y+1;
}
else
{ y = 150; }
sì
x=2;
y = y+1;
y>100?
no (else)
y = 150;
• Il ramo else può essere assente; se il ramo else non c'è, se la
condizione è falsa non viene eseguita la sequenza di
istruzioni 1, e si va avanti con il resto del programma.
• Per brevità, se le sequenze sono fatte di una sola istruzione,
le graffe si possono omettere
Specifica delle condizioni in C
• Solitamente le condizioni riguardano il
valore di certe variabili
• == uguaglianza (simbolo diverso da
quello dell’assegnamento)
• < (minore), > (maggiore), <= (minore
o uguale) , >= (maggiore o uguale), !=
(diverso)
• if (x==0) x = x+1;
• if (y > 100) { x = x*y; z = 4; }
Condizioni composte
• Una condizione può essere semplice, come
gli esempi precedenti, oppure composta da
diverse sottocondizioni, unite tra loro
tramite operatori logici
• ! negazione (non), && congiunzione (e), ||
disgiunzione (oppure)
• !(x==4)
x NON è uguale a 4
• (x<10)&&(y>=100)
x minore di 10 e y maggiore o uguale a 100
• (y==1)||(z!=2)
y è uguale a 1 o z è diverso da 2
Operatori logici
• Data una condizione C, !C ha il valore
di verità opposto
• Date due condizioni C1 e C2, C1&&C2
è vera solo quando sia C1 sia C2 sono
vere, ed è falsa in tutti gli altri casi
• Date due condizioni C1 e C2, C1||C2 è
falsa solo quando sia C1 sia C2 sono
false, ed è vera in tutti gli altri casi
Tabelle di verità
C
!C
V
F
C1
C2
C1&&C2
F
V
V
V
V
V
F
F
F
V
F
F
F
F
operatore NOT
C1
C2
C1||C2
V
V
V
V
F
V
F
V
V
F
F
F
operatore OR
operatore AND
Precedenza tra gli operatori
• Data la condizione C1 && !C2 || C3,
conoscendo i valori di verità di C1, C2, e
C3, come si procede per il controllo?
• ! precede &&
• && precede ||
• Quindi le condizione composta equivale a
(C1 && (!C2))||C3
• Usare le parentesi aiuta a eliminare i dubbi
e anche a modificare le precedenze
• !( (C4||C5) && C6 )
Esempi
• if semplice
if (x==0)&&(y<10)
x=y;
x=x+1;
• if...else
if (x==0)&&(y<10)
x=y;
else
x=x+1;
• I risultati che otteniamo sono diversi
If semplice
sì
(x==0)&&(y<10)
?
x=y
if (x==0)&&(y<10)
x=y;
x=x+1;
x=x+1
no
If … else
sì
x=y
if (x==0)&&(y<10)
x=y;
else
x=x+1;
(x==0)&&(y<10)
?
no (else)
x=x+1
Uso delle parentesi graffe
• Le parentesi graffe { } delimitano un
blocco di istruzioni: un insieme di
istruzioni che vengono considerate
come un’unica istruzione
• Il loro uso può modificare la sequenza
di istruzioni eseguita in un’istruzione
condizionale
Esempio
• if semplice con istruzioni semplici
if (x==0)&&(y<10)
x=y;
x=x+1;
• if semplice con blocco di istruzioni
if (x==0)&&(y<10) {
x=y;
x=x+1; }
If semplice
sì
(x==0)&&(y<10)
?
x=y
if (x==0)&&(y<10)
x=y;
x=x+1;
x=x+1
no
If semplice con blocco di
istruzioni
sì
x=y;
x=x+1;
if (x==0)&&(y<10) {
x=y;
x=x+1; }
(x==0)&&(y<10)
?
no
Esempio errato
• Il seguente esempio invece è
scorretto, perché all’interno del blocco
avremmo un else non associato ad
alcun if
if (x==0)&&(y<10) {
x=y;
else
x=x+1; }
If innestati
• Le istruzioni che vengono eseguite
all’interno di un costrutto if possono a
loro volta essere istruzioni
condizionali
if (x==0)&&(y<10)
if (x != y)
x=x+1;
Nota sull’istruzione if…else
• if (C1) if (C2) S1; else S2;
significa:
if (C1)
if (C2) S1;
else S2;
oppure
if (C1)
if (C2) S1;
else S2;
???
• Convenzione: l’else viene attribuito all’ultimo if.
Altrimenti, scriviamo esplicitamente:
if (C1) {if (C2) S1;} else S2;
Istruzioni iterative in C
• La parola chiave è while:
while (condizione)
{ sequenza di istruzioni }
Esecuzione dell’istruzione
iterativa
1.viene valutata la condizione
2.se la condizione è falsa, non viene eseguito il
corpo del ciclo (la sequenza di istruzioni), e si
passa all’istruzione successiva al while
3.altrimenti viene eseguito una volta il corpo del
ciclo, quindi si ricomincia (viene valutata la
condizione etc.)
sequenza
di
istruzioni
si
condizione?
no
While
sì
(x<0)?
x=x+1
while (x<0)
x=x+1;
x=y;
x=y
no