Corso Programmazione C

Titolo unità didattica: Concetto di Algoritmo [01]
Titolo modulo : Algoritmi per esecutori umani [01-T]
Algoritmi come “istruzioni operative di uso” nella vita quotidiana
Argomenti trattati:
9 definizione intuitiva di algoritmo
9 origine della parola algoritmo
9 problema, algoritmo, soluzione, esecutore
9 capacità dell’esecutore
9 esempi di algoritmi per esecutori umani
9 esigenza di un linguaggio di descrizione degli algoritmi
9 algoritmi e sequenze di operazioni
Prerequisiti richiesti: nessuno

prima definizione informale di algoritmo
un
un procedimento
procedimento per
per risolvere
risolvere un
un problema
problema
un
unalgoritmo
algoritmoèèun unprocedimento
procedimentoche checonsente
consentedi di
ottenere
ottenereun unrisultato
risultatoatteso
attesoeseguendo,
eseguendo,in inun
undeterminato
determinato
ordine,
ordine,ununinsieme
insiemedidi passi
passisemplici
semplici corrispondenti
corrispondentiad ad
azioni
azioniscelte
sceltesolitamente
solitamenteda daun
uninsieme
insiemefinito.
finito.
(da
(da Wikipedia,
Wikipedia,versione
versioneitaliana,
italiana,06/2007
06/2007
http://en.wikipedia.org/wiki/Main_Page)
http://en.wikipedia.org/wiki/Main_Page
http://en.wikipedia.org/wiki/Main_Page)
nel senso più ampio della parola, il libretto delle istruzioni

di un’automobile o di un elettrodomestico, una ricetta di
cucina, etc., sono algoritmi
il termine algoritmo deriva dal nome del matematico
persiano Al KhwƗrizmƯ
Mu‫ف‬ammad ibn MǌsƗ al-KhwƗrizmƯ
(ϲϣίέ΍ϮΨϟ΍ ϰγϮϣ ϦΑ ΪϤΤϣ)
matematico, astronomo e geografo
persiano (780 – 845 circa).
Il nome fa riferimento alla sua città natale
Khwarizm (oggi Khiva), nella provincia
Khorasan dell’impero Abbasside (oggi
provincia di Xoram, Uzbekistan)
principali libri scritti da Al-Khwarizmi
KitƗb al-Jam wa-l-tafrƯq bi-‫ف‬isƗb al-Hind
(il libro delle addizioni e delle sottrazioni, in
accordo al sistema di numerazione indiano)
Manuale di matematica
Algoritmi de numero indorun

(Al-Khwarizmi sui numeri indiani)
Manuale di aritmetica
Dixit algorizmi …
“Così disse al-KhwƗrizmƯ…."
Giovanni Villani, Cronica, circa 1330
Troviamo […] in Firenze da novantamila bocche tra

uomini e femmine e fanciulli […]. Troviamo ch’e
fanciulli e fanciulle, che stanno a leggere, da otto a
diecimila; i fanciulli che stanno a imparare l’abbaco
e algorismo in sei scuole, da mille a millecinquecento
…
citato in
Fabrizio Luccio e Linda Pagli
Algoritmi, divinità e gente comune
Edizioni ETS, 1999
riformulazione della definizione di Wikipedia
un
unalgoritmo
algoritmoèèununprocedimento
procedimentoche checonsente
consentedi dirisolvere
risolvere
un
unproblema
problema eseguendo,
eseguendo,una unadopo
dopol’altra
l’altraeein
inunun
determinato
determinatoordine,
ordine,una
unasequenza
sequenzadi disemplici
semplicioperazioni.
operazioni.
Le
Leoperazioni
operazioninon
nonsono
sonoarbitrarie,
arbitrarie,ma
madevono
devonoessere
essere scelte
scelte
da
daun
un insieme
insiemefinito
finitodi
dioperazioni
operazioniconsentite
consentite
(un
(unelenco
elencodi dioperazioni)
operazioni)
un algoritmo viene progettato per

essere eseguito
la sua esecuzione consente di
esecutore
esecutore risolvere un problema progettistaprogettista
la
la descrizione
descrizione dell'algoritmo
dell'algoritmo èè in
in un
un
linguaggio
linguaggio comprensibile
comprensibile dall'esecutore
dall'esecutore
numero 1
tavoletta
Sumera, valle
dell’Eufrate,
2500 a.C
numero 60
numero 10 numero 600
algoritmo per suddividere un granaio di grano tra più individui:
input: la capacità del granaio, la parte prestabilita per persona;
output: numero di persone che possono ricevere la parte di grano.
la
latavoletta
tavolettaèèla
la
descrizione
descrizionedidiun
unalgoritmo
algoritmodididivisione
divisione
algoritmo di
divisione
A) calcolo inverso
del divisore
tavoletta
B) prodotto per il
babilonese,
dividendo
1800 a.C
la
latavoletta
tavolettaèèla
la
descrizione
descrizionedidiun
unalgoritmo
algoritmodididivisione
divisione
problema: cambio di una ruota bucata di un'auto
operazioni elementari: avvitare/svitare i bulloni,
individuare la ruota bucata/di scorta, mettere/togliere
una ruota, alzare/abbassare l'auto
algoritmo
algoritmo
svitare
svitare ii bulloni
bulloni della
della ruota
ruota bucata
bucata
sollevare
sollevare l'auto
l'auto
togliere
togliere lala ruota
ruota bucata
bucata
mettere
mettere la la ruota
ruota di
di scorta
scorta
abbassare
abbassare l'auto
l'auto
avvitare
avvitare ii bulloni
bulloni della
della ruota
ruota di
di scorta
scorta
fine
fine algoritmo
algoritmo
flowchart: convenzione grafica per la descrizione di un
algoritmo
inizio
svitare i bulloni della ruota bucata
sollevare l’auto
togliere la ruota bucata
mettere la ruota di scorta
abbassare l’auto
avvitare i bulloni della ruota di scorta
fine
si supponga che l’operazione
svitare/avvitare i bulloni
non sia una operazione elementare per l’esecutore
si supponga che l’operazione

svitare/avvitare un bullone
sia una operazione elementare per l’esecutore
è necessario descrivere l’operazione

svitare/avvitare i bulloni
in termini dell’operazione
svitare/avvitare un bullone
(ripetizione della stessa azione)
algoritmo
algoritmo
svitare
svitare un
un bullone
bullone della
della ruota
ruota bucata
bucata
svitare
svitare un
un bullone
bullone della
della ruota
ruota bucata
bucata
svitare
svitare un
un bullone
bullone della
della ruota
ruota bucata
bucata
svitare
svitare un
un bullone
bullone della
della ruota
ruota bucata
bucata
sollevare
sollevare l'auto
l'auto
togliere
togliere la
la ruota
ruota bucata
bucata
mettere
mettere lala ruota
ruota di
di scorta
scorta
abbassare
abbassare l'auto
l'auto
avvitare
avvitare unun bullone
bullone della
della ruota
ruota di
di scorta
scorta
avvitare
bullone della
della ruota
ruota di
di scorta
scorta
avvitare
bullone della
della ruota
ruota di
di scorta
scorta
avvitare
bullone della
della ruota
ruota di
di scorta
scorta
fine
fine algoritmo
algoritmo
descrizione concisa di sequenze di
operazioni uguali
ripetere:
ripetere:
svitare
svitare un
un bullone
bullone della
della ruota
ruota bucata
bucata
svitare un bullone della loop

ruota bucata
loop
denota
denota una
una sequenza
sequenza infinita
infinita di
di azioni
azioni
ripetere:
ripetere:
svitare
svitare unun bullone
bullone della
della
ruota
ruota bucata
bucata
finché:
finché: tutti
tutti ii bulloni
bulloni sono
sono svitati
svitati
svitare un bullone della

ruota bucata
tutti i bulloni
sono svitati
F
SUHGLFDWR
SUHGLFDWR
V
costrutto
costrutto didi controllo
controllo
di
di ripetizione
ripetizione
algoritmo
algoritmo
ripetere:
ripetere:
svitare
svitare un
un bullone
bullone della
della ruota
ruota bucata
bucata
finché:
finché: tutti
tutti ii bulloni
bulloni sono
sono svitati
svitati
sollevare
sollevare l'auto
l'auto
togliere
togliere la
la ruota
ruota bucata
bucata
mettere
mettere lala ruota
ruota didi scorta
scorta
abbassare
abbassare l'auto
l'auto
ripetere:
ripetere:
avvitare
bullone della
della ruota
ruota di
di scorta
scorta
finché:
finché: tutti
tutti ii bulloni
bulloni sono
sono avvitati
avvitati
fine
fine algoritmo
algoritmo
algoritmo
algoritmo
se:
se: c’è
c’è la
la ruota
ruota di
di scorta
scorta
allora:
allora:
cambiare
cambiare la
la ruota
ruota bucata
bucata
altrimenti:
altrimenti:
chiamare
chiamare ilil meccanico
meccanico
fine
fine algoritmo
algoritmo
V c’è la ruota F
di scorta
cambiare la chiamare il
ruota bucata meccanico
costrutto
costruttodi
dicontrollo
controllo
diselezione
di selezione
algoritmo
algoritmo
se:
se: c’è
c’è la
la ruota
ruota di di scorta
scorta
allora:
allora:
ripetere:
ripetere:
svitare
svitare un un bullone
bullone della
della ruota
ruota bucata
bucata
finché:
finché: tutti
tutti ii bulloni
bulloni sono
sono svitati
svitati
sollevare
sollevare l'auto
l'auto
togliere
togliere la la ruota
ruota bucata
bucata
mettere
mettere la la ruota
ruota didi scorta
scorta
abbassare
abbassare l'autol'auto
ripetere:
ripetere:
avvitare
avvitare un un bullone
bullone della
della ruota
ruota di
di scorta
scorta
finché:
finché: tutti
tutti ii bulloni
bulloni sono
sono avvitati
avvitati
altrimenti:
altrimenti:
chiamare
chiamare ilil meccanico
meccanico
fine
fine algoritmo
algoritmo
un algoritmo denota una sequenza di operazioni
sequenza 1 (c’è la ruota di scorta):

svitare un bullone della ruota bucata, svitare un
bullone della ruota bucata, svitare un bullone della
ruota bucata, svitare un bullone della ruota bucata,
sollevare l'auto, togliere la ruota bucata, mettere la
ruota di scorta, abbassare l'auto, avvitare un bullone
della ruota di scorta, avvitare un bullone della ruota di
scorta, avvitare un bullone della ruota di scorta,
avvitare un bullone della ruota di scorta.
sequenza 2 (non c’è la ruota di scorta):

chiamare il meccanico
algoritmo
algoritmo
prendere
prendere un un uovo,
uovo, prendere
prendere un un Kg
Kg di
di farina
farina
prendere
prendere 1/2 1/2 kg
kg didi zucchero,
zucchero, prendere
prendere uno uno
yogurt
yogurt
rompere
rompere l'uovo
l'uovo
mettere
mettere l'uovo
l'uovo nel
nel frullatore,
frullatore, mettere
mettere lo lo
zucchero
zucchero nel nel frullatore
frullatore
mettere
mettere la la farina
farina nel
nel frullatore
frullatore
mettere
mettere lo lo yogurt
yogurt nel
nel frullatore
frullatore
frullare
frullare
versare
versare inin una
una teglia,
teglia, mettere
mettere in
in forno
forno aa 200C
200C
ripetere:
ripetere:
controllare
controllare la la doratura
doratura
fare
fare altro
altro per
per 55 minuti
minuti
finché:
finché: doratura
doratura OK OK
togliere
togliere la
la teglia
teglia dal
dal forno
forno
fine
fine algoritmo
algoritmo
g
un
unalgoritmo
algoritmoèèun
untesto,
testo,che
chedeve
deveessere
esseredescritto
descrittoin
in
modo
modononnonambiguo
ambiguoper perl’esecutore
l’esecutoreutilizzando
utilizzando
9
9 un
uninsieme
insiemedi
di costrutti
costruttididicontrollo
controlloee
9
9 un
uninsieme
insiemedi
di istruzioni
istruzioniche
chedenotano
denotano
operazioni
operazioni(eseguibili
(eseguibilidall’esecutore)
dall’esecutore)
un
unalgoritmo
algoritmodenota
denotauna
unaoopiù
più sequenze
sequenzefinite
finite di
di
azioni
azioniche
chel’esecutore
l’esecutoredeve
deveeffettuare
effettuare
eseguire
eseguireun
unalgoritmo
algoritmosignifica
significaeseguire
eseguireunaunatra
trale
le
sequenze
sequenzedi diazioni
azionidenotate
denotatedall’algoritmo
dall’algoritmo
Titolo unità didattica: Concetto di Algoritmo [01]
Titolo modulo : Algoritmi per calcolare [02-T]
Algoritmi per risolvere semplici problemi aritmetici
Argomenti trattati:
9 algoritmo per il calcolo di sommatorie
9 algoritmo per il calcolo della media
9 definizione di algoritmo
9 dati di input, dati locali, dati di output
Prerequisiti richiesti: AP-01-1-T

problema:
calcolo della somma di un insieme di numeri
operazioni elementari: calcolo della somma di due
numeri, azzeramento
insieme qualunque di numeri Î i valori non sono predeterminati

la cardinalità dell’insieme non è predeterminata
un algoritmo viene progettato per essere eseguito

la sua esecuzione consente di risolvere un
problema; la descrizione dell'algoritmo è in un
linguaggio comprensibile dall'esecutore
problema:
numeri, azzeramento
insieme qualunque di numeri Î i valori non sono predeterminati

la cardinalità dell’insieme non è predeterminata
un algoritmo viene progettato per essere eseguito

la sua esecuzione consente di risolvere una
classe di problemi; la descrizione dell'algoritmo è
in un linguaggio comprensibile dall'esecutore
problema:
numeri, azzeramento
algoritmo
algoritmo
azzerare
azzerare ilil totale
totale
ripetere:
ripetere:
sommare
sommare un un numero
numero alal totale
totale
finché:
finché: non
non ci ci sono
sono altri
altri numeri
numeri
fine
fine algoritmo
algoritmo
inizio
azzerare il totale
sommare un numero al totale
F
non ci sono
altri numeri
fine
Esempio: numeri da sommare {5,7,10,-2}
sequenza di operazioni elementari:

totale è 0, totale è 0+5, totale è 5+7,
totale è 12+10, totale è 22-2
il risultato dell'esecuzione dell'algoritmo

è il valore finale di totale, cioè 20
risolve
risolve ilil problema
problema della
della somma
somma didi un
un insieme
insieme
costituito
costituito da da un
un numero
numero qualunque
qualunque di
di numeri
numeri
algoritmo
algoritmo
azzerare
totale
ripetere:
ripetere:
sommare
numero alal totale
totale
finché: non
finché: non ci ci sono
sono altri
altri numeri
numeri
fine
fine algoritmo
algoritmo
algoritmo
algoritmo
azzerare
totale
ripetere:
ripetere:
sommare
numero alal totale
totale
finché: non
finché: non ci ci sono
sono altri
altri numeri
numeri
fine
fine algoritmo
algoritmo
totale
totale èè 00
algoritmo
algoritmo
azzerare
totale
ripetere:
ripetere:
sommare
numero alal totale
totale
finché:
finché: non
non ci ci sono
sono altri
altri numeri
numeri
fine
fine algoritmo
algoritmo
totale
totale èè 00
algoritmo
algoritmo
azzerare
totale
ripetere:
ripetere:
sommare
numero alal totale
totale
finché:
finché: non
non ci ci sono
sono altri
altri numeri
numeri
fine
fine algoritmo
algoritmo
totale
totale èè 55
algoritmo
algoritmo
azzerare
totale
ripetere:
ripetere:
sommare
numero alal totale
totale
finché:
finché: non
non ci ci sono
sono altri
altri numeri
numeri
fine
fine algoritmo
algoritmo
totale
totale èè 55
algoritmo
algoritmo
azzerare
totale
ripetere:
ripetere:
sommare
numero alal totale
totale
finché:
finché: non
non ci ci sono
sono altri
altri numeri
numeri
fine
fine algoritmo
algoritmo
totale
totale èè 12
12 5+7=12
algoritmo
algoritmo
azzerare
totale
ripetere:
ripetere:
sommare
numero alal totale
totale
finché:
finché: non
non ci ci sono
sono altri
altri numeri
numeri
fine
fine algoritmo
algoritmo
totale
totale èè 12
12
algoritmo
algoritmo
azzerare
totale
ripetere:
ripetere:
sommare
numero alal totale
totale
finché:
finché: non
non ci ci sono
sono altri
altri numeri
numeri
fine
fine algoritmo
algoritmo
totale
totale èè 22
22 12+10=22
algoritmo
algoritmo
azzerare
totale
ripetere:
ripetere:
sommare
numero alal totale
totale
finché:
finché: non
non ci ci sono
sono altri
altri numeri
numeri
fine
fine algoritmo
algoritmo
totale
totale èè 22
22
algoritmo
algoritmo
azzerare
totale
ripetere:
ripetere:
sommare
numero alal totale
totale
finché:
finché: non
non ci ci sono
sono altri
altri numeri
numeri
fine
fine algoritmo
algoritmo
totale
totale èè 20
20 22-2=20
algoritmo
algoritmo
azzerare
totale
ripetere:
ripetere:
sommare
numero alal totale
totale
finché:
finché: non
non ci ci sono
sono altri
altri numeri
numeri
fine
fine algoritmo
algoritmo
totale
totale èè 20
20
problema:
calcolo della media di un insieme di numeri
operazioni elementari: somma di due numeri,
azzeramento, divisione di due numeri
algoritmo
algoritmo
azzerare
totale
azzerare
azzerare ilil contatore
contatore
ripetere:
ripetere:
sommare
numero al al totale
totale
sommare
sommare 11 al al contatore
contatore
finché:
finché: non
non cici sono
sono altri
altri numeri
numeri
la
la media
media èè ilil totale
totale diviso
diviso ilil contatore
contatore
fine
fine algoritmo
algoritmo
Esempio: insieme dei numeri {8,2,1,-2,6}
sequenza di operazioni elementari:

totale è 0, contatore è 0, totale è 0+8, contatore è
1, totale è 8+2, contatore è 2, totale è 10+1,
contatore è 3, totale è 11-2, contatore è 4, totale
è 9+6, contatore è 5, media è 15/5.
il risultato dell'esecuzione dell'algoritmo

è il valore finale di media, cioè 3
definizione di algoritmo
un
un algoritmo
algoritmo èè un un procedimento
procedimento per per la
la
risoluzione
risoluzione di di una
una classe
classe didi problemi,
problemi,
descritto
descritto dada una sequenza finita
una sequenza finita di
di
costrutti
costrutti didi controllo
controllo ee di di istruzioni
istruzioni
non
non ambigue
ambigue perper l’esecutore,
l’esecutore, che che specifica
specifica
una
una sequenza
sequenza finita
finita di
di operazioni,
operazioni,
elementari
elementari perper l’esecutore,
l’esecutore, cheche agiscono
agiscono
su
su un
un insieme
insieme finito
finito di
di oggetti
oggetti
9 Finitezza: “un algoritmo deve sempre terminare dopo un
Donald E. KNUTH (1968, 1973): 5 proprietà di un algoritmo:
9 Non ambiguità: “ogni passo di un algoritmo deve essere

numero finito di passi …, un ragionevole numero di passi"
precisamente definito; le operazioni che devono essere

effettuate devono essere specificate in modo rigoroso e non
9 Input: "... le quantità che sono note all’inizio e che devono

ambiguo per ogni caso"
essere fornite prima che l’esecutore inizi l’esecuzione

dell’algoritmo; questi (dati di) input sono appartengono a uno
9 Output: "... la soluzione del problema; quantità che hanno

specifico insieme di oggetti"
9 Efficacia: "... Tutte le operazioni da effettuare nell’algoritmo

una specifica relazione con i dati di input"
devono essere sufficientemente elementari da poter essere,

in linea di principio, effettuate da una persona usando carta
e penna"
gli oggetti su cui opera un algoritmo sono
detti i dati dell'algoritmo
i dati che devono essere necessariamente noti

prima dell'esecuzione sono detti dati di input (o
dati di ingresso)
il risultato dell'esecuzione è detto dato (o dati)

di output (o dati di uscita)
i dati che non sono né di input né di output sono

detti dati locali (o dati intermedi)
dati di algoritmo dati di
input output
insieme la
di algoritmo somma
numeri
insieme la
di algoritmo media
numeri
Titolo unità didattica: Concetto di Variabile [02]
Titolo modulo : Variabili e tipi [01-T]
Nozioni di base sulle variabili in programmazione
Argomenti trattati:
9 tipi di dati
9 definizione di variabile
9 tipo di una variabile
9 dichiarazione del tipo di una variabile
9 associazione di un valore a una variabile
Prerequisiti richiesti: AP-01-*-T

nozioni
nozioni di
di base
base di
di programmazione
programmazione
introdurre le nozioni di base

in modo indipendente
dal particolare linguaggio di programmazione
insieme
insieme di
di
convenzioni
convenzioni di
di esempio
esempio
(pseudo-linguaggio)
(pseudo-linguaggio)
un
un algoritmo
algoritmo opera
opera su
su dati
dati
(detti
(detti anche
anche valori)
valori))
ii dati
dati fondamentali
fondamentali (tipi
(tipi di
di dati)
dati) sono:
sono:
numeri,
numeri, caratteri
caratteri di di un
un alfabeto,
alfabeto,
stringhe
stringhe di di caratteri,
caratteri, valori
valori didi verità
verità
3.5578
3.5578 èè un
un numero
numero
21
21 èè un
un numero
numero
zz èè un
un carattere
carattere
ROSSI
ROSSI èè una
una stringa
stringa di
di caratteri
caratteri
vero
vero èè un
un valore
valore di
di verità
verità
ii dati
dati sono
sono classificati
classificati in
in insiemi
insiemi detti
detti tipi
tipi
3.5578
3.5578 èè un
un dato
dato di
di tipo
tipo numero
numero reale
reale
21
21 èè un
un dato
dato di
di tipo
tipo numero
numero intero
intero
zz èè un
un dato
dato di
di tipo
tipo carattere
carattere
ROSSI
ROSSI èè un
un dato
dato di
di tipo
tipo stringa
stringa di
di caratteri
caratteri
vero
vero èè un
un dato
dato di
di tipo
tipo valore
valore di
di verità
verità
necessità di convenzioni
21
21 èè un
un dato
dato di
di tipo
tipo numero
numero reale?
reale?
99 èè un
un dato
dato di
di tipo
tipo carattere?
carattere?
zz èè un
un dato
dato di
di tipo
tipo stringa
stringa di
di caratteri?
caratteri?
vero
vero èè un
un dato
dato di
di tipo
tipo stringa
stringa di
di caratteri?
caratteri?
3.1415
3.1415 èè un
un dato
dato di
di tipo
tipo stringa
stringa di
di caratteri?
caratteri?
una convenzione può essere:
5 è un dato di tipo intero
3.141592 è un dato di tipo reale
-27 è un dato di tipo intero
‘z’ è un dato di tipo carattere
“Rossi” è un dato di tipo stringa di
caratteri
true (vero) è un dato di tipo logico
false (falso) è un dato di tipo logico
9 numero intero (integer)

tipi di dati fondamentali
9 numero reale
9 carattere
(real)
9 stringa di caratteri (string)

(character)
9 logico (logical)
una
una variabile
variabile èè un
un nome
nome aa cui
cui si
si
può
può associare
associare un
un dato,
dato,
che
che èè detto
detto ilil valore
valore della
della variabile
variabile
motivazioni:
denotare i dati attraverso nomi
(il lato è 3.5578, il cognome è ROSSI, l’età è
53,…)
evitare i dettagli (astrazione) relativi alla modalità
di rappresentazione dei dati (in memoria)
sviluppare algoritmi generali, per risolvere classi
di problemi (l’area è base per altezza)
una
una variabile
variabile èè un
un nome
nome aa cui
cui si
si
può
può associare
associare un
un dato,
dato,
che
che èè detto
detto ilil valore
valore della
della variabile
variabile
ilil tipo
tipo di
di una
una variabile
variabile indica
indica
l'insieme
l'insieme dei dei valori
valori che
che èè possibile
possibile
associare
associare alla
alla variabile
variabile
l'operazione di dichiarazione di una
variabile consente di specificare in
modo univoco il tipo di una variabile
9 un insieme di (identificatori di) variabili
la dichiarazione di variabili deve specificare
9 il loro tipo

var <variabili>: <tipo>
identificatori di variabile
Esempio:
Esempio: tipo
var
var lato:
lato: real
real
var
var nome_proprio,cognome:
nome_proprio,cognome: string
string
var
var eta_anni:
eta_anni: integer
integer
var <variabili>: <tipo>
Esempio:
Esempio:
var
var lato:
lato: real
real
var raggio,circonferenza:
var raggio,circonferenza: real
real
var
var lettera_alfabeto,
lettera_alfabeto, simbolo:
simbolo: character
character
var
string
var
var eta_anni:
eta_anni: integer
integer
var
var p:
p: logical
logical
una
una variabile
variabile èè indeterminata
indeterminata
se
se non
non èè stata
stata dichiarata
dichiarata
ROSSI
cognome
cognome è il nome della variabile

ROSSI è il valore della variabile cognome
una
una variabile
variabile èè definita
definita se
se aa essa
essa èè
associato
associato un
un valore
valore (del
(del suo
suo tipo)
tipo)
ROSSI
cognome
cognome è il nome della variabile

ROSSI è il valore della variabile cognome
una
una variabile
variabile èè indefinita
indefinita se
se aa essa
essa
non
non èè associato
associato alcun
alcun dato
dato
variabili scalari (o ordinarie):
variabili a cui è possibile associare
un solo valore alla volta
tipi
tipi (scalari)
(scalari)
9
9 numero
tipi
tipi fondamentali:
fondamentali: primitivi
primitivi
9
9 numero
numero intero
intero (integer)
(integer)
9
9 carattere
numero reale
reale (real)
(real)
9
9 stringa
carattere (character)
(character)
9
9 logico
stringa di
di caratteri
caratteri (string)
(string)
logico (logical)
(logical)
un
un tipo
tipo consiste
consiste di
di
un
un
un insieme
insieme di
di valori
valori
un insieme
insieme di
di operazioni
operazioni consentite
consentite
un
sui
sui valori
valori
un criterio
criterio di
di rappresentazione
rappresentazione in
in
memoria (rappresentazione interna)
memoria (rappresentazione interna)
ogni
ogni tipo
tipo primitivo
primitivo ha
9
ha
9 ilil proprio
proprio insieme
insieme di di dati
9
dati
9 le
le proprie
proprie operazioni
operazioni suisui dati
9
dati
9 la
la propria
propria modalità
modalità didi rappresentazione
rappresentazione
interna
interna dei
dei dati
dati
variabile di tipo string
cognome
variabile di tipo real
lato
variabile di tipo integer
eta_anni
ROSSI variabile di tipo string
cognome
3.5578 variabile di tipo real
lato
53 variabile di tipo integer
eta_anni
azioni di base
ROSSI
accesso al valore della variabile
(qual è il valore della variabile?)
cognome
cambiamento del valore della variabile

(sostituzione del vecchio valore della variabile
con un nuovo valore)
visualizzazione (su schermo) del valore

della variabile
(“ il valore della variabile è …”)
ROSSI VERDI
cognome
3.5578 93.294
lato
VERDI
viene perduto il
cognome vecchio valore
associato alla
variabile
93.294
lato
l’operazione
l’operazione che
che consente
consente di
di associare
associare
un
un valore
valore aa una
una variabile
variabile èè l’operazione
l’operazione
fondamentale
fondamentale in
in un
un algoritmo
algoritmo
due
due diverse
diverse istruzioni:
¾
istruzioni:
¾ istruzione
¾
¾ istruzione
istruzione di
di assegnazione
assegnazione
istruzione di
di lettura
lettura da
da dispositivo
dispositivo
esterno
esterno di
di input
input
Titolo modulo : Operazione di assegnazione [02-T]
Operazioni di base sulle variabili in programmazione
Argomenti trattati:
9 operazione di assegnazione di un valore a una variabile
9 valutazione delle espressioni

l’operazione
l’operazione che
che consente
consente di
di associare
associare
un
un valore
valore aa una
una variabile
variabile èè l’operazione
l’operazione
fondamentale
fondamentale in
in un
un algoritmo
algoritmo
due
due diverse
diverse istruzioni:
¾
istruzioni:
¾ istruzione
¾
¾ istruzione
istruzione di
di assegnazione
assegnazione
istruzione di
di lettura
lettura da
da dispositivo
dispositivo
esterno
esterno di
di input
input
ROSSI 3.5578
cognome lato
53
eta_anni
VERDI
ROSSI 93.294
3.5578
cognome lato
31
53
eta_anni
VERDI 93.294
cognome lato
31
eta_anni
istruzione di assegnazione:
9 la variabile (destinazione) a cui deve

l’assegnazione deve specificare
9 il valore da assegnare
essere assegnato il valore
9 una espressione, la cui valutazione

oppure
fornisce il valore da assegnare

<variabile> := <valore>
<variabile> := <espressione>
Esempio:
Esempio:
lato
lato :=
:= 3.12
3.12
eta_anni :=
eta_anni := 27
27
9
9
il valore 3.12 è associato alla variabile lato
il valore 27 è associato alla variabile eta_anni
<valore> deve essere un dato del tipo di cui è stata

dichiarata la <variabile>
Esempio:
Esempio:
lato
lato :=
:= 4.23
4.23 ++ 2.1
2.1
eta_anni
eta_anni :=
:= (27
(27 –– 7)/2
7)/2
9 viene valutato il valore dell’espressione

4.23 + 2.1, che è 6.33
9 il valore 6.33 è associato alla variabile lato
(27 – 7)/2, che è 10
9il valore 10 è associato alla variabile eta_anni
Esempio:
Esempio:
var
var area_rett,
area_rett, base,
base, altezza:
altezza: real
real
base
base :=
:= 4.0
4.0
altezza :=
altezza := 3.1
3.1
area_rett
area_rett :=:= base
base ** altezza
altezza
9il valore 4.0 è associato alla variabile base

9 il valore 3.1 è associato alla variabile altezza
(base * altezza), che è 12.4
9il valore 12.4 è associato alla variabile
area_rett
una
una espressione
espressione èè una una combinazione
combinazione didi
variabili
variabili ee dati
dati connessi
connessi da
da operatori
operatori
nella valutazione di una espressione si
utilizzano i valori delle variabili e i dati
una espressione deve essere corretta
deve coinvolgere variabili, dati e operatori

non deve contenere variabili indeterminate o
rispettando la congruenza di tipo
deve avere un unico valore

indefinite
Esempio:
Esempio:
var
var alfa,beta,gamma:
alfa,beta,gamma: integer
integer
alfa
alfa :=
:= 44
beta
beta :=
:= 99
gamma :=
gamma := 3*(alfa+5)-beta
3*(alfa+5)-beta
dopo la prima assegnazione il valore associato
dopo la seconda quello associato a beta è 9
a alfa è 4
viene valutato il valore dell’espressione

dopo la terza assegnazione il valore associato a
3*(alfa+5)-beta, che è 18
gamma è 18
Esempio:
Esempio:
var
var i:
i: integer
integer
ii :=
:= 11
ii :=
:= i+1
i+1
dopo la prima assegnazione il valore

associato a i è 1
dopo la seconda assegnazione il valore

i + 1, che è 2
associato a i è 2
Esempio:
Esempio:
var
var nome,
nome, cognome,
cognome, persona:
persona: string
string
nome
nome :=
:= “Carlo”
“Carlo”
cognome
cognome :=:= “Rossi”
“Rossi”
persona
persona :=
:= nome//“
nome//“ ”//cognome
”//cognome
dopo la prima assegnazione a nome è associato il
valore (stringa) Carlo
dopo la seconda a cognome è associato Rossi
viene valutato il valore dell’espressione convenzione
nome//“ ”//cognome (concatenare il
valore di nome, la spaziatura e il valore di
cognome), che è (la stringa) Carlo Rossi
dopo la terza a persona è associato il valore
(stringa) Carlo Rossi
Esempio:
Esempio:
var
var alfa,beta:
alfa,beta: real
real
var
var delta:
delta: logical
logical
alfa
alfa :=
:= 4.
4.
beta :=
beta := 9.1
9.1
delta
delta :=:= alfa
alfa << beta
beta
dopo la prima assegnazione a alfa è associato 4

dopo la seconda a beta è associato 9.1
alfa < beta, che è true
dopo la terza a delta è associato true
Esempio:
Esempio:
var
var alfa,beta,gamma:
alfa,beta,gamma: integer
integer
alfa
alfa :=
:= 44
beta
beta :=
:= 99
beta :=
beta := 3*(alfa+5)-
3*(alfa+5)- gamma
gamma

dopo la seconda a beta è associato 9
3*(alfa+5)- gamma, che è indefinito
dopo la terza beta è indefinita,

poiché gamma è indefinita
Esempio:
Esempio:
var
var alfa,beta:
alfa,beta: integer
integer
alfa
alfa :=
:= 44
beta
beta :=
:= 99
alfa+beta :=
alfa+beta := beta
beta

dopo la seconda a beta è associato 9
ma - ERRORE - un dato non può essere

beta che è 9
assegnato a una espressione (alfa+beta)

dichiarazione di costanti simboliche

const <costante> = <valore> :<tipo>
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real
const
const e_neper
e_neper == 2.7182818:
2.7182818: real
real
sono
sono indicate
indicate 88 cifre
cifre significative,
significative, cioè
cioè ilil massimo
massimo
consentito
consentito dalla
dalla singola
singola precisione
precisione deldel sistema
sistema
aritmetico
aritmetico floating
floating point
point didi un
un pcpc
valori di tipo reale
una sequenza di cifre decimali precedute
eventualmente dal segno, e contenente il
punto decimale (.) oppure in notazione
esponenziale contenente la E
Esempio:
3.
-0.417
5E9
+298976543212E-26
-3.4E2
Titolo modulo : Operazione di lettura/visualizzazione [03-T]
Operazioni di base sulle variabili in programmazione
Argomenti trattati:
9 operazione di lettura del valore di una variabile da dispositivo
esterno
9 operazione di visualizzazione del valore di una variabile su
dispositivo esterno
Prerequisiti richiesti: AP-02-01-T, AP-02-02-T

l’operazione che consente di associare
un valore a una variabile è l’operazione
fondamentale in un algoritmo
due
due diverse
diverse istruzioni:
¾
istruzioni:
¾ istruzione
¾
¾ istruzione
istruzione di
di assegnazione
assegnazione
istruzione di
di lettura
lettura da
da dispositivo
dispositivo
esterno
esterno di
di input
input
istruzione di lettura da dispositivo esterno
associa a una variabile un valore fornito da un
dispositivo di input durante l'esecuzione dell’algoritmo
9 una variabile viene dichiarata

9 non le viene associato alcun valore
9 quando l’algoritmo viene eseguito, il valore

attraverso assegnazione
viene digitato sul dispositivo esterno di
9 il valore digitato viene associato alla variabile

input (la tastiera)
9 a questo punto, la variabile è stata definita

3.5578
digitare 3.5578
3.5578 lato è una variabile

di tipo real
lato
9 la variabile (destinazione) a cui deve

l’istruzione deve specificare
essere assegnato il valore, o un

insieme di variabili a ognuna delle
quali deve essere assegnato un
(diverso) valore

read <variabili>
associa a una variabile un valore fornito da un
dispositivo di input durante l'esecuzione dell’algoritmo
Esempio:
Esempio:
read
read lato
lato
read
read raggio,
raggio, circonferenza
circonferenza
9 associa a lato il dato che viene trasmesso dal dispositivo
9associa a raggio e circonferenza i due dati trasmessi

esterno (digitato sulla tastiera e seguito da enter)
dal dispositivo esterno (digitati consecutivamente

sulla tastiera e seguiti da enter)
istruzione di scrittura su dispositivo esterno
determina l'invio sul dispositivo standard di

uscita, generalmente lo schermo, del valore
associato alle variabili che compaiono nella lista
<variabili>
9 si accede al valore associato a una variabile

9 il valore viene visualizzato sul dispositivo
9 il valore della variabile rimane inalterato

esterno (lo schermo)
3.5578
3.5578
3.5578 lato è una variabile

di tipo real
lato
9 la variabile il cui valore deve essere

l’istruzione deve specificare
visualizzato sul dispositivo esterno

print <variabili>
Esempio:
Esempio:
print
print lato
lato
print
print raggio,
raggio, circonferenza
circonferenza
print ““ raggio
print raggio == ”,raggio
”,raggio
9 visualizza il valore associato alla variabile lato

9 visualizza, in sequenza, il valore associato alla
variabile raggio e il valore associato alla
9 visualizza la stringa raggio = seguita dal valore

variabile circonferenza
associato alla variabile raggio

problema: sviluppare un algoritmo per calcolare la
circonferenza di un cerchio, di cui è noto il raggio
l'algoritmo ha
9 un dato di input (il valore del raggio)
9 un dato di output (il valore della circonferenza)
l’algoritmo fa uso della famosa formula

(chiusa) per il calcolo della circonferenza c
2S r
di un cerchio, noto il suo raggio r
c
problema: sviluppare un algoritmo per calcolare la
circonferenza di un cerchio, di cui è noto il raggio
dato di input: il valore del raggio (variabile raggio)

dato di output: il valore della circonferenza
(variabile circonferenza)
var
raggio,circonferenza: real
real
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real
read
read raggio
raggio
circonferenza
circonferenza :=:= 2.0*pi_greco*raggio
2.0*pi_greco*raggio
print
print circonferenza
circonferenza
var
real
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real
read
read raggio
raggio
circonferenza
2.0*pi_greco*raggio
print
print circonferenza
circonferenza
3.1415926
2.0 12.566370
circonferenza pi_greco
raggio
12.566370
si digita 2.0
Titolo unità didattica: Introduzione al linguaggio C [03]
Titolo modulo : Linguaggi di programmazione [01-T]
Linguaggio macchina, linguaggi di programmazione di alto livello

e programmi traduttori
Argomenti trattati:
9 linguaggi di programmazione
9 traduttori di linguaggi di programmazione
9 compilatori
9 interpreti
Prerequisiti richiesti: nessuno

livello
livello ++ livello
livello ==
software hardware calcolatore
calcolatore
software hardware
software
macchina
fisica
(hardware)
calcolatore
calcolatore
HARDWARE
esegue programmi scritti nel (proprio)

linguaggio macchina
estremamente elementare
il linguaggio macchina è
usa l’alfabeto binario

di difficile gestione da parte del
programmatore
HARDWARE
+
programma in linguaggio macchina
per il calcolo della somma di n numeri
=
macchina che “sa”
calcolare la somma di n numeri
HARDWARE
+
programma in linguaggio macchina
per il calcolo della media
=
calcolare la media
linguaggio di programmazione
scopo:
descrizione semplice e sintetica di un algoritmo, cioè
dei dati e delle sequenze di operazioni su di essi
programma = algoritmo scritto in un linguaggio

di programmazione
un programma è un testo che descrive una

computazione
un linguaggio di programmazione è un insieme di

convenzioni (standard) formali per descrivere un
programma
il più semplice dei programmi C
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
printf(“questo
printf(“questo e’
e’ il
il mio
mio primo
primo programma
programma C\n”);
C\n”);
}}
l’insieme
l’insieme delle
delle parole
9
parole
9 lessico
lessico corrette
corrette del
del linguaggio
linguaggio
(il
(il dizionario)
dizionario))
9
9 sintassi
sintassi le
le regole
regole per
per mettere
mettere
insieme
insieme le
le parole
parole per
per
costruire
costruire una
una frase
frase
linguaggio formale
linguaggio
linguaggio formale
formale

linguaggio
linguaggio naturale
naturale
9 un linguaggio formale è progettato per

essere completamente non ambiguo
9 un linguaggio formale è conciso e non
ridondante
9 un linguaggio formale può essere
facilmente tradotto in un altro linguaggio
formale
HARDWARE
+
programma (in l.m.) che traduce un programma
scritto in C in un programma scritto
nel linguaggio macchina
=
eseguire programmi C
programma traduttore
un programma traduttore del linguaggio L per

la macchina M è un programma che trasforma
(traduce) un programma (o una porzione di
programma) scritto nel linguaggio L
(programma sorgente, source code)
in un programma equivalente
(programma oggetto, object code)
scritto nel linguaggio macchina della macchina M
programmi traduttori
compilatori interpreti
traduzione globale traduzione ed

esecuzione di una
esecuzione globale istruzione alla volta
processo di compilazione
programma
sorgente
input
programma
in esecuzione
compilatore
output
programma
oggetto
esecuzione
programma programma
oggetto eseguibile
dati di input
programma
in esecuzione
eseguibile
dati di output
eseguire un programma (source code) in
linguaggio compilato:
9 eseguire il programma compilatore,
che produce il programma oggetto
9 eseguire il programma (linker) che

(object code)
trasforma il programma oggetto in

programma eseguibile (executable
9 eseguire il programma eseguibile

code)
programma programma programma
oggetto 1 oggetto 2
…. oggetto n
programmi
programma
di in esecuzione
sistema linker
programma
eseguibile
fasi di compilazione:
9 analisi lessicale, identificazione e
9 analisi sintattica, correttezza della

classificazione dei simboli
combinazione dei simboli in strutture
9 generazione del codice in linguaggio

sintattiche
9 ottimizzazione del programma oggetto

macchina
processo di interpretazione
programma
sorgente dati di input
input
programma
in esecuzione
interprete
output
dati di output
eseguire un programma in linguaggio
interpretato:
9 eseguire il programma interprete, che
considera una direttiva del programma

ripete le seguenti azioni
traduce la direttiva in una sequenza di

sorgente
esegue tale sequenza di istruzioni

istruzioni in linguaggio macchina
conserva i dati di input e di output

generati durante l’esecuzione
compilatore
PRO: una successiva esecuzione del programma
non richiede una successiva compilazione
CONTRO: non c’è interazione tra programmatore e
programma in esecuzione
interprete
PRO: elevata interattività tra programmatore e
programma in esecuzione
CONTRO: ogni successiva esecuzione del
programma comporta ogni volta un processo di
interpretazione
Titolo modulo : Linguaggio di programmazione C [02-C]
Aspetti generali del linguaggio C ed ‘esecuzione’ di un

programma C
Argomenti trattati:
9 introduzione storica al C
9 compilatore e precompilatore
9 ambienti di sviluppo
9 ambiente Visual C++ di Microsoft
9 esecuzione di un semplice programma in C

il linguaggio C è un linguaggio di programmazione
standardizzato (ANSI/ISO C, standard riconosciuto a
livello internazionale)
ideatori:
Ken Thompson, Dennis Ritchie, 1970
9 sviluppo di software applicativo

9 sviluppo di software di sistema
(Unix, Linux, Matlab sono scritti in C)
Dennis Ritchie
http://www.cs.bell-labs.com/who/dmr/
Ken Thompson
http://cm.bell-labs.com/cm/cs/who/ken/
¾1983: l’American National Standards Institute (ANSI) crea un
Comitato, X3J11, per fissare le specifiche standard del C
¾1989: lo standard viene ratificato come ANSI X3.159-1989
"Programming Language C"
¾ questa versione del linguaggio viene spesso definita ANSI
C, Standard C, o anche C89
¾1990: l’ANSI C standard (con alcune modifiche minori) viene
adottato dall’International Organization for
Standardization (ISO) con la sigla ISO/IEC 9899:1990
¾ qusta versione viene spesso chiamata C90
i termini "C89" e "C90" si riferiscono

essenzialmente allo stesso linguaggio
C è un linguaggio di programmazione general-
purpose, strutturato a blocchi, procedurale,
imperativo sviluppato nel 1972 presso i Bell Telephone
Laboratories per esser usato con il sistema operativo
Unix
sebbene nato per scrivere software di sistema, C è

anche ampiamente utilizzato per il software applicativo
C ha anche influenzato molti altri linguaggi di

programmazione, specialmente C++, che è stato
progettato per essere una versione avanzata di C
C ha influenzato lo sviluppo di altri linguaggi di
programmazione:
JAVA, C#, PERL, PHP, JAVASCRIPT
http://www.ansi.org
http://www.ansi.org
corso di C su Wikiversity
http://en.wikiversity.org/wiki/Topic:C
http://en.wikiversity.org/wiki/Topic:C
the Wikiversity content-development project for the C computer

language, part of the Division of Computer Programming
libro di C su Wikibooks
http://en.wikibooks.org/wiki/C_Programming
http://en.wikibooks.org/wiki/C_Programming
il più semplice dei programmi C
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
printf(“questo
printf(“questo e'
e' il
il mio
mio primo
primo programma
programma C\n”);
C\n”);
}}
processo di compilazione
programma
sorgente
input
programma
in esecuzione
compilatore
output
programma
oggetto
esecuzione
programma programma
oggetto eseguibile
dati di input
programma
in esecuzione
eseguibile
dati di output
passi
passi per
per l’esecuzione
l’esecuzione didi un
un programma
programma C
C
(il
(il C
C èè un
un linguaggio
linguaggio compilato)
compilato)
¾ creare un file contenente un programma C
¾ tradurre il programma C in linguaggio

(estensione .c)
¾collegamento con altri programmi di sistema

macchina (compilazione)
¾ eseguire il programma eseguibuile

(linking)
(estensione .exe)
sistema
sistema operativo
operativo Windows
Windows
processo
processo di
di compilazione-linking-esecuzione
compilazione-linking-esecuzione
programma
programma in in CC IN
file programma
programma
file testo,
testo,
estensione
estensione .c.c COMPILATORE
COMPILATORE CC
OUT
IN programma
programma
programma programma oggetto,
oggetto,
LINKER estensione
estensione .obj
.obj
LINKER
OUT
programma ilil programma

programma .exe
.exe
programma eseguibile,
eseguibile,
estensione
estensione .exe
.exe può
può essere
essere eseguito
eseguito
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
printf(“questo
printf(“questo e'
e' il
il mio
mio primo
primo programma
programma C\n”);
C\n”);
}}
l’esecuzione del programma visualizza

sullo schermo la frase
questo e’ il mio primo programma C

Press any key to continue_
ambiente di sviluppo VisualC++ 6.0 di Microsoft
estensione
estensione .c
.c
scrivere il programma C
compilazione
#include <stdio.h>
void main()
{
printf(“questo e' il mio primo programma C\n”);
}
9
ilil compilatore
compilatore CC segnala
9eventuali
segnala
9
eventuali errori
errori (errors)
9eventuali
(errors)
eventuali imprecisioni
imprecisioni (warnings)
(warnings)
linking
esecuzione
ambiente
ambiente di
di sviluppo
sviluppo VisualC++
VisualC++ 6.0
6.0 di
di Microsoft
Microsoft
azioni per modificare ed eseguire di nuovo un
file contenente un programma C già creato in
un progetto
¾ apportare le modifiche al codice sorgente

¾ tradurre il programma C modificato
¾ collegare con altri programmi di sistema

(nuova compilazione)
¾ eseguire il nuovo programma eseguibuile

(nuovo linking)
Fare le correzioni volute
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
printf(“questo
printf(“questo e'
e' il
il mio
mio primo
primo programma
programma C\n”);
C\n”);
}}
struttura di un compilatore per ANSI/ISO C
PRECOMPILATORE
COMPILATORE
richiesta al (pre)compilatore di richiamare le istruzioni di I/O
#include
#include <stdio.h>
<stdio.h>
void
void main()
main() è l’ incipit di ogni programma in C
{{
printf(“questo e'
printf(“questo e' il
il mio
mio primo
primo programma
programma C\n”);
C\n”);
}}
istruzione di visualizzazione della frase (stringa)
questo e' il mio primo programma C
\n provoca l’andata a
capo (stampa del
carattere di fine riga)
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
printf(“questo e'
printf(“questo e' il
il mio
mio primo
primo programma
programma C\n”);
C\n”);
}}
una coppia di apici doppi racchiude ; chiude le

una stringa di caratteri istruzioni
le parentesi { e } racchiudono
il corpo del programma
Titolo modulo : Variabili e tipi in C [03-C]
Sviluppo di semplici programmi C
Argomenti trattati:
9 tipi di dati scalari in C
9 variabili e costanti in C
9 operazione di assegnazione in C
9 operatori aritmetici ed espressioni in C
Prerequisiti richiesti: AP-02-*-T, AP-03-02-C

tipo di dato:
¾ un insieme di valori e un insieme di
operazioni che si possono essere effettuare
su tali valori
¾ un criterio di rappresentazione in memoria,
che stabilisce le modalità in cui i valori del
tipo sono memorizzati nelle celle (voci,
locazioni,…) della memoria
tipi di dati scalari in C
(tipi semplici built-in)
9 tipo intero
9 tipo reale
9 tipo carattere
in C è possibile definire nuovi tipi di dati scalari

(tipi user-defined)
tipo intero in C
int
short
long
unsigned short
unsigned int
unsigned long
tipo intero in C insiemi dei valori
(pc classici, celle di 32 bit)
int -2˙147˙483˙648, +2˙147˙483˙647
short -32˙768, +32˙767
long come int
unsigned short 0, +65˙535

unsigned int 0, +4˙294˙967˙295
unsigned long come int
tipo intero in C
specificazione di un valore del tipo

numeri interi positivi
[+]dddddddddd
numeri interi negativi

-dddddddddd
il numero delle cifre (d) dipende dal particolare tipo C

(dal numero di bit per la rappresentazione in memoria)
tipo intero in C
il comando C
sizeof(tipo)
restituisce il numero di byte necessario per
la rappresentazione di un valore del tipo
sizeof(int)
sizeof(unsigned short)
sizeof(long)
tipo reale in C
float singola precisione,

8 cifre significative
double doppia precisione,

16 cifre significative
long double
tipo reale in C

valori float positivi
[+]dddd.ddddF
[+]dddd.ddddE[±]eeF
valori float negativi

-dddd.ddddF
-dddd.ddddE[±]eeF
il numero delle cifre significative (d) è al più 8

il numero delle cifre dell’esponente (e) è al più 2
tipo reale in C

valori double positivi
[+]dddddddd.dddddddd
[+]dddddddd.ddddddddE[±]eee
valori double negativi

-dddddddd.dddddddd
-dddddddd.ddddddddE[±]eee
il numero delle cifre significative (d) è al più 16

il numero delle cifre dell’esponente (e) è al più 3
tipo reale in C
il comando C
sizeof(tipo)
restituisce il numero di byte necessario per
la rappresentazione di un valore del tipo
sizeof(float)
sizeof(double)
sizeof(long double)
tipo carattere in C
char un solo carattere

dell’alfabeto esteso
codifica ASCII 1 carattere Æ 1 byte
alfabeto esteso: 128 caratteri

000
000 001001 002002 003003 004004 005005 006006 007007 008 008
009
009 010010 011011 012012 013013 014014 015015 016016 017 017
018
018 019019 020020 021021 022022 023023 024024 025025 026 026
027
027 028028 029029 030030 031031 032032 033033!! 034
034"" 035
035##
036
036$$ 037
037%%038
038&&039
039' ' 040
040(( 041
041)) 042
042** 043
043++ 044
044,,
045
045-- 046
046.. 047
047// 048
04800 049
04911 050
05022 051
05133 052
05244 053
05355
054
05466 055
05577 056
05688 057
05799 058
058:: 059
059;; 060
060<< 061
061== 062
062>>
063
063?? 064
064@@065
065AA066
066BB067
067CC068
068DD 069
069EE 070
070FF 071
071GG
072
072HH073
073II 074
074JJ 075
075KK076
076LL 077
077MM078
078NN079
079OO 080
080PP
081
081QQ082
082RR 083
083SS084
084TT 085085UU086
086VV 087
087WW088088XX089
089YY
090
090ZZ 091
091[[ 092
092\\ 093
093]] 094
094^^ 095
095__ 096
096`` 097
097aa 098
098bb
099
099cc 100
100dd 101
101ee 102
102ff 103
103gg 104
104hh 105
105ii 106
106jj 107
107kk
108
108ll 109
109mm110
110nn 111
111oo 112
112pp 113
113qq 114
114rr 115
115ss 116
116tt
117
117uu 118
118vv 119
119ww120
120xx 121
121yy 122
122zz 123
123{{ 124
124| | 125
125}}
126
126~~ 127
127
tabella ASCII
tipo carattere in C

un solo carattere dell’alfabeto esteso
‘k’
l’alfabeto esteso contiene caratteri minuscoli, maiuscoli,
simboli speciali, etc…
‘K’ ‘a’ ‘A’

‘5’ ‘ ’ ‘%’
‘\’’ ‘\n’ ‘\\’
tipi scalari in C:
spazio di memoria (in byte) per la
rappresentazione dei valori
sizeof
int 4 byte
float 4 byte
double 8 byte
char 1 byte
pc classici, celle di 32 bit

il tipo logico in C non esiste
in sostituzione, si usa il tipo int, con la

convenzione che
falso 0
vero 1 qualunque valore

non nullo è
interpretato come
vero
variabili in C
una variabile C è caratterizzata dal

9 nome (identificatore)
9 valore associato
9 tipo
9 indirizzo della cella di memoria a partire dal
quale è memorizzato il valore
attenzione!
nome, tipo e indirizzo non possono essere modificati
variabili in C
il nome di una variabile è un identificatore C,

cioè una sequenza di lettere e cifre
non può iniziare con un numero
è formato al più da 31 lettere
lettere maiuscole e minuscole sono considerate
distinte
a ogni variabile è associata una cella di
memoria o più celle consecutive, a seconda
del suo tipo
l’indirizzo di una variabile è quello della prima
cella
variabili in C
metafora della scatola etichettata in uno scaffale
nome etichetta
valore contenuto della scatola
tipo contenuti (e capienza) possibili
della scatola
indirizzo posizione della scatola nello
scaffale
variabili in C
valore
scaffale
4
lato nome
Cella 742…
int
indirizzo
tipo
dichiarazione di variabili in C
<tipo> <variabili>;
Esempio:
Esempio:
int
int eta_anni;
eta_anni;
float
float raggio,
raggio, circonferenza;
circonferenza;
double
double lato;
lato;
char
char lettera_alfabeto,simbolo;
lettera_alfabeto,simbolo;
var
string ?
dichiarazione di variabili in C
<tipo> <variabili>;
Esempio:
Esempio:
unsigned
unsigned int
int eta;
eta;
long
long double
double velocita_luce;
velocita_luce;
short
short indice_riga;
indice_riga;
long
long fattoriale;
fattoriale;
int
int p;
p;
costanti in C
una costante è un’associazione non

modificabile che associa in modo
permanente un valore a un identificatore
const
const float
float pi_greco
pi_greco == 3.1415926F;
3.1415926F;
const
const double
double pipi == 3.14159265258416;
3.14159265258416;
const
const int
int nn == 100;
100;
assegnazione in C
<variabile> = <espressione>;
simbolo di
assegnazione
Esempio:
Esempio:
int
int eta_anni,p;
eta_anni,p;
eta_anni
eta_anni == 27;
27; float
float raggio;
raggio;
raggio double
double lato;
raggio == 59.4F;
59.4F; char
lato;
char lettera_alfabeto;
lettera_alfabeto;
lato
lato == 3.12;
3.12;
lettera_alfabeto
lettera_alfabeto == ‘g’;
‘g’;
pp == 1;
1;
assegnazione in C
var
var cognome:
cognome: string
string
cognome
cognome :=
:= “Rossi”
“Rossi”
char
char cognome;
cognome;
cognome
cognome == ‘Rossi’;
‘Rossi’;
cognome
cognome == “Rossi”;
“Rossi”;
le stringhe in C sono considerate valori strutturati

(verranno trattate nell’ambito delle strutture dati)
dichiarazione/inizializzazione in C
<tipo> <variabile> = <valore>;
Esempio:
Esempio:
int
int eta_anni
eta_anni == 27;
27;
float
float raggio
raggio == 59.4F;
59.4F;
double
double lato
lato == 3.12;
3.12;
char
char lettera_alfabeto
lettera_alfabeto == ‘g’;
‘g’;
int
int pp == 1;
1;
assegnazione in C
operatori
operatori aritmetici
aritmetici +,-,*,/,%
+,-,*,/,%
Esempio:
Esempio:
eta_anni 10
eta_anni == (27-7)/2;
(27-7)/2;
eta_anni
eta_anni == (28-7)/2;
(28-7)/2; 10
eta_anni
eta_anni == 27-7/2;
27-7/2; 24
raggio
raggio == 2.0F*15.4F;
2.0F*15.4F; 30.8
lato
lato == (3.0-0.1)/(3.-1E-1);
(3.0-0.1)/(3.-1E-1); 1.0
eta_anni
eta_anni == 27%5
27%5 2
operatori aritmetici in C
++ addizione
addizione (per
(per tutti
tutti ii tipi)
tipi)
-- sottrazione
sottrazione (per
(per tutti
tutti ii tipi)
tipi)
** moltiplicazione
moltiplicazione (per
(per tutti
tutti ii tipi)
tipi)
// divisione
divisione (float,
(float, double,
double, long double ))
long double
// divisione
divisione intera
intera (per
(per ii tipi
tipi interi)
interi)
%% modulo
modulo (per
(per ii tipi
tipi interi),
interi), resto
resto divisione
divisione intera
intera
la
la divisione
divisione intera
intera (tra
(tra un
un dividendo
dividendo di di tipo
tipo
intero
intero ee un
un divisore
divisore didi tipo
tipo intero)
intero) fornisce
fornisce
come
come risultato
risultato la
la parte
parte intera
intera del
del quoziente
quoziente
(28-7)/2 10 1/2 0 1.0/2.0 0.5
++ addizione
addizione (per
(per tutti
tutti ii tipi)
tipi)
-- sottrazione
sottrazione (per
(per tutti
tutti ii tipi)
tipi)
** moltiplicazione
moltiplicazione (per
(per tutti
tutti ii tipi)
tipi)
// divisione
divisione (float,
(float, double,
double, long double ))
long double
// divisione
divisione intera
intera (per
(per ii tipi
tipi interi)
interi)
%% modulo
modulo (per
(per ii tipi
tipi interi),
interi), resto
resto divisione
divisione intera
intera
ilil modulo
modulo (tra (tra un
un dividendo
dividendo di di tipo
tipo intero
intero ee
un
un divisore
divisore di di tipo
tipo intero)
intero) fornisce
fornisce come
come
risultato
risultato ilil resto
resto della
della divisione
divisione intera
intera
23%7 2 7%7 0 1%2 1 10%2 0 11%2 1
regole
regole di
di precedenza:
precedenza:
moltiplicazione,
moltiplicazione, divisione
divisione ee modulo
modulo vengono
vengono eseguite
eseguite
prima
prima didi addizione
addizione ee sottrazione
sottrazione
27-8/2 23
6.0/3.0-1.0 1.0
16%3+2 3
3 7 1
42 2
3*7-1/4*2+2
regole
regole di
di precedenza:
precedenza:
per
per superare
superare lele regole
regole di
di precedenza
precedenza èè necessario
necessario
usare
usare le
le parentesi
parentesi (tonde)
(tonde)
3 7 1
42 2
(3*7-1)/(4*2+2)
regole
regole di
di precedenza:
precedenza:
se
se gli
gli operatori
operatori hanno
hanno la
la stessa
stessa precedenza,
precedenza, allora
allora
l’espressione
l’espressione viene
viene valutata
valutata da
da sinistra
sinistra verso
verso destra
destra
59*100/60 98 valore int
59.0*100.0/60.0 98.33333333333333
valore double
59.0F*100.0F/60.0F 98.333333
valore float
programma
programma C C per
per ilil calcolo
calcolo della
della circonferenza
circonferenza di
di
un
un cerchio,
cerchio, fissato
fissato ilil suo
suo raggio
raggio
#include <stdio.h> commento

#include <stdio.h>
/*
/* calcolo
calcolo circonferenza
circonferenza di
di un
un cerchio
cerchio */
*/
void
void main
main ()
()
{{
const
const float
float pi_greco
pi_greco == 3.1415926F;
3.1415926F;
float
float raggio,
raggio, circon;
circon;
raggio
raggio == 2.0F;
2.0F;
circon
circon == 2.0F
2.0F ** pi_greco
pi_greco ** raggio;
raggio;
printf
printf (“circonferenza=%f\n”,circon);
(“circonferenza=%f\n”,circon);
}}
visualizzazione su schermo
circonferenza=12.566370
programma
programma C C per
per ilil calcolo
calcolo della
della circonferenza
circonferenza di
di
un
un cerchio,
cerchio, fissato
fissato ilil suo
suo raggio
raggio
#include
#include <stdio.h>
<stdio.h>
/*
/* calcolo
calcolo circonferenza
circonferenza didi un
un cerchio
cerchio */
*/
/*
/* versione
versione doppia
doppia precisione
precisione */*/
void
void main
main ()
()
{{ parte dichiarativa
const double pi_greco
const double pi_greco == 3.14159265258416;
3.14159265258416;
double
double raggio,
raggio, circon;
circon;
raggio
raggio == 2.0;
2.0; /*
/* il
il Raggio
Raggio e’e’ fissato
fissato */
*/
circon
circon == 2.0
2.0 ** pi_greco
pi_greco ** raggio;
raggio;
printf
printf (“circonferenza=%23.14lf\n”,circon);
(“circonferenza=%23.14lf\n”,circon);
}}
parte esecutiva
circonferenza=12.56637061033664
Titolo modulo : Puntatori in C [04-C]
Accesso ai valori delle variabili attraverso gli indirizzi di memoria

in C
Argomenti trattati:
9 indirizzi di memoria delle variabili C
9 puntatori in C
9 operatore di indirizzo in C
9 operatore di dereferenziazione in C
Prerequisiti richiesti: AP-03-03-C

metafora della scatola etichettata in uno scaffale
valore
scaffale
27
eta nome
Cella 742…
int
indirizzo
tipo
celle di memoria, indirizzi, valori memorizzati, variabili
int
int eta;
eta;
char
char lettera;
lettera;
memoria eta
indirizzo eta == 27;
27;
lettera
lettera == ‘k’;
‘k’;
01
rappr. int di 27 alla variabile eta viene
02 associata la cella di indirizzo 01
rappr. char di ‘k’ alla variabile lettera viene
associata la cella di indirizzo 02
03
la rappresentazione di 27 viene
memorizzata nella cella di
04 indirizzo 01
la rappresentazione di ‘k’
05 viene memorizzata nella cella
di indirizzo 02
celle di memoria, indirizzi, valori memorizzati, variabili
in
inCCèèpossibile
possibileconoscere
conoscere
memoria l’indirizzo
l’indirizzodella
dellacella
cella
indirizzo associata a una variabile
associata a una variabile
01
rappr. int di 27
02 operatore&&,,
operatore
rappr. char di ‘k’
operatore
operatoreindirizzo
indirizzodi
di
03
&eta
&eta
04 &lettera
&lettera
indicano:
indicano:
05 indirizzo
indirizzodella
dellavariabile
variabileeta
eta
indirizzodella
indirizzo dellavariabile
variabilelettera
lettera
in
in C
C èè possibile
possibile assegnare
assegnare l’indirizzo
l’indirizzo di
di una
una
variabile
variabile aa una
una variabile
variabile puntatore
puntatore
un
un puntatore
puntatore èè una
una variabile
variabile che
che contiene
contiene
l’indirizzo
l’indirizzo di
di un’altra
un’altra variabile
variabile
dichiarazione di puntatore
<tipo>
<tipo> *<puntatore>;
*<puntatore>;
ipunt è un puntatore a una variabile
int
int *ipunt;
*ipunt; di tipo int
c è un puntatore a una variabile di
float
float *c;
*c; tipo float
char r è un puntatore a una variabile di
char *r;
*r; tipo char
puntatori in C
int
int *ipunt
*ipunt
ipunt
ipunt èè un
un puntatore
puntatore aa una
una variabile
variabile di
di
tipo
tipo intero
intero
ipunt
ipunt contiene
contiene l’indirizzo
l’indirizzo di
di una
una variabile
variabile
di
di tipo
tipo intero
intero
ilil valore
valore puntato da ipunt
puntato da ipunt èè un
un dato
dato di
di
tipo
tipo intero
intero
puntatori in C
int
int *ipunt
*ipunt
operatore di
dereferenziazione
ipunt
ipunt èè la
la variabile
variabile puntatore
puntatore (il
(il suo
suo valore
valore
èè un
un indirizzo
indirizzo ))
*ipunt
*ipunt èè ilil valore
valore memorizzato
memorizzato nella
nella cella
cella
di quell’indirizzo
di quell’indirizzo
puntatori in C
assegnazione di un indirizzo a un puntatore
<puntatore>
<puntatore> == &<variabile>;
&<variabile>;
int
int eta;
eta;
int
int *ipunt;
*ipunt;
ipunt
ipunt == η
η
ilil valore
valore del
del puntatore ipunt èè l’indirizzo
puntatore ipunt l’indirizzo
della
della variabile
variabile eta
eta
ilil puntatore ipunt punta
puntatore ipunt punta alla
alla variabile
variabile eta
eta
puntatori in C
accesso al valore puntato da un puntatore
(accesso indiretto al valore di una variabile)
*<puntatore>
*<puntatore>
int
int eta;
eta;
int
int *ipunt;
*ipunt;
ipunt
ipunt == η
η
eta
eta == 27;
27;
ilil valore
valore della
della variabile eta può
variabile eta può essere
essere ottenuto
9
ottenuto
9 direttamente: eta
9
direttamente: eta
9 indirettamente:
indirettamente: *ipunt
*ipunt
puntatori in C
accesso al valore puntato da un puntatore
(accesso indiretto al valore di una variabile)
*<puntatore>
*<puntatore>
int
int eta;
eta;
int
int *ipunt;
*ipunt; accesso diretto
ipunt
ipunt == η
η a eta
eta
eta == 27;
27;
printf(“valore
printf(“valore di
di eta=%d/n”,eta);
eta=%d/n”,eta);
int
int eta;
eta;
int *ipunt; accesso indiretto
int *ipunt; a eta
ipunt = η
ipunt = η
eta
eta == 27;
27;
printf(“valore
printf(“valore di
di eta=%d/n”,*ipunt);
eta=%d/n”,*ipunt);
l’operatore
l’operatore di dereferenziazione **
di dereferenziazione
quando
quando viene
viene applicato
applicato aa un
un puntatore
puntatore
indica
indica ilil valore
valore puntato
puntato
alloca
alloca memoria per xx
memoria per
#include
#include <stdio.h>
<stdio.h>
void alloca
alloca memoria
memoria per
per
void main
main ()
()
{{ un
un indirizzo
indirizzo di
di un
un int
int
int x;
int x;
int
int *y;
*y; associa 55 aa xx
associa
xx == 5;
5;
yy == &x;
&x;
associa
associa l’indirizzo di xx
l’indirizzo di
printf
printf (“indirizzo
(“indirizzo di x=%d\n”,y);aa y
di x=%d\n”,y); y
printf
printf (“valore
(“valore di
di x=%d\n”,*y);
x=%d\n”,*y);
}}
l’operatore
quando
quando viene
viene applicato
applicato aa un
un puntatore
puntatore
indica
indica ilil valore
valore puntato
puntato
stampa
stampa ilil valore di yy,,
valore di
stampa
stampa ilil valore
#include
#include valore puntato
<stdio.h>
<stdio.h> da yy,, cioè,
puntato da cioè, l’indirizzo di xx
l’indirizzo di
void main
mainilil()
void cioè
cioè valore di xx
valore di
()
{{
int x;
int x;
int
int *y;
*y;
xx == 5;
5;
yy == &x;
&x;
printf
(“indirizzo di
di x=%d\n”,y);
x=%d\n”,y);
printf
printf (“valore
(“valore di
di x=%d\n”,*y);
x=%d\n”,*y);
}}
l’operatore
quando
quando viene
viene applicato
applicato aa un
un puntatore
puntatore
indica
indica ilil valore
valore puntato
puntato
#include
#include <stdio.h>
<stdio.h>
void
void main
main ()
()
{{
int
int x;
x;
int
int *y;
*y;
xx == 5;
5;
yy == &x;
&x;
printf
(“indirizzo di
di x=%d\n”,y);
x=%d\n”,y);
printf
printf (“valore
(“valore di
di x=%d\n”,*y);
x=%d\n”,*y);
}}
indirizzo di x=1245052
valore di x=5
_
cella di memoria di x
indirizzo 1245052
xx == 5;
5;
5 valore di x
cella di memoria di y yy == &x;

&x;
indirizzo 3306521
valore di y,
1245052 cioè indirizzo di x
l’operatore
l’operatoredi
dereferenziazione **
quando
quandoviene
vieneapplicato
applicatoaaun
un puntatore
puntatore indica
indica ilil valore
valorepuntato
puntato
#include
#include <stdio.h>
<stdio.h>
void
void main
main ()
()
{{ associa
associa 66 alla
alla variabile
variabile
int
int x;
x; puntata da yy,, cioè
puntata da cioè xx
int
int *y;
*y;
xx == 5;
5; incrementa
incrementa di di uno
uno ilil
yy == &x;
&x; valore
valore puntato
puntato da da yy,,
*y
*y == 6;
6; cioè ilil valore di xx
*y
cioè valore di
*y == (*y)+1;
(*y)+1;
printf
printf (“valore
(“valore di
di x=%d\n”,x);
x=%d\n”,x);
printf
printf (“valore
(“valore di
di x=%d\n”,*y);
x=%d\n”,*y);
}}
valore di x=7
valore di x=7
_
Esempio
/*
/* dichiarazione
dichiarazione di
di puntatore
puntatore aa intero
intero */
*/
int
int *ipunt
*ipunt;;
/*
/* dichiarazione
dichiarazione di
di variabili
variabili intere
intere */
*/
int
int aa == 5,
5, b;
b;
ipunt
ipunt == &a;
&a; /*
/* ipunt
ipunt punta
punta ad
ad aa */
*/
bb == *ipunt;
*ipunt; /*
/* assegnare
assegnare aa bb il
il
valore
valore della
della variabile
variabile puntata
puntata dada ipunt,
ipunt,
cioe’
cioe’ il
il valore
valore di
di a,
a, ovvero
ovvero 55 */
*/
*ipunt
*ipunt == 9;
9; /*
/* assegnare
assegnare 99 alla
alla
variabile
variabile puntata
puntata da
da ipunt,ovvero
ipunt,ovvero ad
ad aa
*/
*/
priorità degli operatori
indirizzo & e deferenziazione *
priorità più elevata degli operatori aritmetici
Esempio
int a=2,b=1,c,*p;
p = &b;
c = a+*p; c = a+(*p);
sono associativi a destra
c = *&b; c = *(&b);
priorità degli operatori
indirizzo & e deferenziazione *
* e & sono uno l’inverso dell’altro

¾ data la dichiarazione
int a; *&a è equivalente ad a
valore
¾ data la dichiarazione
int *ip; &*ip è equivalente a ip
indirizzo
&*ip non può essere usato a sinistra di =
Titolo modulo : Input / Output in C [05-C]
Operazioni elementari di lettura da tastiera e visualizzazione in C
Argomenti trattati:
9 operazione di visualizzazione in C: printf
9 codici di formato in C
9 operazione di lettura da tastiera in C: scanf
9 I/0 di caratteri in C

operazioni di input e output (I/O) in C
Esempio
libreria standard
#include
#include <stdio.h>
<stdio.h>
void
di I/O
void main()
main()
{{
printf(“Questo
printf(“Questo e’
e’ il
il mio
mio primo
primo programma
programma C\nƎ);
C\nƎ);
}}
istruzione di output
Questo e’ il mio primo programma C

Press any key to continueB
operazione di output in C
Esempio
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
int
int eta;
eta;
eta
eta == 27;
27;
printf(“valore
printf(“valore di
eta=%d/n”,eta);
}}
valore di eta=27
Press any key to continueB
operazione di output in C
printf(“Questo
printf(“Questo e’
e’ il
il mio
mio primo
primo programma
programma C\nƎ)
C\nƎ)
printf(“valore
printf(“valore di
eta=%d/n”,eta);
printf(<stringa
printf(<stringa di
di controllo>,<variabili>);
controllo>,<variabili>);
produce
produce la
la visualizzazione
visualizzazione dei
dei valori
valori delle
delle
<variabili>
<variabili>
la
la <stringa
<stringa di controllo> contiene
di controllo> contiene ii codici
codici di
di
formato per
formato per ii valori
valori delle
delle <variabili>
<variabili>
codici di formato in C
specificano le modalità di conversione tra la rappresentazione
interna di un valore e la rappresentazione (notazione) di
visualizzazione
%c carattere
%d int in notazione decimale
%f float o double in notazione [–]m.n
%e float o double in notazione [–]m.nE[+-]xx
%u int in notazione decimale senza segno

%s stringa
%o notazione ottale senza segno
%x notazione esadecimale senza segno
codici di formato in C
ilil numero
numero didi codici
codici di
di formato
formato nella
nella <stringa
<stringa didi
controllo> deve
controllo> deve essere
essere uguale
uguale alal numero
numero didi
variabili in
variabili <variabili>, cioè
in <variabili>, cioè deve
deve essere
essere uguale
uguale
al
al numero
numero didi valori
valori da
da visualizzare
visualizzare
la
la corrispondenza
corrispondenza tra
tra codice
codice di
di formato
formato nella
nella
<stringa
<stringa di controllo> ee relativa
di controllo> relativa variabile
variabile in
in
<variabili> èè per
<variabili> per posto
posto
la
la posizione
posizione nella
nella <stringa
<stringa di controllo> di
di controllo> di un
un
codice
codice di
di formato
formato indica
indica la
la posizione
posizione dove
dove viene
viene
visualizzato
visualizzato nella
nella riga
riga dello
dello schermo
schermo ilil corrispondente
corrispondente
valore
valore della
della <variabile>
<variabile>
Esempio
int miglia, km;
miglia = 1534;
km = 97;
printf("%d\n %d\n", miglia, km);
1534
97
B
B
float lun_maratona = 42.195F;

printf(“La maratona e’ lunga %f chilometri\n”,
lun_maratona);
La maratona e’ lunga 42.195000 chilometri
B
codici di formato in C forma generale
% n .m carattere di conversione
% carattere di inizio codice di formato
allineamento a sinistra
n ampiezza del campo di visualizzazione
. separatore
per una stringa massimo numero di caratteri da visualizzare
m per un int massimo numero di cifre da visualizzare
per un float massimo numero di cifre da visualizzare dopo il
punto frazionario
Esempio
char
char c1,c2;
c1,c2;
c1
c1 == ‘P’;
‘P’;
c2
c2 == ‘O’;
‘O’;
printf("%c
printf("%c %4c
%4c %-8c\n",
%-8c\n", c1,
c1, c2,
c2, c1);
c1);
P OP
_
Esempio
float
float x;
x;
xx == 54.32572F;
54.32572F;
printf("%10.3f\n",
printf("%10.3f\n", x);
x);
5 4 . 3 2 6
_
printf("%10.5f\n",
printf("%10.5f\n", x);
x);
5 4 . 3 2 5 7 2
_
Esempio
float
float xx == 12.345678F;
12.345678F;
printf("%16.7e\n",
printf("%16.7e\n", x);
x);
1 . 2 3 4 5 6 7 8 e + 0 0 1
_
double
double xx
xx == 12.34567890123456;
12.34567890123456;
printf("%22.15e\n%22.15f\n",
printf("%22.15e\n%22.15f\n", xx,xx);
xx,xx);
1.234567890123456e+001
12.345678901234560
B
operazione di input in C
Esempio
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
int
int x;x;
printf(“Inserire
printf(“Inserire un un intero:
intero: ”);
”);
scanf
scanf (“%d”,
(“%d”, &x);
&x);
printf
printf (“valore
(“valore inserito
inserito == %d\n”,
%d\n”, x);
x);
}}
istruzione di input
premere sul tasto

Inserire un intero:
intero:_21 Enter ( Invio)
valore inserito = 21
_
Esempio
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
int
int x,y;
x,y;
printf(“Inserire
printf(“Inserire due
due interi:
interi: ”);
”);
scanf
scanf (“%d%d”,
(“%d%d”, &x,&y);
&x,&y);
printf
printf (“primo
(“primo valore
valore inserito
inserito == %d\n
%d\n
secondo
secondo valore
valore inserito
inserito == %d\n”,x,y);
%d\n”,x,y);
}}
premere sul tasto
Inserire due interi:
interi:_321 654
primo valore inserito = 321
Enter ( Invio)
secondo valore inserito = 654
Esempio
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
int
int x,y;
x,y;
printf(“Inserire
printf(“Inserire due
due interi:
interi: ”);
”);
scanf
scanf (“%d%d”,
(“%d%d”, &x,&y);
&x,&y);
printf
printf (“primo
(“primo valore
valore inserito
inserito == %d\n”,x);
%d\n”,x);
printf
printf (“secondo
(“secondo valore
valore inserito
inserito == %d\n”,y);
%d\n”,y);
}}
Inserire due interi: 321 654

primo valore inserito = 321
secondo valore inserito = 654
scanf
scanf (“%d”,
(“%d”, &x);
&x);
scanf
scanf (“%d%d”,
(“%d%d”, &x,&y);
&x,&y);
scanf(<stringa
scanf(<stringa di
di controllo>,<indirizzi
controllo>,<indirizzi variabili>);
variabili>);
sospende
sospende l’esecuzione
l’esecuzione del
del programma
programma ee resta
resta in
in
attesa
attesa dell’immissione
dell’immissione da da tastiera dei valori
tastiera dei valori delle
delle
<variabili>
<variabili>
la
la <stringa
<stringa di controllo> contiene
di controllo> contiene ii codici
codici di
di
formato per
formato per ii valori
valori delle
delle <variabili>
<variabili>
Esempio
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
float x,
float x, y;
y;
printf("Inserire
printf("Inserire due due numeri
numeri reali:\n");
reali:\n");
scanf("%f%f",&x,&y);
printf(“
printf(“ xx =%f\n
=%f\n yy =%f\n",x,y);
=%f\n",x,y);
}}
Inserire due numeri reali :
1.0
_
2.45
x = 1.000000
y = 2.450000
_
Esempio
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
float x,
float x, y;
y;
printf("Inserire
printf("Inserire due due numeri
numeri reali:\n");
reali:\n");
printf(“
printf(“ xx =%f\n
=%f\n yy =%f\n",x,y);
=%f\n",x,y);
}}
54.3257
256.67543E2
x = 54.325699
y = 25667.542969
_
Esempio
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
float x,
float x, y;
y;
printf("Inserire
printf("Inserire due
due numeri
numeri reali:\n");
reali:\n");
printf(“
printf(“ xx =%20.3f\n
=%20.3f\n yy =%12.5f\n",x,y);
=%12.5f\n",x,y);
}}
54.3257
256.67543E2
x = 54.326
y = 25667.54297
_
Esempio
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
float x,
float x, y;
y;
printf("Inserire
printf("Inserire due
due numeri
numeri reali:\n");
reali:\n");
printf(“
printf(“ xx =%15.7e\n
=%15.7e\n yy =%15.7e\n",x,y);
=%15.7e\n",x,y);
}}
54.3257
256.67543E2
x = 5.4325699e+001
y = 2.5667543e+004
_
Esempio
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
int x;
int x;
char
char y;
y;
printf(“Inserire
printf(“Inserire un un intero
intero ee un
un carattere:
carattere: ”);
”);
scanf
scanf (“%d%c”,&x,&y);
(“%d%c”,&x,&y);
printf
printf (“x
(“x == %d
%d ee yy == %c
%c \n”,
\n”, x,
x, y);
y);
}}
Inserire un intero e un carattere: 21A

x = 21 e y = A
_
Esempio
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
char x,y;
char x,y;
printf(“Inserire
printf(“Inserire duedue caratteri:
caratteri: ”);
”);
scanf
scanf (“%c%c”,&x,&y);
(“%c%c”,&x,&y);
printf
printf (“x
(“x == %c
%c ee yy == %c
%c \n”,
\n”, x,
x, y);
y);
}}
Inserire due caratteri: GH

x =
e y = G ?
_
Esempio
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
char x,y;
char x,y;
printf(“Inserire
printf(“Inserire duedue caratteri:
caratteri: ”);
”);
fflush(stdin);
fflush(stdin);
scanf
scanf (“%c%c”,&x,&y);
(“%c%c”,&x,&y);
printf
printf (“x
(“x == %c
%c ee yy == %c
%c \n”,
\n”, x,
x, y);
y);
}}
Inserire due caratteri: GH

x = G e y = H
_
operazione di output di un singolo carattere
visualizzazione del valore di

putchar(c);
putchar(c);
tipo char della variabile c
Esempio
A
char cc == ƍAƍ;
char ƍAƍ; B
putchar(c);
putchar(c);
putchar("\n");
putchar("\n");
operazione di input di un singolo carattere
lettura da tastiera del valore

cc == getchar();
getchar(); di tipo char della variabile c
Esempio
B
char
char cc ;;
B_
cc == getchar();
getchar();
putchar(c);
putchar(c);
Esempio
calcolo e visualizzazione della circonferenza di un cerchio,
dato (lettura da tastiera) il suo raggio
#include
#include <stdio.h>
<stdio.h>
void
void main
main ()
()
{{
const
const float
float pi_greco
pi_greco == 3.1415926F;
3.1415926F;
float
float raggio,
raggio, circon;
circon;
scanf(“%f”,&raggio);
circon
circon == 2.F*pi_greco*raggio;
2.F*pi_greco*raggio;
printf
printf (“raggio=%f
(“raggio=%f circonferenza=%f\n”,
circonferenza=%f\n”,
raggio,circon);
raggio,circon);
}}
da tastiera
output del programma
Esempio
calcolo e visualizzazione dell’area di un rettangolo,
date (lettura da tastiera) la sua base e la sua altezza
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
int
int base,
base, altezza,
altezza, area;
area;
printf("Immettere
printf("Immettere la la base
base del
del rettangolo
rettangolo (int):
(int): ");
");
scanf("%d",
scanf("%d", &base);
&base);
printf(“\nImmettere
printf(“\nImmettere l’altezza
l’altezza del
del rettangolo
rettangolo (int):
(int): ");
");
scanf("%d",
scanf("%d", &altezza);
&altezza);
area
area == base
base ** altezza;
altezza;
printf(“\n
printf(“\n Area
Area del
del rettangolo
rettangolo (base=%d,altezza=%d):%d\n",
(base=%d,altezza=%d):%d\n",
base,
base, altezza,
altezza, area);
area);
}}
Immettere la base del rettangolo (int): 5

Immettere l’altezza del rettangolo (int): 3
Area del rettangolo (base= 5, altezza= 3):15
_
Titolo unità didattica: Costrutti di controllo [04]
Titolo modulo : Costrutti di selezione [01-T]
Caratteristiche generali dei costrutti di selezione
Argomenti trattati:
9 costrutto di selezione a due vie (if-then-else)
9 costrutto di selezione if-then
9 predicati
9 costrutti di selezione nidificati
9 costrutto di selezione a più vie

un costrutto di selezione denota la scelta
(selezione) tra due insiemi di istruzioni, in
dipendenza del valore di una condizione
(predicato)
un costrutto di selezione (a due vie) deve
9 una condizione (predicato) che può

specificare
assumere valore vero o valore falso
9 due insiemi di istruzioni

(tertium non datur)
denota la scelta tra due sequenze computazionali

if <predicato>
then
<corpo del then>
else
<corpo dell’else>
endif
<corpo del then> , <corpo dell’else>
sono due insiemi di istruzioni
costrutto
costrutto di
di selezione
selezione
if
if then
then else
else
if
if <predicato>
then
<sequenza 1>
else
<sequenza 2>
endif
v F
predicato
sequenza 1 sequenza 2
Esempio:
algoritmo per il calcolo del valore assoluto
(o modulo) di un numero x
il valore assoluto si indica in Matematica
con |x| ed è definito da:
x se x t 0
®
¯ x se x 0
x
Esempio:
(o modulo) di un numero x
dato di input: il numero x (variabile x)
dato di output: il numero |x|

(variabile val_assoluto)
dato di input: dal dispositivo di input
dato di output: sul dispositivo di output

Esempio:
di un numero
var
var x, x, val_assoluto:
val_assoluto: real
real
read xx
read
if
if xx >=
>= 00
then
then
val_assoluto
val_assoluto :=
:= xx
else
else
val_assoluto
val_assoluto :=
:= -x
-x
endif
endif
print
print val_assoluto
val_assoluto
var
val_assoluto: real
real
read
read xx
val_assoluto
val_assoluto := := xx
if
if xx << 00 versione altenativa
then
then
val_assoluto
val_assoluto :=
:= -x
-x
endif
endif
print val_assoluto
print val_assoluto
if <predicato>
then predicato
F
<corpo del then> v
endif sequenza
Esempio:
algoritmo per determinare se un numero x
appartiene a un intervallo [a,b]
d x d
a b
xx deve
deve essere
essere maggiore
maggiore oo uguale
uguale ad
ad aa
ee contemporaneamente
contemporaneamente
minore
minore oo uguale
uguale aa bb
Esempio:
dati di input: il numero x (variabile x), il

numero a (variabile a), il numero b
(variabile b)
dato di output: true oppure false
(variabile appartiene)
dati di input: dal dispositivo di input
dato di output: sul dispositivo di output

Esempio:
var
var x,a,b:
x,a,b: real
real
var
var appartiene:
appartiene: logical
logical
read x,a,b
read x,a,b
if
if xx >=
>= aa and
and xx <=
<= bb predicato
then
then
appartiene
appartiene := := true
true
else
else
appartiene
appartiene := := false
false
endif
endif
print x,a,b,appartiene
costrutti di selezione nidificati
if <predicato 1>
then
<corpo del then 1>
else if <predicato 2>
then
<corpo del then 2>
else
<corpo dell’else 2>
endif
endif
selezione a tre vie
1 se
°
Esempio: calcolare il x >0
® 0 se
numero a :
° 1 se
a x 0
¯ x0
if
if x>0
x>0
then
then
aa :=
:= 11
else
else if
if x=0
x=0 then
then
aa :=
:= 00
else
else
aa :=
:= -1
-1
endif
endif
endif
endif
if
if x>0
x>0 then
then
aa :=
:= 11
else
else if
if x=0
x=0 then
then
aa :=
:= 00
else
else
aa :=
:= -1
-1
endif
endif
endif
endif
sequenze di operazioni
se il valore di x è >0 : x>0, a:=1
se il valore di x è =0 : x>0, x=0, a:=0
se il valore di x è <0 : x>0, x=0, a:=-1

Esempio:
algoritmo per determinare se un numero
intero x è positivo, nullo o negativo
dato di input: il numero x (variabile x)
dato di output: nessuno: si visualizza (in

alternativa): “il numero è positivo”,
“il numero è nullo”, “il numero è negativo”
output: sul dispositivo di output

Esempio:
algoritmo per determinare se un numero
intero x è positivo, nullo o negativo
var
var x: x: integer
integer
read xx
read
if
if xx >> 00
then
then
print “il
print “il numero
numero èè positivo”
positivo”
else
else if
if xx == 00
then
then
print
print “il
“il numero
numero èè nullo”
nullo”
else
else
print
print “il
“il numero
numero èè negativo”
negativo”
endif
endif
endif
endif
costrutti di selezione a n vie
switch <variabile>
case <val_1> : <corpo del caso 1>
..
case <val_n> : <corpo del caso n>
default: <corpo del caso default>
endswitch
se <variabile> ha valore <val_1> si eseguono (solo)
le istruzioni del <corpo del caso 1>
se <variabile> ha valore <val_2> si eseguono (solo)
le istruzioni del <corpo del caso 2>
costrutti di selezione a n vie
switch <variabile>
..
case <val_n> : <corpo del caso n>
default: <corpo del caso default>
endswitch
se <variabile> ha valore <val_n> si eseguono (solo)
le istruzioni del <corpo del caso n>
se <variabile> ha un qualsiasi altro valore si
eseguono le istruzioni del <corpo del default>
Esempio:
algoritmo per determinare se una città x (tra
quattro città prefissate) è quella desiderata
dato di input: la città x (variabile x)

alternativa): “risposta esatta”,
un messaggio 1, un messaggio 2, un
messaggio 3, un messaggio di errore

var
var x:
x: string
string
print “dire
print “dire quale
quale tra
tra Napoli,Caserta,Avellino,
Napoli,Caserta,Avellino,
Benevento
Benevento èè più
più aa nord”
nord”
read
read xx
switch
switch xx
case
case “Napoli”
“Napoli” :: print
print “Napoli
“Napoli èè la
la più
più aa sud
sud
delle
delle 4”
4”
case
case “Caserta”
“Caserta” :: print
print “Caserta
“Caserta èè piùpiù aa sud
sud
solo
solo di
di Benevento”
Benevento”
case
case “Avellino”
“Avellino” :: print
print “Avellino
“Avellino èè più
più aa nord
nord
solo
solo di
di Napoli”
Napoli”
case
case “Benevento”
“Benevento” :: print
print “risposta
“risposta esatta”
esatta”
default:
default: print
print “errore
“errore nell’inserimento
nell’inserimento della
della
citta”
citta”
endswitch
endswitch
predicati
una
una sentenza
sentenza èè una
una affermazione
affermazione che
che può
può
essere
essere vera
vera oo falsa
falsa
sentenza A: Napoli è il capoluogo della Campania v
sentenza B: 7 > 10 f
sentenza C: la Terra è più grande di Urano f
un
un predicato
predicato èè una
una struttura
struttura logica
logica che
che si
si

ottiene
ottiene connettendo
connettendo sentenze
sentenze

¾ QHJD]LRQH not

¾ FRQJLXQ]LRQH and
¾ GLVJLXQ]LRQH or
(VHPSL predicati
predicato A:
Napoli non è il capoluogo falso
predicato B: 7 d 10
della Campania
vero
predicato A B: Napoli è il capoluogo
B C: 7 > 10 or la Terra è più

della Campania and 7>10 falso
predicato
falso
B C: 7d10 and la Terra non

grande di Urano
predicato vero
è più grande di Urano
predicati
FRQYHQ]LRQHSHURSHUD]LRQLIXQ]LRQLORJLFKH
WDEHOODGLYHULW¢
p p p q p q p q p q
v f v v v v v v
f v v f f v f v
not f v f f v v
f f f f f f
and or
predicati
FRQYHQ]LRQHSHURSHUD]LRQLIXQ]LRQLORJLFKH
WDEHOODGLYHULW¢
p q p q p q
v v f v v f v v f
v f f v f v v f v
f v f f v v f v v
f f v f f v f f f
nor nand xor
predicati
p q
(VHPSL UHOD]LRQHGL'H0RUJDQ
pq
x t a x d b
i predicati
x a x ! b
sono equivalenti
sono
sono veri
veri se
se ee solo
solo se
se xx appartiene
appartiene
all’intervallo
all’intervallo [a,b]
[a,b]
[ ]
Titolo modulo : Costrutti di ripetizione [02-T]
Caratteristiche generali dei costrutti di ripetizione
Argomenti trattati:
9 costrutto for
9 costrutto repeat-until
9 costrutto while
9 costrutti di ripetizione nidificati

un costrutto di ripetizione denota la ripetizione
(iterazione) di un insieme di istruzioni
9 costrutti in cui il numero di ripetizioni

i costrutti di ripetizione si distinguono in
9 costrutti in cui il numero di ripetizioni

(iterazioni) è noto a priori
(iterazioni) non è noto, ma dipende da

una condizione (predicato)
le istruzioni che compaiono in un costrutto di

ripetizione sono dette corpo del ciclo
costrutti in cui il numero di ripetizioni è noto a
priori
costrutto di ripetizione for
costrutti in cui il numero di ripetizioni non è

noto, ma dipende da una condizione
costrutti dipuò
una convenzione ripetizione
essere:
while , repeat-until
<variabili>: ,….
costrutto
di ripetizione for
(o ciclo for
(o ciclo for))
consente di denotare la ripetizione N volte
di una sequenza di operazioni

for i=1,N do
<corpo del ciclo>
endfor
range della
variabile di ciclo variabile di ciclo
costrutto
di ripetizione for
(o ciclo for
(o ciclo for))
for i=1,N do
<corpo del ciclo>
endfor
i=1,N
sequenza
Esempio:
visualizzare in output i numeri interi da 1 a 10
var
var i:
i: integer
integer
for
for ii == 1,10
1,10 do
do
print
print ii
endfor
endfor
output:
output:
11 22 .........
......... 99 10
10
forma generale

for <variabile>=<espr_1>,<espr_2>
step=<espr_3> do
<corpo del ciclo>
endfor
<espr_1> , <espr_2>, < espr_3>

sono espressioni a valori interi
Esempio:
visualizzare in output i numeri interi pari tra
-8 e 10
var
var i:
i: integer
integer
for
for ii == -8,10,step=2
-8,10,step=2 do
do
print
print ii
endfor
endfor
output:
output:
-8
-8 -6
-6 .........
......... 88 10
10
costrutto
costrutto di
di ripetizione
ripetizione (o
(o ciclo)
ciclo)
repeat
repeat until
until
denota la ripetizione in dipendenza del
valore di un predicato (con test finale)

repeat
<corpo del ciclo>
until <predicato>
predicato di uscita dal ciclo

costrutto
costrutto di
di ripetizione
ripetizione (o
(o ciclo)
ciclo)
repeat
repeat until
until
repeat
<corpo del ciclo>
until <predicato>
ilil corpo
corpo del
del ciclo
ciclo viene
viene eseguito
eseguito sese ilil
valore del <<predicato
valore del predicato>> èè falso;
falso;
se
se ilil valore del <<predicato
valore del predicato>> èè vero
vero la
la
ripetizione
ripetizione termina
termina
costrutto
costrutto di
di ripetizione
ripetizione (o
(o ciclo)
ciclo)
repeat
repeat until
until
repeat
<corpo del ciclo>
until <predicato>
sequenza
predicato
F
v
Esempio: visualizzazione interi da 1 a 10
var
var i: i: integer
integer
ii :=
:= 00
repeat
repeat
ii :=
:= i+1
i+1
print
print ii
until
until ii == 10
10
output:
output:
11 22 .........
......... 99 10
10
var
var i:i: integer
integer
ii :=
:= 11
repeat
repeat Versione alternativa
print
print ii
ii :=
:= i+1
i+1
until
until ii >> 10
10
output:
output:
11 22 .........
......... 99 10
10
osservazione importante
in generale, il valore del predicato deve cambiare
durante l’esecuzione del ciclo, per evitare un loop
(sequenza infinita di operazioni)
almeno una delle variabili che compaiono nel

predicato di uscita deve avere il proprio valore
modificato da una istruzione del corpo del ciclo
var
var i:i: integer
integer var
var i:i: integer
integer
ii :=
:= 11 ii :=
:= 00
repeat
repeat repeat
repeat
print
print ii ii :=
:= i+1
i+1
ii :=
:= i+1
i+1 print
print ii
until
until ii >> 10
10 until
until ii == 1010
costrutto
costrutto di
di ripetizione
ripetizione (o
(o ciclo)
ciclo)
while
while
denota la ripetizione in dipendenza del
valore di un predicato (con test iniziale)

while <predicato>
<corpo del ciclo>
endwhile
predicato di uscita dal ciclo

costrutto
costrutto di
di ripetizione
ripetizione (o
(o ciclo)
ciclo)
while
while
while <predicato>
<corpo del ciclo>
endwhile
ilil corpo
corpo del
del ciclo
ciclo viene
viene eseguito
eseguito se
se ilil
valore del <<predicato
valore del predicato>> èè vero;
vero;
se
se ilil valore del <<predicato
valore del predicato>> èè falso
falso la
la
ripetizione
ripetizione termina
termina
costrutto
costrutto di
di ripetizione
ripetizione (o
(o ciclo)
ciclo)
while
while
while <predicato>
<corpo del ciclo>
endwhile
F
predicato
sequenza
var
var i: i: integer
integer
ii :=
:= 00
while
while ii << 10
10
ii :=
:= i+1
i+1
print
print ii
endwhile
endwhile
output:
output:
11 22 .........
......... 99 10
10
var
var i:i: integer
integer
ii :=
:= 11 Versione alternativa
while
while ii <=<= 10
10
print
print ii
ii :=
:= i+1
i+1
endwhile
endwhile
output:
output:
11 22 .........
......... 99 10
10
osservazione importante
in generale, il valore del predicato deve cambiare
durante l’esecuzione del ciclo, per evitare un loop
(sequenza infinita di operazioni)
almeno una delle variabili che compaiono nel
predicato di uscita deve avere il proprio valore
modificato da una istruzione del corpo del ciclo
9 il corpo di un ciclo while può non essere

eseguito (ciò accede se il predicato di uscita
ha valore falso);
9 il corpo di un ciclo repeat until è sempre
eseguito almeno una volta
Esempio:
algoritmo di controllo di correttezza della
risposta (inserita da tastiera) a una domanda
dato di input: la risposta (variabile risposta)

alternativa): “risposta corretta”,
“risposta sbagliata, ripetere”
dati di input: dal dispositivo di input

var
var risposta:
risposta: integer
integer
const
const risposta_corretta
risposta_corretta == 10 10 :: integer
integer
repeat
repeat
print “qual
print “qual èè ilil logaritmo
logaritmo in
in base
base 22 di
di 1024?
1024? ””
read
read risposta
risposta
if
if risposta
risposta == risposta_corretta
risposta_corretta
then
then
print
print “risposta
“risposta corretta”
corretta”
else
else
print ““ risposta
print risposta sbagliata,
sbagliata, ripetere”
ripetere”
endif
endif
until risposta=risposta_corretta
until risposta=risposta_corretta
un ciclo può trovarsi all'interno di un altro ciclo
(cicli innestati)
…………
…………
for
for i=1,2
i=1,2 do
do ciclo esterno
for
for j=1,3
j=1,3 do do ciclo interno
print ‘(’,i,‘
print ‘(’,i,‘ ’,j,‘)’
’,j,‘)’
endfor
endfor
endfor
endfor
…………
…………
output:
output:
(1
(1 1)(1
1)(1 2)(1
2)(1 3)(2
3)(2 1)(2
1)(2 2)(2
2)(2 3)
3)
inversione dei cicli
…………
…………
for
for j=1,3
j=1,3 dodo ciclo esterno
for
for i=1,2
i=1,2 do
do
print
print ‘(’,i,‘
‘(’,i,‘ ’,j,‘)’
’,j,‘)’
endfor
endfor
endfor
endfor
…………
…………
output:
output:
(1
(1 1)(2
1)(2 1)(1
1)(1 2)(2
2)(2 2)(1
2)(1 3)(2
3)(2 3)
3)
Titolo modulo : Costrutti di selezione in C [03-C]
Analisi dei vari costrutti di selezione del C
Argomenti trattati:
9 costrutto di selezione if
9 operatori logici in C
9 costrutti di selezione nidificati if else if
9 costrutto di selezione switch
Prerequisiti richiesti: AP-03-03-C, AP-04-01-T

costrutto di selezione if in C
if <predicato>
v F
then predicato
predicato
<corpo del then>

else corpo del 1
sequenza then corpo dell’else
sequenza 2
<corpo dell’else>
endif
if
if (<predicato>)
(<predicato>)
{{
<corpo
<corpo del
del then>
then> blocco
}}
else
else
{{
<corpo
<corpo dell’else>
dell’else> blocco
}}
costrutto di selezione if in C
if <predicato>
then predicato
predicato
F
<corpo del then>
v
endif
corpo del then
sequenza
if
if (<predicato>)
(<predicato>)
{{
<corpo
<corpo del
del then>
then> blocco
}}
un blocco in C è una sequenza di istruzioni all’interno di
una coppia di parentesi graffe
operatori logici in C
operatori logici relazionali
> maggiore
>= maggiore o uguale
< minore
<= minore o uguale
9 hanno priorità inferiore a quella degli

operatori logici di eguaglianza
== uguale
!= diverso
9 hanno priorità inferiore a quella degli

operatori relazionali
operatori logici di connessione
! negazione (not)
&& congiunzione (and)
|| disgiunzione (or)
9 hanno priorità inferiore a quella di tutti

gli altri operatori logici
espressioni, il cui valore è un valore di verità,
predicati in C che coinvolgono:
operatori logici relazionali
operatori logici di eguaglianza
operatori logici di connessione
9 i predicati vengono valutati da sinistra a destra
il valore di un predicato è
0 (falso) oppure 1 (vero)
Esempio:
programma C per il calcolo del valore assoluto di un numero
#include
#include <stdio.h>
<stdio.h> var
val_assoluto: real
real
void
void main()
main() read
read xx
{{ ifif xx >=
>= 00
float then
float x,val_assoluto;
x,val_assoluto; then
printf val_assoluto
val_assoluto :=
:= xx
printf (“inserire
(“inserire un
un numero
numero ”);
”); else
scanf(“%f”,&x);
scanf(“%f”,&x); else
val_assoluto
val_assoluto :=
:= -x
-x
if
if (x
(x >=
>= 0.0)
0.0) endif
endif
{{ print
print val_assoluto
val_assoluto
val_assoluto
val_assoluto == x;x;
}} i blocchi possono essere
else
else
{{
omessi nel caso in cui
val_assoluto <corpo> sia una unica
val_assoluto == -x;
-x;
}} istruzione
printf(“\n
printf(“\n valore
valore assoluto
assoluto di
di %f
%f
== %f”,x,val_assoluto);
%f”,x,val_assoluto);
}}
Esempio:
programma C per il calcolo del valore assoluto di un numero
#include
#include <stdio.h>
<stdio.h> var
val_assoluto: real
real
void
void main()
main() read
read xx
{{ ifif xx >=
>= 00
float then
float x,val_assoluto;
x,val_assoluto; then
printf val_assoluto
val_assoluto :=
:= xx
printf (“inserire
(“inserire un
un numero
numero ”);
”); else
scanf(“%f”,&x);
scanf(“%f”,&x); else
val_assoluto
val_assoluto :=
:= -x
-x
if
if (x
(x >=
>= 0.0)
0.0) endif
endif
val_assoluto
val_assoluto == x;x; print
print val_assoluto
val_assoluto
else
else
val_assoluto
val_assoluto == -x;
-x; i blocchi possono essere
printf(“\n
printf(“\n valore
valore assoluto
assoluto di
di %f
%f
== %f\n”,x,val_assoluto);
omessi nel caso in cui
%f\n”,x,val_assoluto); <corpo> sia una unica
}}
istruzione
inserire un numero -12.1
valore assoluto di -12.1= 12.1
-
Esempio:
programma C per determinare se un numero x appartiene a
un intervallo [a,b]
#include
#include <stdio.h>
<stdio.h> var
var x,a,b:
x,a,b: real
real
void
void main()
main() var appartiene:
var appartiene: logical
logical
{{ read
read x,a,b
x,a,b
float ifif xx >=
>= aa and
and xx <=
<= bb
float x,a,b;
x,a,b; then
int then
int appartiene;
appartiene; appartiene
printf(“ appartiene := := true
true
printf(“ inserire
inserire x,x, a,
a, bb \n”);
\n”); else
else
scanf(“%f
scanf(“%f %f %f %f”,&x,&a,&b);
%f”,&x,&a,&b); appartiene
appartiene := := false
false
if
if (x
(x >=
>= aa &&
&& xx <=
<= b)
b) endif
endif
appartiene
appartiene == 1;1; print x,a,b,appartiene
else
else
appartiene
appartiene == 0;0;
printf(“\n%d\n
printf(“\n%d\n ”,appartiene);
”,appartiene);
}}
inserire x, a, b
-1.0 -3.1 0.1
1
Esempio:
programma C per determinare se un numero x appartiene a
un intervallo [a,b]
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
float
float x,a,b;
x,a,b;
printf(“
printf(“ inserire
inserire x,x, a,
a, bb \n”);
\n”);
scanf(“%f
scanf(“%f %f%f %f”,&x,&a,&b);
%f”,&x,&a,&b);
if
if (x
(x >=
>= aa &&
&& xx <=
<= b)
b)
printf(“\n
printf(“\n ilil numero
numero %f%f appartiene
appartiene aa [%f,%f]”,
[%f,%f]”,
x,a,b);
x,a,b);
else
else
printf(“\n
printf(“\n ilil numero
numero %f%f non
non appartiene
appartiene aa [%f,%f]”,
[%f,%f]”,
x,a,b);
x,a,b);
}}
inserire x, a, b
-1.0 -3.1 0.1
il numero -1.0 appartiene a [-3.1,0.1]_
costrutto di selezione nidificato in C
if
if (<predicato1>)
(<predicato1>)
{{
<corpo
<corpo del
del then
then 1>
1>
}}
else
else ifif (<predicato2>)
(<predicato2>)
{{
<corpo
<corpo del
del then
then 2>
2>
}}
else
else
{{
<corpo
<corpo dell’else
dell’else 2>
2>
}}
var
var x: x: integer
integer
Esempio: read
read xx
programma C per determinare ifif xx >> 00
se un numero intero è positivo, then
then
print “il
print “il numero
numero èè positivo”
positivo”
nullo o negativo else
else ifif xx == 00
then
then
#include <stdio.h>
#include <stdio.h> print
print “il
“il numero
numero èè nullo”
nullo”
void
void main()
main() else
else
{{ print
print “il
“il numero
numero èè negativo”
negativo”
int x;
int x; endif
endif
printf(“
printf(“ inserire
inserire un
un numero\n”);
endif
numero\n”); endif
scanf(“%d”,&x);
scanf(“%d”,&x);
if
if (x
(x >> 0)
0)
printf(“%d
printf(“%d e’e’ positivo”,x);
positivo”,x);
else
else if
if (x
(x ==
== 0)
0)
printf(“%d
printf(“%d e’
e’ nullo”,x);
nullo”,x);
else
else
printf(“%d
printf(“%d e’
e’ negativo”,x);
negativo”,x);
}}
inserire un numero
-14
-14 e’ negativo_
costrutto di selezione multipla in C
switch
switch (<espressione>)
(<espressione>) {{
case
case <valore_1>:
<valore_1>: <sequenza_1>;
<sequenza_1>; break;
break;
case
case <valore_2>:
<valore_2>: <sequenza_2>;
<sequenza_2>; break;
break;
...
...
case
case <valore_n>:
<valore_n>: <sequenza_n>;
<sequenza_n>; break;
break;
default
default :: <sequenza_d>;
<sequenza_d>;
9
9sisivaluta
}}
9
9sisiva
<espressione> (deve
valuta<espressione> (deveessere
essereun int ooun
unint un char)
char)
vaall’etichetta case aacui
all’etichetta case cuièèassociata
associatala
la costante int oo
costante int
char(<valore>)
char (<valore>)che
checoincide
coincidecon
conililvalore
valoredidi
<espressione> eesisiesegue
<espressione> eseguelalarelativa
relativa <sequenza>
<sequenza>
9
9se
di
diistruzioni
istruzioni
senon
nonc’è c’ènessuna
nessunacostante
costanteuguale
ugualeaatale
talevalore,
valore,sisi va
va
9
9quando
all’etichetta
all’etichetta default
default
quandosisiraggiunge
raggiungeuna
unaistruzione break (o
istruzione break (ola
lafine),
fine),
l’istruzione switch termina
l’istruzione switch termina
Esempio:
programma C per determinare se una città (tra quattro città
prefissate) è quella desiderata
var
var x:
x: string
string
print “dire
print “dire quale
quale tra
tra Napoli,Caserta,Avellino,Benevento
Napoli,Caserta,Avellino,Benevento èè più più aa nord”
nord”
read
read xx
switch
switch xx
case
case “Napoli”
“Napoli” :: print
print “Napoli
“Napoli èè lala più
più aa sud
sud delle
delle 4”
4”
case
case “Caserta”
“Caserta” :: print
print “Caserta
“Caserta èè piùpiù aa sud
sud solo
solo di
di Benevento”
Benevento”
case
case “Avellino”
“Avellino” :: print
print “Avellino
“Avellino èè più
più aa nord
nord solo
solo di
di Napoli”
Napoli”
case
case “Benevento”
“Benevento” :: print
print “risposta
“risposta esatta”
esatta”
default:
default: print
print “errore
“errore nell’inserimento
nell’inserimento della
della città”
città”
endswitch
endswitch
Esempio:
#include
#include <stdio.h>
<stdio.h>
void main()
void main()
{{
char x;
char x;
printf(“dire
printf(“dire quale
quale tra
tra Napoli,
Napoli, Caserta,
Caserta, Avellino,
Avellino, Benevento
Benevento e’
e’
piu’
piu’ aa nord
nord (inserire
(inserire solo
solo l’iniziale
l’iniziale della
della citta’)\n”);
citta’)\n”);
scanf(“%c”,&x);
scanf(“%c”,&x);
switch
switch (x)
(x) {{
case
case ‘N’
‘N’ :: printf(“Napoli
printf(“Napoli e’ e’ la
la piu’
piu’ aa sud
sud delle
delle 4\n”);break;
4\n”);break;
case
case ‘C’
‘C’ :: printf(“Caserta
printf(“Caserta e’ e’ piu’
piu’ aa sud
sud solo
solo di
di Benevento\n”
Benevento\n”
); break;
); break;
case
case ‘A’
‘A’ :: printf(“Avellino
printf(“Avellino e’ e’ piu’
piu’ aa nord
nord solo
solo di
di
Napoli\n”
Napoli\n” );
); break;
break;
case
case ‘B’
‘B’ :: printf(“
printf(“ risposta
risposta esatta\n”
esatta\n” ); ); break;
break;
default:
default: printf(“
printf(“ errore
errore nell’inserimento\n”
nell’inserimento\n” ); );
}}
}}
Esempio:
#include
#include <stdio.h>
<stdio.h>
void main()
void main()
{{
int x;
int x;
printf(“dire
printf(“dire quale
quale tra
tra Napoli,
Napoli, Caserta,
Caserta, Avellino,
Avellino, Benevento
Benevento e’
e’
piu’
piu’ aa nord
nord \n”);
\n”);
printf(“Inserire:\n
printf(“Inserire:\n 11 per per Napoli\n
Napoli\n 22 per
per Caserta\n
Caserta\n 33 per
per
Avellino\n
Avellino\n 44 perper Benevento\n”);
Benevento\n”);
scanf(“%d”,&x);
scanf(“%d”,&x);
switch
switch (x)
(x) {{
case 11 :: printf(“Napoli
case printf(“Napoli e’ e’ la
la piu’
piu’ aa sud
sud delle
delle 4\n”);
4\n”); break;
break;
case
case 22 :: printf(“Caserta
printf(“Caserta e’ e’ piu’
piu’ aa sud
sud solo
solo di
di Benevento\n”
Benevento\n”
);
); break;
break;
case
case 33 :: printf(“Avellino
printf(“Avellino e’ e’ piu’
piu’ aa nord
nord solo
solo di
di Napoli\n”
Napoli\n” );
);
break;
break;
case
case 44 :: printf(“
printf(“ risposta
risposta esatta\n”
esatta\n” ); ); break;
break;
default:
default: printf(“
printf(“ errore
errore nell’inserimento\n”
nell’inserimento\n” ); );
}}
}}
Titolo modulo : Costrutti di ripetizione in C [04-C]
Analisi dei costrutti di ripetizione in C
Argomenti trattati:
9 costrutto for
9 costrutto while
9 costrutto do-while
9 costrutti di ripetizione nidificati

costrutti di ripetizione in C
for
for i=a,b,step=c
i=a,b,step=c do
do
<corpo
<corpo del
del ciclo>
ciclo>
endfor
endfor
for
for (i=a;
(i=a; i<=b;
i<=b; i=i+c)
i=i+c)
{{
<corpo
<corpo del
del ciclo>
ciclo> blocco
}}
while
while <predicato>
<predicato>
<corpo
<corpo del
del ciclo>
ciclo>
endwhile
endwhile
while
while (<predicato>)
(<predicato>)
{{
<corpo
<corpo del
del ciclo>
ciclo> blocco
}}
repeat
repeat
<corpo
<corpo del
del ciclo>
ciclo>
until
until <predicato>
<predicato>
predicato>
do
do
{{
<corpo
<corpo del
del ciclo>
ciclo> blocco
}}
while
while (<predicato>);
(<predicato>);
repeat
repeat do
do
<corpo
<corpo del
del ciclo>
ciclo> {{
until
until <predicato>
<predicato>
predicato> <corpo
<corpo del
del ciclo>
ciclo>
}}
while( <!predicato>
while( <predicato>);
<predicato>);
Esempio
do
do
repeat
repeat {{
read
read numero
numero scanf(“%d”,&numero);
scanf(“%d”,&numero);
until
until numero
numero == 00 }}
while
while (numero
(numero !=
!= 0);
0);
il costrutto for in C è equivalente al while
for
for (i=a;i<=b;i=i+c)
(i=a;i<=b;i=i+c)
{{
<corpo
<corpo del
del ciclo>
ciclo>
}}
sono equivalenti
i=a;
i=a;
while
while (i
(i <=
<= b)
b)
{{
<corpo
<corpo del
del ciclo>
ciclo>
i=i+c;
i=i+c;
}}
Esempio:
visualizzazione dei numeri interi da 1 a 10
#include
#include <stdio.h>
<stdio.h> #include
#include <stdio.h>
<stdio.h>
void
void main()
main() void
void main()
main() operatore di
{{ {{ incremento
int
int i;
i; int
int i;
i;
for(i=1;
for(i=1; i<=10
i<=10 ;; i=i+1)
i=i+1) for(i=1;
for(i=1; i<=10
i<=10 ;; i++)
i++)
{{ {{
printf(“%3d”,i);
printf(“%3d”,i); printf(“%3d”,i);
}} }}
}} }}
1 2 3 4 5 6 7 8 9 10_
Esempio:
i blocchi possono essere omessi

nel caso in cui <corpo> sia
#include
#include <stdio.h>
<stdio.h>
una unica istruzione void
void main()
main()
#include
#include <stdio.h>
<stdio.h> {{
void
void main()
main() int
int i;
i;
{{ for(i=1;
for(i=1; i<=10
i<=10 ;; i++)
i++)
int
int i;
i; {{
for(i=1;
for(i=1; i<=10
i<=10 ;; i++)
i++) printf(“%3d”,i);
printf(“%3d”,i); }}
}} }}
1 2 3 4 5 6 7 8 9 10_
Esempio:
visualizzazione dei numeri pari da -8 a 10
#include
#include <stdio.h>
<stdio.h>
/*
/* visualizza
visualizza ii numeri
numeri pari
pari da
da -8
-8 aa 10
10 */
*/
void
void main()
main()
{{
int i;
int i;
for(i=-8;
for(i=-8; i<=10
i<=10 ;; i=i+2)
i=i+2)
}}
-8 -6 -4 -2 0 2 4 6 8 10_
Esempio:
#include
#include <stdio.h>
<stdio.h> #include
#include <stdio.h>
<stdio.h>
void
void main()
main() void
void main()
main()
{{ {{
int
int i=1;
i=1; int
int i=1;
i=1;
while(i<=10)
while(i<=10) {{ do{
do{
printf(“%3d”,i); printf(“%3d”,i);
i++;
i++; i++;
i++;
}} }} while(i<=10);
while(i<=10);
}} }}
1 2 3 4 5 6 7 8 9 10_
operatori incremento e decremento in C
++ operatore di incremento si applicano solo

alle variabili
-- operatore di decremento
i = i+1; ++i; i++; incremento
i = i-1; --i; i--; decremento
Attenzione: ++i i++ --i i-– sono espressioni

(hanno un valore):
int
int i=1;
i=1; int
int i=1;
i=1;
printf(“%d\n”,i++);
printf(“%d\n”,i++); printf(“%d\n”,++i);
printf(“%d\n”,++i);
printf(“%d\n”,i);
printf(“%d\n”,i); printf(“%d\n”,i);
printf(“%d\n”,i);
1 2
2_ 2_
Esempio:
visualizzazione dei primi 10 numeri pari
osservazione
primo numero pari: 2 , (2*1)
secondo numero pari: 4 , (2*2)
i-simo numero pari 2*i
terzo numero pari: 6 , (2*3)
…
#include
#include <stdio.h>
<stdio.h>
/*
/* visualizza
visualizza ii primi
primi 10
10 numeri
numeri pari
pari */
*/
void
void main()
main()
{{
int
int i;
i;
for(i=1;
for(i=1; i<=10
i<=10 ;; i++)
i++)
printf(“%2d-simo
printf(“%2d-simo numero
numero pari:%d\n”,i,2*i);
pari:%d\n”,i,2*i);
}}
Esempio:
visualizzazione dei primi 10 numeri pari
#include
#include <stdio.h>
<stdio.h>
/*
/* visualizza
visualizza ii primi
primi 10
10 numeri
numeri pari
pari */
*/
void
void main()
main()
{{
int
int i;
i;
for(i=1;
for(i=1; i<=10
i<=10 ;; i++)
i++)
printf(“%2d-simo
numero pari:%d\n”,i,2*i);
pari:%d\n”,i,2*i);
}}
1-simo numero pari :2
Esempio:
visualizzazione dei primi 10 numeri dispari
osservazione
primo numero dispari: 1 , (2*1-1)
secondo numero dispari: 3 , (2*2-1) i-simo numero dispari
terzo numero dispari: 5 , (2*3-1) 2*i-1
…
#include
#include <stdio.h>
<stdio.h>
/*
/* visualizza
visualizza ii primi
primi 10
10 numeri
numeri dispari
dispari */
*/
void
void main()
main()
{{
int
int i;
i;
for(i=1;
for(i=1; i<=10
i<=10 ;; i++)
i++)
printf(“%2d-simo
numero dispari:%d\n”,i,2*i-1);
dispari:%d\n”,i,2*i-1);
}}
Esempio:
programma di controllo di correttezza della risposta (inserita
da tastiera) a una domanda
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
int
int risposta;
risposta;
const
const int
int risposta_corretta
risposta_corretta == 10;
10;
do
do {{
printf(“qual
printf(“qual e’e’ il
il log
log in
in base
base 22 di
di 1024?\n”);
1024?\n”);
scanf(“%d”,&risposta);
scanf(“%d”,&risposta);
if
if (risposta
(risposta ==
== risposta_corretta)
risposta_corretta)
printf(“risposta
printf(“risposta corretta\n”);
corretta\n”);
else
else
printf(“risposta sbagliata,
printf(“risposta sbagliata, ripetere\n”);
ripetere\n”);
}} while(risposta
while(risposta !=!= risposta_corretta);
risposta_corretta);
}}
…………
…………
nidificazione di cicli for
for i=1,2
i=1,2 do
do
for
for j=1,3
j=1,3 do
do
(cicli innestati) print
print ‘(’,i,‘
‘(’,i,‘ ’,j,‘)’
’,j,‘)’
endfor
endfor
endfor
endfor
…………
…………
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
int
int i,j;
i,j;
for
for (i=1;
(i=1; i<=2;
i<=2; i++)
i++)
for
for (j=1;
(j=1; j<=3;
j<=3; j++)
j++)
printf(“(%d,%d)
printf(“(%d,%d) ”,i,j);
”,i,j);
}}
(1,1) (1,2) (1,3) (2,1) (2,2) (2,3)_

…………
…………
nidificazione di cicli for
for j=1,3
j=1,3 do
do
for
for i=1,2
i=1,2 do
do
(cicli innestati) print
print ‘(’,i,‘
‘(’,i,‘ ’,j,‘)’
’,j,‘)’
endfor
endfor
endfor
endfor
…………
…………
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
int
int i,j;
i,j;
for
for (j=1;
(j=1; j<=3;
j<=3; j++)
j++)
for(i=1;
for(i=1; i<=2;
i<=2; i++)
i++)
printf(“(%d,%d)
printf(“(%d,%d) ”,i,j);
”,i,j);
}}
(1,1) (2,1) (1,2) (2,2) (1,3) (2,3)_

Titolo unità didattica: Function e procedure [05]
Titolo modulo : Function [01-T]
Organizzazione di algoritmi come function
Argomenti trattati:
9 organizzazione modulare
9 function
9 parametri e argomenti
9 restituzione del risultato

problema:
algoritmo per il calcolo della circonferenza c di un
cerchio, di cui è noto il raggio r
dato di input: il numero r (variabile raggio)
dato di output: il numero c

(variabile circonferenza)
var
var raggio,
raggio, circonferenza:
circonferenza: real
real
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real
read
read raggio
raggio
circonferenza
2.0*pi_greco*raggio
print
print circonferenza
circonferenza
a un algoritmo può essere associato un nome

program <nome algoritmo>
program
program calcolo_circonferenza
calcolo_circonferenza
var
var raggio,
circonferenza: real
real
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real
read
read raggio
raggio
circonferenza
2.0*pi_greco*raggio
print
print circonferenza
circonferenza
end
end
l'algoritmo è formalmente organizzato come una entità
individuata da un nome
limitazione!
il programma calcolo_circonferenza non
può essere utilizzato da altri programmi
program
program main
main
var
var raggio:
raggio: real
real
...
...
...
...
read
read raggio
raggio
...
... programma
programma
...
... calcolo_circonferenza
calcolo_circonferenza
obiettivo: all’interno di main si vuole calcolare la circonferenza

del cerchio di raggio raggio, eseguendo il programma il cui
nome è calcolo_circonferenza
limitazione!
il programma calcolo_circonferenza non
può essere utilizzato da altri programmi
function e procedura
l’algoritmo
l’algoritmo deve
deve essere
essere organizzato
organizzato in in modo
modo da
da
poter
poter essere
essere utilizzato
utilizzato da
da altri
altri algoritmi
algoritmi
l’algoritmo
l’algoritmo deve
deve poter
poter “scambiare”
“scambiare” dati
dati con
con gli
gli
altri
altri algoritmi
algoritmi che
che lo
lo utilizzano
utilizzano
input input input ……. input
function
output
9 il nome della function
la intestazione di una function deve specificare
9 le variabili per i dati di input (parametri)

9 il tipo del valore da restituire (il dato di output)

function <nome>(<variabili>): <tipo>
function
function circon(raggio):
circon(raggio): real
real
var
var raggio:
raggio: real
real
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real ...
...
9 il valore che restituisce (dato di output)
la function deve specificare

return <espressione>
function
real
var
var raggio,risultato:
raggio,risultato: real
real
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real
risultato
risultato :=
:= 2.0*pi_greco*raggio
2.0*pi_greco*raggio
return
return risultato
risultato
end
end
9 il valore che restituisce (dato di output)
la function deve specificare

return <espressione>
function
real
var
var raggio:
raggio: real
real
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real
return
return 2.0*pi_greco*raggio
2.0*pi_greco*raggio
end
end
utilizzo di una function:
program
program usa_circon
usa_circon
var
real
var
var circon:
circon: real
real function
function
raggio
raggio :=
:= 1.1
1.1
circonferenza :=
circonferenza := circon(raggio)
circon(raggio)
print
print circonferenza
circonferenza
end
end
raggio è l’argomento della chiamata

program
program usa_circon
usa_circon
var
var mio_raggio,
mio_raggio, circonferenza:
circonferenza: real
real
var
var circon:
circon: real
real function
function
mio_raggio
mio_raggio :=:= 1.1
1.1
circonferenza :=
circonferenza := circon(mio_raggio)
circon(mio_raggio)
print
print circonferenza
circonferenza
end
end
mio_raggio è l’argomento della chiamata

program
program usa_circon
usa_circon
var
var circonferenza:
circonferenza: real
real
var circon:
var circon: real
real function
function
circonferenza
circonferenza := := circon(1.1)
circon(1.1)
print
print circonferenza
circonferenza
end
end
1.1 è l’argomento della chiamata

program
program usa_circon
usa_circon program
program usa_circon
usa_circon
var
var circon:
circon: real
real function
function varvar r:
r: real
real
print
print circon(1.1)
circon(1.1) var
var circon:
circon: real
real function
function
end
end read rr
read
print
print circon(r)
circon(r)
end
end
program
program usa_circon
usa_circon
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: realreal
var
var circon:
circon: real
real function
function
circon(1.1)
circon(1.1) :=
:= 2.0*pi_greco*1.1
2.0*pi_greco*1.1
print
print circon(1.1)
circon(1.1)
end
end
le espressioni
circonferenza
circonferenza :=
:= circon(mio_raggio)
circon(mio_raggio)
circonferenza
circonferenza :=
:= circon(raggio)
circon(raggio)
contengono un riferimento alla

function circon
la
la valutazione
valutazione didi questa
questa espressione
espressione
richiede
richiede l'esecuzione
l'esecuzione (attivazione)
(attivazione) della
della
function circon
function circon
l'esecuzione
l'esecuzione dell'istruzione
dell'istruzione didi chiamata
chiamata
provoca
provoca l'esecuzione
l'esecuzione della
della function
function
(attivazione
(attivazione della
della function)
function)
lo
lo scambio
scambio didi informazioni
informazioni tratra ilil
programma
programma chiamante
chiamante ee
la
la function
function chiamata
chiamata
avviene
avviene attraverso
attraverso la la corrispondenza
corrispondenza
tra
tra argomento
argomento di di chiamata
chiamata ee
parametro
parametro delladella function
function
ee attraverso
attraverso ilil risultato
risultato restituito
restituito
nell’espressione
nell’espressione di di chiamata
chiamata
argomenti
argomenti
variabili
variabili che
che appaiono
appaiono nella
nella chiamata
chiamata di
di una
una function
function
parametri
parametri
variabili
variabili che
che appaiono
appaiono nell’intestazione
nell’intestazione di
di una
una function
function
ilil valore
valore dell’argomento
dell’argomento viene
viene
assegnato
assegnato al al parametro
parametro corrispondente,
corrispondente,
al
al momento
momento dell’attivazione
dell’attivazione della
della function
function
argomento
argomento ee parametro
parametro non
non sono
sono la
la
stessa
stessa variabile
variabile
function <nome>(<variabili>):<tipo>
la lista delle variabili che appaiono nella

intestazione è la lista dei parametri della function
e indica le variabili che identificano i dati di input
dell'algoritmo
c’è un unico dato di output dell'algoritmo,
che è associato al nome della function
e il cui tipo è precisato in <tipo>
function
real tipo dell’output
parametro di input
¾ la function circon ha come unico
¾ non ci sono istruzioni di I/O nella function

parametro la variabile raggio
¾ la variabile raggio è lasciata indefinita

(senza valore associato) nel corpo della
¾ la function deve contenere una istruzione

function
che restituisca il valore della function

(dato di output)
(return 2.0*pi_greco*raggio)
Esempio:
algoritmo per il calcolo dell'area A di un cerchio di
raggio r, utilizzando il valore della circonferenza c
(c=2Sr, A=Sr2 e quindi A=c2/(4S))
program
program area_di_un_cerchio
area_di_un_cerchio
var
var area,
area, raggio:
raggio: real
real
var
var circon:
circon: real
real function
function
const pi_greco
const pi_greco == 3.1415926:
3.1415926: real
real
read raggio
read raggio
area :=
area := circon(raggio)^2/(4.0*pi_greco)
circon(raggio)^2/(4.0*pi_greco)
print
print area
area
end
end
2
4S
c
A
function
function area_cerchio(raggio):
area_cerchio(raggio): real
real
var raggio:
var raggio: real
real
var circon: real function versione 1
var circon: real function
const pi_greco
3.1415926: real
real
return
return circon(raggio)^2/(4.0*pi_greco)
circon(raggio)^2/(4.0*pi_greco)
end
end
function area_cerchio(raggio): real A Sr 2

function area_cerchio(raggio): real
var
var raggio:
raggio: real
real versione 2
const pi_greco
3.1415926: real
real
return pi_greco*raggio^2
return pi_greco*raggio^2
end
end
programma che chiama
la function area_cerchio
program
program usa_area_cerchio
usa_area_cerchio
var
var area,
area, raggio:
raggio: real
real
var
var area_cerchio:
area_cerchio: real
real function
function
read
read raggio
raggio
area :=
area := area_cerchio(raggio)
area_cerchio(raggio)
print
print area
area
end
end
per il programma usa_area_cerchio
¾ non è necessario conoscere quale
algoritmo è implementato nella
function area_cerchio,
¾ è necessario sapere solo come
richiamare (le specifiche) la
function area_cerchio
nascondere
nascondere ii dettagli
dettagli
==
astrazione
astrazione
Esempio:
algoritmo per il calcolo dell'area di una corona circolare
dati di input: il raggio maggiore R (variabile r_mag),

il raggio minore r (variabile r_min)
dato di output: l’area A (variabile area_corona)
Area cerchio esterno
AR Ar
R
r A
Area cerchio interno
Esempio:
algoritmo per il calcolo dell'area di una corona circolare
dati di input: il raggio maggiore R (variabile r_mag),
il raggio minore r (variabile r_min)
dato di output: l’area A (variabile area_corona)
program
program corona_circolare
corona_circolare
var
var r_mag,r_min,area_corona:
r_mag,r_min,area_corona: realreal
var
var area_cerchio:
area_cerchio: real
real function
function
read
read r_mag,
r_mag, r_min
r_min
area_corona
area_corona :=:= area_cerchio(r_mag)-
area_cerchio(r_mag)-
area_cerchio(r_min)
area_cerchio(r_min)
print
print area_corona
area_corona
end
end
prima chiamata
area_cerchio(r_mag)
attivazione della
al parametro raggio è associato il valore

dell’argomento r_mag
al termine dell'esecuzione della function si
ottiene il valore del primo dei due addendi
seconda chiamata
area_cerchio(r_min)
attivazione della
al parametro raggio è associato il valore

dell’argomento r_min
al termine dell'esecuzione è associato

un valore anche al secondo addendo
l’espressione viene valutata e il suo valore
viene associato alla variabile area_corona
area_corona :=
area_cerchio(r_mag)-area_cerchio(r_min)
function area_cerchio(raggio)
<corpo della function>
scambio
scambio delle
delle informazioni
informazioni (dati)
(dati) tra
tra
chiamante
chiamante ee chiamato
chiamato
==
meccanismo
meccanismo didi sostituzione,
sostituzione,
(( passaggio
passaggio dei
dei parametri
parametri ))
Esempio:
sviluppare una function per il calcolo della
x y
x, y
2 2
distanza d di un punto di
coordinate dall'origine
d y
x
Esempio:
x y
x, y
2 2
dati di input: ascissa x (variabile x), ordinata y

(variabile y)
dato di output: la distanza d (da restituire)

Esempio:
x y
x, y
2 2
function
function distanza_o(x,y):
distanza_o(x,y): real
real
var
var x,y:
x,y: real
real
return
return sqrt(x^2+y^2)
sqrt(x^2+y^2)
end
end
Esempio:
calcolare la distanza dall'origine dei due punti
(2.1,4.2) e (-1.1,-3.2)
program
program usa_distanza_o
usa_distanza_o
var
var d_primo_punto,d_secondo_punto,...
d_primo_punto,d_secondo_punto,...
primo_x,primo_y,secondo_x,secondo_y:
primo_x,primo_y,secondo_x,secondo_y: real
real
var
var distanza_o:
distanza_o: real
real function
function
read primo_x,primo_y,secondo_x,secondo_y
read primo_x,primo_y,secondo_x,secondo_y
d_primo_punto
d_primo_punto :=:= distanza_o(primo_x,primo_y)
distanza_o(primo_x,primo_y)
d_secondo_punto
d_secondo_punto :=:= distanza_o(secondo_x,secondo_y)
distanza_o(secondo_x,secondo_y)
print
print d_primo_punto,d_secondo_punto
d_primo_punto,d_secondo_punto
end
end
la
la corrispondenza
corrispondenza tra
tra
parametri
parametri
ee
argomenti
argomenti
èè stabilita
stabilita dalla
dalla posizione
posizione dei
dei parametri
parametri
nella
nella lista
lista dei
dei parametri
parametri (nell’intestazione)
(nell’intestazione)
ee degli
degli argomenti
argomenti nella
nella
lista
lista degli
degli argomenti
argomenti (nella
(nella chiamata)
chiamata)
argomento
parametro non
non sono
sono la
la
stessa
stessa variabile
variabile
Titolo unità didattica: Function e procedure [05]
Titolo modulo : Procedure [02-T]
Organizzazione di algoritmi come procedure
Argomenti trattati:
9 procedure
9 parametri di input, parametri di output
9 parametri di input/output

input input input ……. input
procedura
output output ……. output

la intestazione di una procedura deve
9 il nome della procedura

specificare
9 i parametri di input
9 i parametri di output
9 i parametri di input/output

procedure <nome procedura>
( in: <parametri input>;
out: <parametri output>;
inout:<parametri input/output>)
procedura:
procedura: intestazione
intestazione
procedure
procedure <nome
<nome procedura>
procedura>
(in:<variabili>;
(in:<variabili>; out:<variabili;
out:<variabili;
inout:<variabili>)
inout:<variabili>)
le variabili che appaiono

9 dopo
9 dopo
in: sono i parametri di input
9 dopo
out: sono i parametri di output
inout: sono parametri sia di
input sia di output
Esempio di intestazione
procedure
procedure circ(in:
circ(in: r;
r; out:
out: c)
c)
var
var r,c:
r,c: real
real
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real
cc :=
:= 2.0*pi_greco*r
2.0*pi_greco*r
end
end
¾ la procedura circ ha un unico
¾
parametro di input, la variabile r
la procedura ha un unico parametro di
¾ non ci sono istruzioni di I/O nella procedura

output, la variabile c
coinvolgenti i parametri
Esempio di intestazione
procedure
procedure circ(in:
circ(in: r;
r; out:
out: c)
c)
var
var r,c:
r,c: real
real
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real
cc :=
:= 2.0*pi_greco*r
2.0*pi_greco*r
end
end
¾ la variabile r è lasciata indefinita (nessun valore
¾ la procedura deve contenere una istruzione che
associato) nel corpo della procedura
assegni un valore al parametro di uscita (dato
¾ non ci deve essere nessuna istruzione return

di output), cioè alla variabile c
Esempio di chiamata
program
program usa_circ
usa_circ
var
var raggio,
circonferenza: real
real
read
read raggio
raggio
circ(raggio,
circ(raggio, circonferenza)
circonferenza)
print
print circonferenza
circonferenza
¾ il valore della variabile

end
end
raggio è
l’argomento di input da associare al
¾
parametro di input r
l’argomento di output circonferenza riceve il
valore associato al parametro di output
c, al termine dell’esecuzione della
procedura
Problema:
algoritmo per lo scambio del valore di due variabili
(di tipo intero)
alfa, beta di tipo integer
53 -44
alfa beta
Problema:
(di tipo intero)
alfa := beta
beta := alfa
53 -44
alfa beta
Problema:
(di tipo intero)
alfa := beta
beta := alfa
-44 -44
alfa beta
Problema:
(di tipo intero)
temp := alfa alfa, beta, temp
alfa := beta di tipo integer
beta := temp
53 -44
alfa beta
temp
Problema:
(di tipo intero)
temp := alfa alfa, beta, temp
alfa := beta di tipo integer
beta := temp
-44 -44
alfa beta
53
temp
procedura per lo scambio del valore di due variabili di tipo intero
procedure
procedure scambiare_i(inout:
scambiare_i(inout: var1,var2)
var1,var2)
var
var var1,
var1, var2,
var2, temp:
temp: integer
integer
temp
temp :=
:= var1
var1
var1 :=
var1 := var2
var2
var2
var2 :=
:= temp
temp
end
end
¾ la procedura scambiare_i ha due parametri
¾
di input/output, le variabili var1 e var2
¾
la procedura usa la variabile (locale) temp
la procedura modifica i valori associati ai
parametri di input/output var1, var2
procedure
var1,var2)
var
var var1,
var1, var2,
var2, temp:
temp: integer
integer
temp
temp :=
:= var1
var1
var1 :=
var1 := var2
var2
var2
var2 :=
:= temp
temp
end
end
program
program usa_scambiare_i
usa_scambiare_i
var
var alfa,
alfa, beta:
beta: integer
integer
read alfa,
read alfa, beta
beta
scambiare_i(alfa,
scambiare_i(alfa, beta)
beta)
print
print alfa,
alfa, beta
beta
end
end
Titolo unità didattica: Function e Procedure [05]
Titolo modulo : Function in C [03-C]
Caratteristiche delle function C ed esempi di function C
Argomenti trattati:
9 definizione di una function C
9 parametri e argomenti in C
9 prototipo di una function C
9 passaggio dei parametri per valore
9 istruzione return
9 esempi di function in C
9 function C primitive
9 header file C

function
real
function in C var
var raggio,risultato:
raggio,risultato: real
real
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real
risultato
risultato :=
:= 2.0*pi_greco*raggio
2.0*pi_greco*raggio
return
return risultato
risultato
end
end
float
float circon(float
circon(float raggio)
raggio)
{{
const float pi_greco
const float pi_greco == 3.1415926F;
3.1415926F;
float
float risultato;
risultato;
risultato
risultato == 2.0F*pi_greco*raggio;
2.0F*pi_greco*raggio;
return
return risultato;
risultato;
}}
function
real
function in C var
var raggio:
raggio: real
real
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real
return
return 2.0*pi_greco*raggio
2.0*pi_greco*raggio
end
end
float
float circon(float
raggio)
{{
3.1415926F;
return
return 2.0F*pi_greco*raggio;
}}
function in C definizione di function
intestazione
intestazione parametro
parametro ee tipo
tipo
tipo del
del parametro
parametro
tipo dell’output
dell’output
float
float circon
circon (float
(float raggio)
raggio)
{{
3.1415926F;
float
float risultato;
risultato;
risultato
return
return risultato;
risultato;
}}
ritorno
ritorno al
al chiamante
chiamante
ee passaggio
passaggio deldel risultato
risultato
<intestazione>
<intestazione>
{{
<corpo
<corpo della
della function>
function>
}}
(<tipo> <parametro>, <tipo> <parametro>,.., <tipo> <parametro>)
<tipo
<tipo output>
output> <nome
<nome function>(<tipo>
function>(<tipo> <parametro>)
<parametro>)
{{
<corpo
<corpo della
della function>
function>
}}
<intestazione>
<intestazione>
{{
<corpo
<corpo della
della function>
function>
}}
<intestazione>
<intestazione>
{{
variabili locali
<parte
<parte dichiarativa>
dichiarativa> della function
<parte
<parte esecutiva>
esecutiva>
}}
function in C chiamata di function
program
program usa_circon
usa_circon
var
real
var
var circon:
circon: real
real function
function
read
read raggio
raggio :=
:= 1.1
1.1
circonferenza
circonferenza := := circon(raggio)
circon(raggio)
print
print circonferenza
circonferenza
end
end
#include
#include <stdio.h>
<stdio.h> raggio è
float
float circon(float
circon(float raggio);
raggio); l’argomento
void
void main
main ()
() della chiamata
{{
float
float raggio,
circonferenza;
printf
printf (“Inserire
(“Inserire il
il raggio
raggio :: ”);
”);
circonferenza
circonferenza == circon(raggio);
circon(raggio);
printf
printf (“circonferenza=%f\n”,circonferenza);
(“circonferenza=%f\n”,circonferenza);
}}
function in C chiamata di function
prototipo
prototipo di
di function
function
#include
#include <stdio.h>
<stdio.h>
float
float circon(float
raggio);
void
void main
main ()
()
{{
float
float raggio, chiamata
chiamata di
circonferenza; di function
function
printf
printf (“Inserire
(“Inserire il
il raggio
raggio :: ”);
”);
circonferenza
circonferenza == circon
circon (raggio);
(raggio);
printf
}}
il prototipo di una function C specifica il

numero e il tipo dei parametri
float
float circon(float);
circon(float); nel prototipo si possono
omettere i nomi dei parametri
organizzazione di un programma C unico file
#include
#include <stdio.h>
<stdio.h>
float
float circon(float
raggio);
void
void main
main ()
()
{{
float
float raggio,
circonferenza;
printf
printf (“Inserire
(“Inserire il
il raggio
raggio :: ”);
”);
circonferenza
circon(raggio);
printf
}}
float
float circon(float
raggio)
{{
const
const float
float pi_greco
pi_greco == 3.1415926F;
3.1415926F; variabile locale
float risultato;
float risultato; della function
risultato
return
return risultato;
risultato;
}}
organizzazione di un programma C più file
#include
#include <stdio.h>
<stdio.h> main.c
float
float circon(float
raggio);
void
void main
main ()
()
{{
float
float raggio,
circonferenza;
printf
printf (“Inserire
(“Inserire il
il raggio
raggio :: ”);
”);
circonferenza
circon(raggio);
printf
}}
float
float circon(float
raggio) circon.c
{{
const
const float
float pi_greco
pi_greco == 3.1415926F;
3.1415926F;
float
float risultato;
risultato;
risultato
return
return risultato;
risultato;
}}
qualunque sia l’organizzazione del programma C:
una
una variabile
variabile dichiarata
dichiarata all’interno
all’interno didi una
una
function
function èè utilizzabile
utilizzabile solo
solo all’interno
all’interno della
della
function
function stessa;
stessa;
essa
essa risulta
risulta indeterminata
indeterminata (non (non dichiarata)
dichiarata)
al
al di
di fuori
fuori della
della function
function
regola
regola di di visibilità
visibilità (scope
(scope rule):
rule):
gli
gli identificatori
identificatori sono
sono accessibili
accessibili solo
solo all’interno
all’interno
del
del blocco
blocco nelnel quale
quale sono
sono dichiarati;
dichiarati;
al
al di
di fuori
fuori del
del blocco
blocco essi
essi risultano
risultano sconosciuti
sconosciuti
programma C
insieme di comandi
al precompilatore
un eventuale prototipi di function
variabili globali
insieme di tipi globali
dichiarazioni ….
una function main
un eventuale
insieme di function
l’esecuzione del programma inizia sempre dal main

programma C
file1.c
unico file main
compilazione separata
.c
file2.c
compilazione unica
main
function1 function1
function2 file3.c
…..
function2
functionn
function3
…..
passaggio di parametri in C
sempre
sempre per
per valore
valore
alla
alla function
function viene
viene passata
passata una
una copia
copia del
del valore
valore
dell’argomento
dell’argomento
argomento
parametro
non
non sono
sono la
la stessa
stessa variabile
variabile
l’eventuale
l’eventuale variazione
variazione del
del valore
valore del
del parametro
parametro
(nella
(nella function)
function)
non
non haha nessun
nessun effetto
effetto
sul
sul valore
valore dell’argomento
dell’argomento (nel (nel chiamante)
chiamante)
passaggio di parametri in C per valore
#include
#include <stdio.h>
<stdio.h>
float
circon(float);
void
void main
main ()
()
{{
float
float raggio_main,
raggio_main, circonferenza;
circonferenza;
printf
printf (“Inserire
(“Inserire il
il raggio
raggio :: ”);
”);
scanf(“%f”,&raggio_main);
circonferenza
circonferenza == circon(raggio_main);
circon(raggio_main);
printf
}}
float
float circon(float
raggio)
{{
const
const float
float pi_greco
pi_greco == 3.1415926F;
3.1415926F;
float
float risultato;
risultato;
risultato
return
return risultato;
risultato;
}}
passaggio di parametri in C per valore
#include
#include <stdio.h>
<stdio.h>
void
void main
main ()
()
{{
float raggio_main,
float raggio_main, circonferenza;
circonferenza;
raggio_main = 100.0F;
raggio_main = 100.0F;
circonferenza
circonferenza == circon(raggio_main);
circon(raggio_main);
printf (“raggio=%f\n”,raggio_main);
printf (“raggio=%f\n”,raggio_main);
printf
}}
float
float circon(float
raggio)
{{
const
const float
float pi_greco
pi_greco == 3.1415926F;
3.1415926F;
float
float risultato;
risultato;
risultato
raggio = 0.0F;
raggio = 0.0F;
return
return risultato;
risultato;
}}
raggio=100.000000
circonferenza= 628.318481
_
Versione 1: main e function in un unico file .c
Esercizio: Versione 2: main e function in due file .c nello stesso project
scrivere una function area_cerchio che calcoli l’area di un cerchio,

dato come parametro il raggio.
Scrivere un main che calcoli l’area di un cerchio (letto con scanf il
suo raggio) richiamando la function area_cerchio
#include
#include <stdio.h>
<stdio.h>
float
float area_cerchio(float);
area_cerchio(float);
void
void main
main ()()
{{
float raggio_main,
float raggio_main, area;
area;
printf
printf (“Inserire il raggio
(“Inserire il raggio :: ”);
”);
area
area == area_cerchio(raggio_main);
area_cerchio(raggio_main);
printf
printf (“l’area del
(“l’area del cerchio
cerchio di
di raggio
raggio %f
%f e’:%f\n”,
e’:%f\n”,
raggio_main,area);
raggio_main,area);
}}
float area_cerchio(float
float area_cerchio(float raggio)
raggio)
{{
const
const float
float pi_greco
pi_greco == 3.1415926F;
3.1415926F;
return pi_greco*raggio*raggio;
}}
Versione 1: main e area_cerchio e area_corona in un unico
Esercizio: file .c
scrivere una function area_corona che calcoli l’area di una corona

circolare, dati come parametri il raggio minore e il raggio maggiore,
richiamando la function area_cerchio.
Scrivere un main che calcoli l’area di una corona circolare (letti con
scanf il raggio maggiore e il raggio minore) richiamando la function
area_corona
#include
#include <stdio.h>
<stdio.h>
float
float area_corona(float,
area_corona(float, float);
float);
void main
void main ()()
{{
float
float raggio_mag,raggio_min,area;
raggio_mag,raggio_min,area;
printf
printf (“Inserire
(“Inserire il
il raggio
raggio maggiore
maggiore :: ”);
”);
scanf(“%f”,&raggio_mag);
printf
printf (“Inserire
(“Inserire il
il raggio
raggio minore
minore :: ”);
”);
scanf(“%f”,&raggio_min);
area
area == area_corona(raggio_min,raggio_mag);
area_corona(raggio_min,raggio_mag);
printf
printf (“l’area della
(“l’area della corona
corona circolare
circolare didi raggio
raggio minore
minore %f
%f ee
raggio
raggio maggiore
maggiore %f
%f e’:%f\n”,raggio_min,raggio_mag,area);
e’:%f\n”,raggio_min,raggio_mag,area);
}}
……
……
Versione 1: main e area_cerchio e area_corona in un unico
Esercizio: file .c

area_corona
……
……
float area_cerchio(float raggio)
raggio)
{{
3.1415926F;
}}
float
float area_corona(float
area_corona(float r_min,float
r_min,float r_mag)
r_mag)
{{
return
return area_cerchio(r_mag)-area_cerchio(r_min);
area_cerchio(r_mag)-area_cerchio(r_min);
}}
Versione 2: main in un file, area_cerchio e area_corona in un
Esercizio: altro file .c nello stesso project

area_corona
#include
#include <stdio.h>
<stdio.h> float
area_cerchio(float);
float
float area_corona(float, float);
area_corona(float, float); float
float area_corona(float r_min,float
area_corona(float r_min,float
void main
void main ()() r_mag)
r_mag)
{{ {{
float raggio_mag,raggio_min,area;
float raggio_mag,raggio_min,area; return
return area_cerchio(r_mag)-
area_cerchio(r_mag)-
printf
printf (“Inserire
(“Inserire il
il raggio
raggio maggiore
maggiore :: ”);
”); area_cerchio(r_min);
area_cerchio(r_min);
scanf(“%f”,&raggio_mag); }}
printf
printf (“Inserire
(“Inserire il
il raggio
raggio minore
minore :: ”);
”); float
area_cerchio(float raggio)
raggio)
scanf(“%f”,&raggio_min); {{
area
area == area_corona(raggio_min,raggio_mag);
area_corona(raggio_min,raggio_mag); const float pi_greco
3.1415926F;
printf
printf (“l’area della
(“l’area della corona
corona circolare
circolare didi return pi_greco*raggio*raggio;
raggio minore %f eraggio maggiore
raggio minore %f eraggio maggiore }}
%fe’:%f\n”,raggio_min,raggio_mag,
%fe’:%f\n”,raggio_min,raggio_mag,
area);
area);
}}
file main.c file fun.c

Esercizio:
scrivere una function valore_assolutoF che calcoli il valore
assoluto di un numero float, dato come parametro
#include
#include <stdio.h>
<stdio.h>
float
float valore_assolutoF(float);
valore_assolutoF(float);
void
void main
main ()
()
{{
float numero,val_ass_numero;
float numero,val_ass_numero;
printf
printf (“Inserire
(“Inserire unun numero
numero (float)
(float) :: ”);
”);
scanf(“%f”,&numero);
val_ass_numero
val_ass_numero == valore_assolutoF(numero);
valore_assolutoF(numero);
printf
printf (“il valore assoluto
(“il valore assoluto didi %f
%f e’:%f\n”,numero,val_ass_numero);
e’:%f\n”,numero,val_ass_numero);
}}
float valore_assolutoF(float
float valore_assolutoF(float x) x)
{{
if
if (x
(x >=
>= 0)
0)
return
return x;x;
else
else
return
return -x;-x;
}}
Esercizio:
scrivere una function errore_relativoF che calcoli l’errore relativo
x y
di tra due dati float, dati come parametri
Errore relativo =
x
errore relativo di y rispetto a x
VFULYHUHXQmain FKHULFKLDPLODIXQFWLRQ errore_relativoF H

XWLOL]]DUORSHUFDOFRODUHOಬHUURUHUHODWLYRSHUOHFRSSLHGLQXPHUL
x=7.2 , y= 6.4
x= 8.221222 , y= 8.221233
x= -3.21 , y= -3.25
Esercizio:
#include
#include <stdio.h>
<stdio.h>
float
float valore_assolutoF(float);
valore_assolutoF(float);
float
float errore_relativoF(float,
errore_relativoF(float, float);
float);
void
void main
main ()
()
{{
float x,y,errore_rel;
float x,y,errore_rel;
printf
printf (“Inserire
(“Inserire valore
valore di
di riferimento
riferimento (float)
(float) :: ”);
”);
scanf(“%f”,&x);
scanf(“%f”,&x);
printf
printf (“Inserire
(“Inserire approssimazione
approssimazione (float)
(float) :: ”);
”);
scanf(“%f”,&y);
scanf(“%f”,&y);
errore_rel
errore_rel == errore_relativoF(x,y);
errore_relativoF(x,y);
printf
printf (“l’errore
(“l’errore relativo
relativo di
di %f
%f rispetto
rispetto aa %f
%f
e’:%f\n”,y,x,errore_rel);
e’:%f\n”,y,x,errore_rel);
}}
……
……
Esercizio:
……
……
float
float errore_relativoF(float
errore_relativoF(float x,
x, float
float y)
y)
{{
return
return valore_assolutoF(x-y)/valore_assolutoF(x);
valore_assolutoF(x-y)/valore_assolutoF(x);
}}
float
float valore_assolutoF(float
valore_assolutoF(float x)
x)
{{
if
if (x
(x >=
>= 0)
0)
return
return x;
x;
else
else
return
return -x;
-x;
}}
Esercizio:
scrivere una function distanza_origF che calcoli la distanza
dall’origine di un punto del piano, date come parametri le sue due
coordinate
d origine x2 y 2
VFULYHUHXQmain FKHULFKLDPLODIXQFWLRQ distanza_origF H

XWLOL]]DUORSHUFDOFRODUHODGLVWDQ]DGDOOಬRULQHGHLSXQWLFRQOHVHJXHQWL
FRRUGLQDWH
x=2.1 , y= 4.2
x= -1.1 , y= 3
x= 0 , y= -100
Esercizio: d origine x2 y2
coordinate
#include
#include <stdio.h>
<stdio.h>
#include
#include <math.h>
<math.h>
float
float distanza_origF
distanza_origF (float,
(float, float);
float);
void
void main
main ()
()
{{
float
float x,y,distanza_origine;
x,y,distanza_origine;
printf
printf (“Inserire
(“Inserire le
le coordinate
coordinate del
del punto
punto (float)
(float) :: ”);
”);
scanf(“%f%f”,&x,&y);
distanza_origine
distanza_origine == distanza_origF(x,y);
distanza_origF(x,y);
printf
printf (“la
(“la distanza
distanza dall’origine
dall’origine del
del punto
punto di
di
coordinate
coordinate (%f,%f)
(%f,%f) e’:%f\n”,x,y,distanza_origine);
e’:%f\n”,x,y,distanza_origine);
}}
float
distanza_origF (float
(float ascissa,
ascissa, float
float ordinata)
ordinata)
{{
return
return sqrt(ascissa*ascissa+ordinata*ordinata);
sqrt(ascissa*ascissa+ordinata*ordinata);
}}
Esercizio: d origine x2 y2
coordinate
#include
#include <stdio.h>
<stdio.h>
#include
#include <math.h>
<math.h>
float
distanza_origF (float,
(float, float);
float);
void
void main
main ()
()
{{
float
float x,y,distanza_origine;
x,y,distanza_origine;
printf
printf (“Inserire
(“Inserire le
le coordinate
coordinate del
del punto
punto (float)
(float) :: ”);
”);
distanza_origine
distanza_origine == distanza_origF(x,y);
distanza_origF(x,y);
printf
printf (“la
(“la distanza
distanza dall’origine
dall’origine del
del punto
punto di
di
coordinate
coordinate (%f,%f)
(%f,%f) e’:%f\n”,x,y,distanza_origine);
e’:%f\n”,x,y,distanza_origine);
}}
float
distanza_origF (float
(float ascissa,
ascissa, float
float ordinata)
ordinata)
{{
return
return sqrt(pow(ascissa,2)+pow(ordinata,2);
sqrt(pow(ascissa,2)+pow(ordinata,2);
}}
function C primitive
in C vi sono function predefinite per svolgere compiti
specifici di utilità in programmazione
printf
scanf
getchar
putchar sono organizzate in librerie
sqrt
pow una libreria C è un insieme di file;
…… ogni file contiene il codice oggetto di una
function C (insieme di file .obj, cioè
ottenuti compilando function C)
function C primitive librerie
in C vi sono function predefinite per svolgere compiti

specifici di utilità in programmazione
libreria standard di I/O stdio

libreria di funzioni matematiche math
libreria standard stdlib
libreria per la misurazione dei tempi time
……. …
a ogni libreria è associato un
file di intestazioni (header file)
che è un file testo contenente i prototipi delle function
della libreria
(più eventuali altre informazioni necessarie per
l’esecuzione delle function della libreria)
function C primitive file di intestazioni
Se in un programma C (in un file .c) si utilizza una

function primitiva di una libreria, è necessario includere
il corrispondente file di intestazioni della libreria
printf <stdio.h>
scanf <stdio.h> < >
getchar <stdio.h> per gli
putchar <stdio.h> header file
sqrt <math.h> di librerie C
pow <math.h>
…… ……
#include
#include <stdio.h>
<stdio.h>
#include
#include <math.h>
<math.h>
#include produce l’inserimento nel testo del programma, al
posto del comando stesso, di una copia del file di intestazioni
function C file di intestazioni
in un programma C (in un file .c) è possibile definire e

includere file di intestazioni
#include
#include “mioheader.h”
“mioheader.h”
void
void main ()
main ()
{{
float raggio,
float
printf
circonferenza; “ ”
printf (“Inserire il
(“Inserire il raggio
raggio :: ”);
”);
circonferenza
per gli
circon(raggio);
printf (“circonferenza=%f\n”,circonferenza); header file
}}
float circon(float
float circon(float raggio)
raggio)
di utente
{{
const
const float
float pi_greco
pi_greco == 3.1415926F;
3.1415926F;
float risultato;
float risultato;
risultato
return risultato;
return risultato;
}}
#include
#include <stdio.h>
<stdio.h> file di intestazioni
float
float circon(float
raggio); mioheader.h
estensione
estensione .h
.h
mioheader.h
Titolo unità didattica: Function e Procedure [05]
Titolo modulo : Procedure in C [04-C]
Function C che restituiscono più valori
Argomenti trattati:
9 void function in C
9 passaggio dei parametri per riferimento simulato
9 esempi di function C che implementano procedure
Prerequisiti richiesti: AP-03-04-T, AP-05-02-T, AP-05-03-T

function
function procedure
procedure
function
function
in
in C
C una
una procedura
procedura viene
viene realizzata
realizzata
mediante
mediante una
una function
function
una
una function
function C
C può
può avere
avere unun numero
numero
qualunque
qualunque di di valori
valori da
da restutuire
restutuire
void function in C procedure
procedure circ(in:
circ(in: r;
r; out:
out: c)
c)
var
var r,c:
r,c: real
real
const
const pi_greco
pi_greco == 3.1415926:
3.1415926: real
real
cc :=
:= 2.0*pi_greco*r
2.0*pi_greco*r
end
end
void
void circ(float
circ(float r,
r, float
float *c)
*c)
const
const float
float pi_greco
pi_greco == 3.1415926F;
3.1415926F;
{{
*c
*c == 2.0F*pi_greco*r;
2.0F*pi_greco*r;
}}
intestazione di una void function
parametro
parametro
di
di input
input
void
void circ(float
circ(float r,
r, float
float *c)
*c)
indica
indica che
che la
la function
function non
non parametro
parametro
restituisce
restituisce unun valore
valore di
di output
output
mediante return
mediante return
ii parametri
parametri di
di output
output devono
devono essere
essere
puntatori
puntatori
chiamata di una void function
program
program usa_circ
usa_circ
var
var raggio,
circonferenza: real
real
read
read raggio
raggio
circ(raggio,
circ(raggio, circonferenza)
circonferenza)
print
print circonferenza
circonferenza
end
end
#include<stdio.h>
#include<stdio.h>
void
void circ(float
circ(float r,float
r,float *c);
*c);
void
void main
main ()
()
{{
float
float raggio,
circonferenza;
printf(“inserire
printf(“inserire ilil raggio:
raggio: ”);
”);
circ(raggio,
circ(raggio, &circonferenza);
&circonferenza);
printf(“circonferenza
printf(“circonferenza =%f\n”,circonferenza);
=%f\n”,circonferenza);
}}
chiamata di una void function
circ(raggio, &&circonferenza
circ(raggio, circonferenza));;
argomento
argomento argomento
argomento
di
di input
input di
di output
output
gli
gli argomenti
argomenti di
di output
output devono
devono essere
essere
indirizzi
indirizzi
operatore
operatoreindirizzo
indirizzodi
di (&)
(&)
indirizzo
indirizzodi
diuna
unavariabile
variabile
puntatore
puntatorealla
allavariabile
variabile
void
void circ(float
circ(float r,float
r,float *c)
*c)
ilil parametro
parametro didi output
output èè un
un
puntatore
puntatore (a
(a un
un float)
float)
l’argomento
l’argomento corrispondente
corrispondente (output)
(output)
deve
deve essere
essere unun
puntatore
puntatore aa un
un float
float
oppure
oppure
un
un indirizzo
indirizzo di
di un
un float
float
#include
#include <stdio.h>
<stdio.h>
void
void circ(float
circ(float r,float
r,float *c);
*c);
void
void main
main ()
()
{{
float
float raggio,
circonferenza;
circ(raggio,&circonferenza);
circ(raggio,&circonferenza);
printf
}}
#include
#include <stdio.h>
<stdio.h>
void
void circ(float,float
circ(float,float *);
*);
void
void main
main ()
()
{{
float
float raggio,
raggio, circonferenza,
circonferenza, *punt;
*punt;
punt
punt == &circonferenza;
&circonferenza;
circ(raggio,punt);
circ(raggio,punt);
printf
printf (“circonferenza=%f\n”,
(“circonferenza=%f\n”, circonferenza);
circonferenza);
}}
il passaggio dei parametri in C è solo per valore
parametri di input: OK
parametri di output: ?
ilil passaggio
passaggio dell’indirizzo
dell’indirizzo di
di una
una variabile
variabile consente
consente
di
di accedere
accedere in
in modo
modo indiretto
indiretto alla
alla variabile
variabile
#include<stdio.h>
#include<stdio.h> void
void circ(float
circ(float r,r, float
float *c)
*c)
void circ(float
void circ(float r,float
r,float *c); const
*c); const float
float pi_greco
pi_greco ==
void main ()
void main () 3.1415926F;
{{ 3.1415926F;
{{
float raggio,
float raggio, circonferenza;
circonferenza;
printf(“inserire
*c
*c == 2.0F*pi_greco*r;
2.0F*pi_greco*r;
printf(“inserire ilil raggio:
raggio: ”);
”); }}
circ(raggio,
circ(raggio, &circonferenza);
&circonferenza);
printf(“circonferenza ilil puntatore
printf(“circonferenza
=%f\n”,circonferenza); puntatoreccpunta
punta alla
alla
=%f\n”,circonferenza);
}} variabile
variabile circonferenza
circonferenza
il passaggio dei parametri in C è solo per valore
chiamante function chiamata
argomento: indirizzo parametro: puntatore
&variabile puntatore
passaggio
passaggio dei
dei parametri
parametri per
per
riferimento
riferimento simulato
simulato
procedure
var1,var2)
var
var var1,
var1, var2,
var2, temp:
temp: integer
integer
temp
temp :=
:= var1
var1
var1 :=
var1 := var2
var2
var2
var2 :=
:= temp
temp
end
end
program
program usa_scambiare_i
usa_scambiare_i
var
var alfa,
alfa, beta:
beta: integer
integer
read alfa,
read alfa, beta
beta
scambiare_i(alfa,
scambiare_i(alfa, beta)
beta)
print
print alfa,
alfa, beta
beta
end
end
#include
#include <stdio.h>
<stdio.h>
void
void scambiare_i(int
scambiare_i(int var1,int
var1,int var2);
var2);
void
void main()
main()
{{
int
int x,y;
x,y;
scanf(“%d%d”,&x,&y);
printf(“x=%d
printf(“x=%d y=%d”,x,y);
y=%d”,x,y);
scambiare_i(x,y);
scambiare_i(x,y);
printf(“x=%d
y=%d”,x,y);
}}
void
scambiare_i(int var1,
var1, int
int var2)
var2)
{{
int
int temp;
temp;
temp
temp == var1;
var1;
var1
var1 == var2;
var2;
var2
var2 == temp;
temp;
}}
#include
#include <stdio.h>
<stdio.h>
void
scambiare_i(int *var1,
*var1, int
int *var2);
*var2);
void
void main()
main()
{{
int
int x,y;
x,y;
printf(“x=%d
y=%d”,x,y);
scambiare_i(&x,&y);
scambiare_i(&x,&y);
printf(“x=%d
y=%d”,x,y);
}}
void scambiare_i(int *var1,
*var1, int
int *var2)
*var2)
{{
int
int temp;
temp;
temp
temp == *var1;
*var1;
*var1
*var1 == *var2;
*var2;
*var2
*var2 == temp;
temp;
}}
main scambiare_i
x var1 &x
y var2 &y
*var1 è il valore di x
*var2 è il valore di y
void
void main()
main()
{{
int
int x,y;
x,y;
printf(“x=%d
y=%d”,x,y);
scambiare_i(&x,&y);
scambiare_i(&x,&y);
printf(“x=%d
y=%d”,x,y);
}}
definizione
definizionedi maincome
di main voidfunction,
comevoid function,
void main()
senza
senzaparametri
parametri
scanfèèuna
scanf unafunction,
function,chiamata
chiamata
scanf(“%d%d”,&x,&y); con
con11argomento
argomentodi di input
inputee
22argomenti
argomentidi
di output
output
printfèèuna
printf unafunction,
function,
printf(“x=%d y=%d”,x,y); chiamata
chiamatacon
con33argomenti
argomenti di
di
input
input
Titolo unità didattica: Approccio incrementale [06]
Titolo modulo : Algoritmi per il calcolo di somme [01-T]
Sviluppo di algoritmi per il calcolo di sommatorie
Argomenti trattati:
9 l’idea “incrementale”
9 algoritmo incrementale per la somma dei primi n naturali
9 formula di Gauss per la somma dei primi n naturali
9 sequenza di istanze dello stesso problema
9 algoritmo incrementale per la somma armonica
9 analisi del costo di un algoritmo
Prerequisiti richiesti: AP-02-*-T, AP-04-*-T, AP-05-*-T

primi
primi criteri
criteri di
di progetto
progetto di
di un
un algoritmo
algoritmo
individuazione di
¾ dati di input del problema
¾ dati di output del problema
¾ costrutti di ripetizione da utilizzare;
individuare:
- costrutti ripetivi più adatti
- operazioni che vengono ripetute
- predicati di uscita dai cicli
problema:
calcolo della somma dei primi n numeri naturali
s = 1+2+3+4+5+…+n
s 1 2 3 ! n { ¦ i
n
i 1
unico unico
dato di output dato di input
dato di input: il numero n
dato di output: il numero s

idea! costruire
costruire la
la soluzione
soluzione attraverso
attraverso
incrementi
incrementi successivi
successivi
della
della difficoltà
difficoltà del
del problema
problema
approccio
approccio incrementale
incrementale
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
3 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
6 + 4 + 5 + 6 + 7 + 8 + 9 + 10
10 + 5 + 6 + 7 + 8 + 9 + 10
idea! costruire
costruire la
la soluzione
attraverso
incrementi
successivi
della
della difficoltà
difficoltà del
del problema
problema
approccio
incrementale
15 + 6 + 7 + 8 + 9 + 10
21 + 7 + 8 + 9 + 10
28+ 8 + 9 + 10
36+ 9 + 10
45+ 10
55
problema:
dato di input: il numero n (variabile n)
dato di output: il numero s (variabile somma)

costrutto ripetitivo: for
operazione ripetuta (al generico passo i):
sommare il numero i (l'addendo i-simo
della sommatoria) alla somma degli (i-1)
numeri precedenti
variabile
somma_parziale
costruire
costruire la
la soluzione
attraverso
incrementi
successivi
della
della difficoltà
difficoltà del
del problema
problema
approccio
incrementale
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
0
somma_parziale
costruire
costruire la
la soluzione
attraverso
incrementi
successivi
della
della difficoltà
difficoltà del
del problema
problema
approccio
incrementale
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
+
0
somma_parziale
costruire
costruire la
la soluzione
attraverso
incrementi
successivi
della
della difficoltà
difficoltà del
del problema
problema
approccio
incrementale
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
1
somma_parziale
costruire
costruire la
la soluzione
attraverso
incrementi
successivi
della
della difficoltà
difficoltà del
del problema
problema
approccio
incrementale
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
+
1
somma_parziale
costruire
costruire la
la soluzione
attraverso
incrementi
successivi
della
della difficoltà
difficoltà del
del problema
problema
approccio
incrementale
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
3
somma_parziale
costruire
costruire la
la soluzione
attraverso
incrementi
successivi
della
della difficoltà
difficoltà del
del problema
problema
approccio
incrementale
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
+
3
somma_parziale
costruire
costruire la
la soluzione
attraverso
incrementi
successivi
della
della difficoltà
difficoltà del
del problema
problema
approccio
incrementale
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
6
somma_parziale
somma_parziale :=
:= somma_parziale
somma_parziale ++ ii
costruire
costruire la
la soluzione
attraverso
incrementi
successivi
della
della difficoltà
difficoltà del
del problema
problema
approccio
incrementale
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
+
6
somma_parziale
somma_parziale :=
:= somma_parziale
costruire
costruire la
la soluzione
attraverso
incrementi
successivi
della
della difficoltà
difficoltà del
del problema
problema
approccio
incrementale
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
10
somma_parziale
somma_parziale :=
:= somma_parziale
problema:
approccio
incrementale
function
function somma_naturali(n):
somma_naturali(n): integer
integer
var n,
var n, i,i, somma_parziale,
somma_parziale, somma_finale:
somma_finale: integer
integer
somma_parziale
somma_parziale := := 00
for
for i=1,n
i=1,n do do
somma_parziale
somma_parziale := := somma_parziale
endfor
endfor
somma_finale
somma_finale := := somma_parziale
somma_parziale
return
return somma_finale
somma_finale
end
end
function
integer
var
var n,
n, i,i, somma:
somma: integer
integer
somma
somma := := 00
for
versione finale
for i=1,n
i=1,n do do
somma
somma := := somma
somma ++ ii
endfor
endfor
return somma
return somma
end
end
sequenza computazionale (n=5)

somma:=0+1; somma:=1+2; somma:=3+3;
somma:=6+4; somma:=10+5
function
integer
var
var n,
n, i,i, somma:
somma: integer
integer
somma
somma := := 00 nn
for
for i=1,n
i=1,n do do addizioni
addizioni
somma
somma := := somma
somma ++ ii
endfor
endfor
return somma
return somma
end
end
la sequenza computazionale (in questo caso
operazioni di addizione) è costituita da n addizioni
l’algoritmo
l’algoritmo ha
ha un
un costo di nn addizioni
costo di addizioni
approccio
incrementale
la soluzione è costruita risolvendo una sequenza di

problemi dello stesso tipo, ma incrementando ogni
volta la difficoltà (dimensione) del problema
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
a ogni passo, la soluzione dell’istanza del

problema da risolvere (a quel passo) è costruita a
partire dalla soluzione dell’istanza precedente
richiami
formula
formula (chiusa)
(chiusa) per
per ilil calcolo
calcolo della
della
somma
somma dei
dei primi
primi nn numeri
numeri naturali
nn 1
naturali
s 1 2 3 ! n { ¦ i
n
i 1 2
n n 1 10 10 1
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
10 11
55
2 2 2
formula
formula di
di Gauss
Gauss
richiami formula
formula didi Gauss
Gauss
formula
formula (chiusa)
(chiusa) per
per ilil calcolo
calcolo della
della
3 ! n 1 n
somma
somma dei
dei primi
primi nn numeri
numeri naturali
naturali
s 1 2
n n 1 n 2 ! 2 1
+
n 1 n 1 n 1 ! n 1 n 1
s
2s
nn 1
n
nn 1
2s
s
2
problema:
calcolo della sommatoria (detta armonica)
¦ 1 !
n
1 1 1 1
S
i 1 i 2 3 n

dato di output: il numero S (variabile somma)
sommare l'addendo i-simo (cioè 1/i)
alla somma degli (i-1) addendi precedenti
function
function somma_armonica(n):
somma_armonica(n): real
real nn
var
var n,
n, i:i: integer
integer addizioni
addizioni ee
var
var somma
somma :: real real nn
somma
somma := := 0.0
0.0 divisioni
divisioni
for
for i=1,n
i=1,n do do
somma
somma := := somma
somma ++ 1.0/float(i)
1.0/float(i)
endfor
endfor
return
return somma
somma
end
end

somma:=0+1/1; somma:=1+1/2;
somma:=1.5+1/3; somma:=1.833+1/4;
somma:=2.083+1/5
Titolo modulo : Ancora sul calcolo di somme e prodotti [02-T]
Sviluppo di algoritmi per il calcolo di sommatorie e produttorie
Argomenti trattati:
9 algoritmo incrementale per sommatorie generiche
9 algoritmo incrementale per il fattoriale

richiamo costruire
costruire la
la soluzione
attraverso
incrementi
successivi
della
della difficoltà
difficoltà del
del problema
problema
approccio
incrementale
function
integer
var n,
var n, i,i, somma:
somma: integer
integer
somma
somma := := 00
for
for i=1,n
i=1,n do do
somma
somma := := somma
somma ++ ii
endfor
endfor
return somma
return somma
end
end
problema:
calcolo della sommatoria
¦ 1 2 2 ! 2
n
1 1 1 1
v 2
i 1 i 2 3 n

dato di output: il numero v (variabile somma)
sommare l'addendo i-simo (cioè 1/i^2)
¦
nn
1 2 2 ! 2
n
1 1 1 1
v 2 addizioni
addizioni ee
i 1 i 2 3 n
2n
2n
function
function somma_quadr_rec(n):
somma_quadr_rec(n): real
real prodotti
prodotti
var
var n,
n, i:i: integer
integer (molt.,
(molt., div)
div)
var somma:
var somma: real real
somma
somma := := 0.0
0.0
for
for i=1,n
i=1,n do do
somma
somma := := somma
somma ++ 1.0/float(i^2)
1.0/float(i^2)
endfor
endfor
return
return somma
somma
end
end
il calcolo del quadrato di un numero si effettua

mediante una moltiplicazione
problema:
calcolo della sommatoria generica
¦addendo addendo1 addendo2 addendo3 ! addendon

n
i
i 1

dato di output: il valore della sommatoria (variabile
somma)
sommare l'addendo i-simo (da calcolare)
function
function sommatoria(n):
sommatoria(n): real
real
var
var n,
n, i:i: integer
integer
var somma
var somma :: real real
somma
somma := := 0.0
0.0
for
for i=1,n
i=1,n do do
somma
somma := := somma
somma ++ valore di addendo
valore di addendoii
endfor
endfor
return somma
return somma
end
end
espressione, function,…. per il calcolo del valore

dell’i-simo addendo della sommatoria
function
function sommatoria(n):
sommatoria(n): real real
var
var n,
n, i:i: integer
integer
var somma,
var somma, addendo
addendo :: real
real
somma
somma := := 0.0
0.0
for
for i=1,n
i=1,n do do
addendo
addendo := := valore di addendo
valore di addendoii
somma
somma := := somma
somma ++ addendo
addendo
endfor
endfor
return
return somma
somma
end
end
espressione, function,…. per il calcolo del valore

dell’i-simo addendo della sommatoria
problema: calcolo del fattoriale n ! 1 2 3 ! n
di un intero 0! 1 , 1! 1
dato di output: il numero n! (variabile fatt)

moltiplicare il numero i (il fattore i-simo
dei prodotti) per il prodotto degli (i-1)
numeri precedenti
variabile
fatt
n! 1 2 3 ! n 0! 1 , 1! 1
function
function fattoriale(n):
fattoriale(n): integer
integer
var n,
var n, fatt:
fatt: integer
integer
fatt :=
fatt := 11 n-1
n-1
if
if n>1
n>1 then
then prodotti
for prodotti
for i=2,n
i=2,n do
do
fatt
fatt :=:= fatt
fatt ** ii
endfor
endfor
endif
endif
return fatt
return fatt
end
end
fatt:=1; fatt:=1*2; fatt:=2*3; fatt:=6*4;
fatt:=24*5
n! 1 2 3 ! n 0! 1 , 1! 1
function
function fattoriale(n):
fattoriale(n): integer
integer
var n,
var n, fatt:
fatt: integer
integer
fatt :=
fatt := 11 n-1
n-1
if
if n>1
n>1 then
then prodotti
for prodotti
for i=2,n
i=2,n do
do
fatt
fatt :=:= fatt
fatt ** ii
endfor
endfor
endif
endif
return fatt
return fatt
end
end
la sequenza computazionale (in questo caso
operazioni di prodotto) è costituita da n-1 prodotti
l’algoritmo
l’algoritmo ha
ha un
un costo di n-1
costo di n-1 prodotti
prodotti
Titolo modulo : Algoritmo per la determinazione di elementi

estremi (dati esterni) [03-T]
Sviluppo di algoritmi per la determinazione del massimo e del

minimo in un insieme (esterno) di dati di input
Argomenti trattati:
9 generalizzazione dell’idea “incrementale”
9 algoritmo incrementale per la determinazione del massimo
9 algoritmo incrementale per la determinazione del minimo
9 algoritmo incrementale per la determinazione del massimo e
del minimo

problema:
calcolo dell'elemento massimo di un insieme di n dati
forniti sul supporto esterno di input
dati di input: il numero n (variabile n),gli n numeri

(da immettere uno dopo l’altro da tastiera,
senza memorizzarli tutti)
dato di output: il massimo (variabile massimo)
9 leggere da tastiera un numero alla volta,

9 utilizzarlo
9 eliminarlo
problema:

dato di output: il massimo (variabile massimo)
operazione ripetuta (al generico passo i): leggere
un numero da tastiera;
calcolare il massimo tra il numero inserito (il
numero i-simo) e il massimo degli (i-1) numeri
precedenti variabile
massimo
problema:
8 5 1 -12 21 4 7 32 -1 3
da
tastiera
8
massimo
problema:
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
8
massimo
problema:
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
8
massimo
problema:
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
8
massimo
problema:
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
8
massimo
problema:
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
21
massimo
problema:
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
21
massimo
problema:
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
21
massimo
problema:
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
21
massimo
problema:
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
32
massimo
problema:
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
32
massimo
problema:
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
32
massimo
aggiornamento della variabile massimo all’interno
di ogni passo: calcolo del massimo tra il numero
letto a quel passo (variabile numero_letto) e il
massimo parziale (variabile massimo)
if
if numero_letto
numero_letto >> massimo
massimo
then
then
massimo
massimo :=
:= numero_letto
numero_letto
endif
endif
program
program calcolo_massimo
calcolo_massimo
var
var numero_letto,
numero_letto, massimo:
massimo: real
real
var
var n,n, i:i: integer
integer
read
read n,numero_letto
n,numero_letto n-1
massimo
n-1
massimo := := numero_letto
numero_letto confronti
confronti
for
for i=2,n
i=2,n do do
read
read numero_letto
numero_letto
if
if numero_letto
numero_letto >> massimo
massimo then
then
massimo
massimo := := numero_letto
numero_letto
endif
endif
endfor
endfor
print massimo
print massimo
end
end
calcolo dell'elemento minimo di un insieme di n dati
program
program calcolo_minimo
calcolo_minimo
var
var numero_letto,
numero_letto, minimo:
minimo: real
real
var
integer
read
read n,numero_letto
n,numero_letto n-1
n-1
minimo := numero_letto
minimo := numero_letto confronti
confronti
for i=2,n
for i=2,n do do
read
read numero_letto
numero_letto
if
if numero_letto
numero_letto << minimo
minimo then
then
minimo
minimo := := numero_letto
numero_letto
endif
endif
endfor
endfor
print minimo
print minimo
end
end
problema:
calcolo dell'elemento massimo e dell’elemento
minimo di un insieme di n dati

dati di output: il massimo (variabile max), il minimo
(variabile min)
9 leggere da tastiera un numero alla volta,

9 utilizzarlo
9 eliminarlo
9 non è ammessa una seconda rilettura
8 5 1 -12 21 4 7 32 -1 3
max min
8 5 1 -12 21 4 7 32 -1 3
da
tastiera
8 8
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
8 8
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
8 5
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
8 5
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
8 1
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
8 1
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
8 -12
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
8 -12
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
21 -12
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
21 -12
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
21 -12
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
21 -12
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
32 -12
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
32 -12
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
32 -12
max min
8 5 1 -12 21 4 7 32 -1 3
da tastiera,
confronto
32 -12
max min
aggiornamento delle variabili max e min a ogni passo:
calcolo del massimo e del minimo tra il numero letto a
quel passo (variabile numero_letto) e il massimo e il
minimo parziale (variabili max H min)
if
if numero_letto
numero_letto >> max
max
then
then
max
max :=:= numero_letto
numero_letto
else
else if
if numero_letto
numero_letto << min
min then
then
min
min :=
:= numero_letto
numero_letto
endif
endif
endif
endif
program
program calcolo_massimo_minimo
calcolo_massimo_minimo
var
var numero_letto,
numero_letto, max, max, min:
min: real
real
var
integer 2(n-1)
2(n-1)
read
read n,numero_letto
n,numero_letto
max confronti
confronti
max := := numero_letto
numero_letto
min (al
(al più)
più)
min :=:= numero_letto
numero_letto
for
for i=2,n
i=2,n do do
read numero_letto
read numero_letto
if
if numero_letto
numero_letto >> max max then
then
max
numero_letto
else
else if if numero_letto
numero_letto << min
min then
then
min
min :=
:= numero_letto
numero_letto
endif
endif
endif
endif
endfor
endfor
print max,
print max, min min
end
end
program
calcolo_massimo_minimo
var
var numero_letto,
numero_letto, max, max, min:
min: real
real
var
integer 2n-2
2n-2
read
read n,numero_letto
n,numero_letto
max confronti
confronti
numero_letto
min (al
(al più)
più)
min :=:= numero_letto
numero_letto
for
for i=2,n
i=2,n do do
read numero_letto
read numero_letto
if
if numero_letto
numero_letto >> max max then
then
max
numero_letto
else
else if if numero_letto
numero_letto << min
min then
then
min
min :=
:= numero_letto
numero_letto
endif
endif
endif
endif
endfor
endfor
print max,
print max, min min
end
end
Titolo modulo : Algoritmo per la determinazione

dell’appartenenza di un valore a un insieme (esterno) [04-T]
Sviluppo di algoritmi per la determinazione dell’appartenenza di un

valore a un insieme di dati di input esterni (algoritmo di search)
Argomenti trattati:
9 generalizzazione dell’idea “incrementale”
9 algoritmo incrementale per la determinazione dell’appartenenza
9 chiave di ricerca e ricerca sequenziale

problema:
determinare l’appartenenza di un dato a un insieme
assegnato di n dati (search), forniti sul dispositivo
esterno di input
dati di input: dato da ricercare (variabile chiave), il
numero n (variabile n), gli n dati (GD
LPPHWWHUHXQRGRSROಬDOWURGDWDVWLHUDVHQ]D
PHPRUL]]DUOLWXWWL)
dato di output: true (la chiave appartiene all’insieme)
oppure false (la chiave non appartiene all’insieme)
(variabile esito_ricerca)
9 leggere da tastiera un dato alla volta
9 utilizzarlo
9 eliminarlo
problema:
esterno di input
costrutto ripetitivo: repeat

leggere un dato da tastiera (l'i-simo dato),
confrontare il dato con chiave
predicato di uscita: successo nel confronto (il
risultato di un confronto è il valore della variabile
esito_ricerca ) oppure completamento
dell'esame dell’insieme dei dati
esterno di input
b g y r k p a e t a h
da
tastiera,
confronto
k false
chiave esito_ricerca
esterno di input
da tastiera,
confronto
k false
esterno di input
da tastiera,
confronto
k false
esterno di input
da tastiera,
confronto
k false
esterno di input
da tastiera,
confronto
k false
esterno di input
da tastiera,
confronto
k true
program
program ricerca_sequenziale
ricerca_sequenziale
var
var chiave,dato_letto:
chiave,dato_letto: character
character
var n,
var n, i:i: integer
integer
var esito_ricerca:
var esito_ricerca: logical
logical
read
read chiave,n
chiave,n
ii :=
:= 00 nn
esito_ricerca
esito_ricerca := := false
false confronti
confronti (chiave-dato)
(chiave-dato)
repeat
repeat (al
(al più)
più)
read dato_letto
read dato_letto
ii :=
:= i+1
i+1
if
if chiave
chiave == dato_letto
dato_letto thenthen
esito_ricerca
esito_ricerca := := true
true
endif
endif
until
until esito_ricerca
esito_ricerca or or ii == nn
print
print esito_ricerca
esito_ricerca
end
end
program
ricerca_sequenziale
var
var chiave,dato_letto:
chiave,dato_letto: character
character
var n,
var n, i:i: integer
integer
var esito_ricerca:
logical
read
read chiave,n
chiave,n
ii :=
:= 00
repeat
repeat
read dato_letto
read dato_letto
ii :=
:= i+1
i+1
until
until chiave=dato_letto
chiave=dato_letto or or i=n
i=n
if
if chiave=dato_letto
chiave=dato_letto then then
esito_ricerca
esito_ricerca :=:= true
true
else
else
esito_ricerca
esito_ricerca :=:= false
false
endif
endif
print esito_ricerca
print esito_ricerca
end
end
Titolo modulo : Algoritmi per somme di potenze e per il

massimo comun divisore [05-AT]
Sviluppo di algoritmi per il calcolo di particolari sommatorie e per

il massimo comun divisore
Argomenti trattati:
9 algoritmi per il calcolo di somme a segni alterni
9 algoritmo per il calcolo di somme di potenze
9 algoritmo di Euclide per il mcd

1
¦
i
problema: n
2i 1
calcolo della sommatoria z
1
i 1
!
n
1 1 1
2n 1
z
3 5 7

dato di output: il numero z (variabile somma)
sommare l'addendo i-simo alla somma
degli (i-1) addendi precedenti
1
¦
i
problema: n
2i 1
i 1
function
function somma_alterni(n):
somma_alterni(n): real
real
var n,i: integer 2n
2n somme
somme
var n,i: integer
var somma,addendo:
var somma,addendo: real real 2n
2n prodotti
prodotti
somma
somma := := 0.0
0.0 nn potenze
potenze
for
for i=1,n
i=1,n dodo
addendo
addendo := := float((-1)î)/(2.0*float(i)+1.0)
float((-1)î)/(2.0*float(i)+1.0)
somma
somma := := somma
somma ++ addendo
addendo
endfor
endfor
return somma
return somma
end
end
il calcolo di una potenza i richiede i-1 prodotti

1
¦
i
problema: n
2i 1
i 1
function
real
var
var n,i:
n,i: integer
integer 2n
2n somme
somme
var somma,addendo:
var somma,addendo: real real 22-n)/2 +2n prodotti
somma := 0.0 (n
(n -n)/2 +2n prodotti
somma := 0.0
for
for i=1,n
i=1,n dodo
addendo
addendo := := float((-1)î)/(2.0*float(i)+1.0)
float((-1)î)/(2.0*float(i)+1.0)
somma
somma := := somma
somma ++ addendo
addendo
endfor
endfor
return somma
return somma
end
end
ilil numero
numero complessivo
complessivo di
di prodotti
prodotti per
per le
le potenze
potenze èè
0+1+2+3
0+1+2+3 +...+n-1=n*(n-1)/2
+...+n-1=n*(n-1)/2
1
¦
i
problema: n
2i 1
i 1
idea valore assoluto dell’addendo

addendo
addendo :=
:= 1.0/(2.0*float(i)+1.0)
1.0/(2.0*float(i)+1.0)
somma :=
somma := somma+segno*addendo
somma+segno*addendo
segno è una variabile il cui valore è +1 oppure -1

e consente di rappresentare il cambio di segno in
modo immediato
segno
segno :=
:= -segno
-segno
1
¦
i
problema: n
2i 1
i 1
function
real
var
var n,i:
n,i: integer
integer
var somma,addendo,segno:
var somma,addendo,segno: real real
somma :=
somma := 0.0 0.0 2n
2n somme
somme
segno
segno :=:= -1.0
-1.0 3n
3n prodotti
prodotti
for
for i=1,n
i=1,n dodo
addendo
addendo := := 1.0/(2.0*float(i)+1.0)
1.0/(2.0*float(i)+1.0)
somma
somma := := somma+segno*addendo
somma+segno*addendo
segno :=
segno := -segno
-segno
endfor
endfor
return somma
return somma
end
end
¦
problema: calcolo della sommatoria n
i
di potenze (detta geometrica) x
i 0
g 1 x x 2
x 3
! x n
dati di input: il numero n (variabile n), il numero

x (variabile x)
dato di output: il numero g (variabile somma)
sommare l'addendo i-simo (xi) alla somma
degli (i-1) addendi precedenti
¦
problema: calcolo della sommatoria n
i
di potenze (detta geometrica) x
i 0
function
function somma_potenze(x,n):
somma_potenze(x,n): real
real
var n,i: integer nn somme
somme
var n,i: integer
var x, somma: real nn potenze
potenze
var x, somma: real
somma
somma := := 1.0
1.0 nn somme
somme
for
for i=1,n
i=1,n dodo (n 22-n)/2 prodotti
(n -n)/2 prodotti
somma
somma := := somma
somma ++ xî
xî
endfor
endfor
return
return somma
somma
end
end
ilil numero
numero complessivo
complessivo di
di prodotti
prodotti èè
0+1+2+3
0+1+2+3 +...+n-1=n*(n-1)/2
+...+n-1=n*(n-1)/2
calcolare xi
quando è stato già calcolato,
al passo precedente, il numero xi-1
x i
xx i 1
conservare
conservare l’ultimo
l’ultimo
valore
valore calcolato
calcolato è un numero
della
della potenza
potenza di di xx già calcolato
calcolare xi
associare
associare alla variabile potenza_x
alla variabile potenza_x l’ultimo
l’ultimo
di xx
xx
valore
valore calcolato
calcolato della
della potenza
potenza di
i i 1
x
potenza_x
potenza_x :=
:= potenza_x
potenza_x ** xx
calcolare xi
function
function somma_potenze(x,n):
somma_potenze(x,n): real
real
var n,i:
var n,i: integer
integer
var x,
var x, somma,
somma, potenza_x:
potenza_x: real
real nn
somma
somma := := 1.0
1.0 somme
somme
potenza_x
potenza_x := := 1.0
1.0 nn
for
for i=1,n
i=1,n dodo prodotti
prodotti
potenza_x
potenza_x := := potenza_x
potenza_x ** xx
somma
somma := := somma
somma ++ potenza_x
potenza_x
endfor
endfor
return somma
return somma
end
end
problema:
calcolo del Massimo Comun Divisore di due numeri
(interi positivi)
ªª LOSL»
LOSL» JUDQGHQXPHURLQWHURFKHGLYLGHUHVWR
JUDQGHQXPHURLQWHURFKHGLYLGHUHVWR

RJQXQRGHLGXHQXPHUL
RJQXQRGHLGXHQXPHUL
MCD(30,42) = 6 MCD(50,40)=10
MCD(32,240)=16 MCD(16,23) = 1
MCD(a,b) ªª LOSL»
MCD(a,b) LOSL» JUDQGHGHLIDWWRULFRPXQLGHOOD
JUDQGHGHLIDWWRULFRPXQLGHOOD
VFRPSRVL]LRQHGLa
VFRPSRVL]LRQHGL Hb
VFRPSRVL]LRQHGLa Hb LQIDWWRULSULPL
LQIDWWRULSULPL
problema:
calcolo del Massimo Comun Divisore di due numeri
(interi positivi)
MCD(a,b) ªª LOSL»
MCD(a,b) LOSL» JUDQGHGHLIDWWRULFRPXQLGHOOD
JUDQGHGHLIDWWRULFRPXQLGHOOD
VFRPSRVL]LRQHGLa
VFRPSRVL]LRQHGL Hb
VFRPSRVL]LRQHGLa Hb LQIDWWRULSULPL
LQIDWWRULSULPL
MCD(32,240)=16
32 = 2^5 240 = 2^4 3 5
SL» JUDQGHGHL
IDWWRULFRPXQL
2^4 = 16
SURSULHW¢
SURSULHW¢ GLMCD(a,b)
GLMCD(a,b)
MCD( )
MCD(a,a)=a
MCD( )=
MCD(a,a)=a
MCD(a,b)
MCD(a,b)) == MCD(a,a-b)
MCD( MCD(
MCD(a,a-b)) == MCD(b,a-b)
MCD(
MCD(b,a-b))
a>b
a>b
MCD(a,b)
MCD(a,b)) == MCD(a,r)
MCD( MCD(a,r)) == MCD(b,r)
MCD( MCD(b,r))
MCD(
aa == qb+r
qb+r rr =
= aa mod
mod bb
VH r=0 DOORUD
VH r=0 DOORUD bb ªª MCD(a,b)
MCD(a,b)
MCD( )
$OJRULWPRGL(XFOLGH
$OJRULWPRGL(XFOLGH
a>b
a>b
FDOFRODUH
FDOFRODUH rr =
= aa mod
mod bb
VH = 00 DOORUD
VH rr = MCD ªª bb
DOORUD MCD 325 AC-265 AC
DOWULPHQWLFDOFRODUHOಬMCD
DOWULPHQWLFDOFRODUHOಬMCD GLb
GLb HH rr
FRQWLQXDUHಹ
FRQWLQXDUHಹ
ªª FRQVLGHUDWRLOSULPRDOJRULWPR
FRQVLGHUDWRLOSULPRDOJRULWPR
FRPSOHVVRGHOODVWRULDGHOOಬXRPR
FRPSOHVVRGHOODVWRULDGHOOಬXRPR
$OJRULWPRGL(XFOLGH
$OJRULWPRGL(XFOLGH
a>b
a>b
var
var a,b,r,mcd:
a,b,r,mcd: integer
integer
...
...
rr :=
:= mod(a,b)
mod(a,b)
while
while rr !=!= 00
aa :=
:= bb
bb :=
:= rr
rr :=
:= mod(a,b)
mod(a,b)
endwhile
endwhile
mcd
mcd := := bb
$OJRULWPRGL(XFOLGH
$OJRULWPRGL(XFOLGH
a>b
a>b
function
function max_com_div(a,b):
max_com_div(a,b): integer
integer
var a,b,r:
var a,b,r: integer
integer
rr :=
:= mod(a,b)
mod(a,b)
while
while rr !=
!= 00
aa :=
:= bb
bb :=
:= rr
rr :=
:= mod(a,b)
mod(a,b)
endwhile
endwhile
return bb
return
end
end
Titolo modulo : Function C per problemi aritmetici di base

[06-C]
Sviluppo di di function in C per il calcolo di somme e prodotti, ed

esempi di utilizzo
Argomenti trattati:
9 function in C per sommatorie
9 function in C per sommatorie a segni alterni
9 function in C per il fattoriale
Prerequisiti richiesti: AP-05-03-C, AP-06-02-T, AP-06-05-AT

problema:
/*
/* function
function per
per il
il calcolo
calcolo della
della somma
somma
dei
dei primi
primi nn numeri
numeri naturali
naturali */
*/
int
int somma_naturali(int
somma_naturali(int n) n)
{{
int s,i;
int s,i;
ss == 0;
0;
for
for (i(i == 1;1; ii <=
<= n;
n; i++)
i++)
ss == ss ++ i;
i;
return
return s; s;
}}
#include
#include <stdio.h>
<stdio.h>
int
somma_naturali(int n);
n);
void
void main()
main()
{{
int
int sn,n;
sn,n;
printf(“inserire
printf(“inserire il il valore
valore di
di n:
n: ”);
”);
scanf(“%d”,&n);
scanf(“%d”,&n);
sn
sn == somma_naturali(n);
somma_naturali(n);
printf(“somma
printf(“somma dei dei primi
primi %d%d naturali:
naturali: %d\n”,n,sn);
%d\n”,n,sn);
/*
/* verifica
verifica via via formula
formula didi Gauss
Gauss */
*/
printf(“verifica
printf(“verifica via via Gauss:
Gauss: %d\n”,n*(n+1)/2);
%d\n”,n*(n+1)/2);
}}
/*
/* function
function sommasomma dei
dei primi
primi nn numeri
numeri naturali
naturali */
*/
int
somma_naturali(int n) n)
{{
int
int s,i;
s,i;
ss == 0;
0;
for
for (i(i == 1;1; ii <=
<= n;
n; i++)
i++)
ss == ss ++ i;
i;
return
return s; s;
}}
function
functionsomma_armonica(n):
somma_armonica(n):real
problema: var n, i: integer
real
var n, i: integer
calcolo della somma dei reciproci dei primi n var
varsomma
somma::realreal
numeri naturali somma := 0.0
somma := 0.0
for
fori=1,n
i=1,ndodo
somma
somma :=somma
:= somma++1.0/float(i)
1.0/float(i)
endfor
endfor
returnsomma
return somma
end
end
/*
/* function
dei reciproci
reciproci dei
dei primi
primi nn
numeri
numeri naturali
naturali */
*/
float
float somma_armonica(int
somma_armonica(int n) n)
{{
float
float s; s;
int
int i;i;
ss == 0.0F;
0.0F;
for
for (i(i == 1;1; ii <=
<= n;
n; i++)
i++)
ss == ss ++ 1.0F/(float)i;
1.0F/(float)i;
return
return s; s;
}}
cast
#include
#include <stdio.h>
<stdio.h>
float
somma_armonica(int n);
n);
void
void main()
main()
{{
int n;
int n;
printf(“inserire
printf(“inserire il
il valore
valore di
di n:
n: ”);
”);
scanf(“%d”,&n);
scanf(“%d”,&n);
printf(“somma
printf(“somma armonica
armonica di
di %d
%d termini:%f\n”,
termini:%f\n”,
n,somma_armonica(n));
n,somma_armonica(n));
}}
/*
/* function
dei reciproci
reciproci dei
dei primi
primi nn
numeri
numeri naturali
naturali */
*/
float
somma_armonica(int n) n)
{{
float
float s; s;
int
int i;i;
ss == 0.0F;
0.0F;
for
for (i(i == 1;1; ii <=
<= n;
n; i++)
i++)
ss == ss ++ 1.0F/(float)i;
1.0F/(float)i;
return
return s; s;
}}
function
functionsomma_quadr_rec(n):
somma_quadr_rec(n):real
problema: var n, i: integer
real
var n, i: integer
calcolo della somma dei quadrati dei var
varsomma:
somma:real
real
reciproci dei primi n numeri naturali somma := 0.0
somma := 0.0
for
fori=1,n
i=1,ndodo
somma
somma :=somma
:= somma++1.0/float(i^2)
1.0/float(i^2)
endfor
endfor
returnsomma
return somma
end
end
/*
/* function
dei quadrati
quadrati dei
dei reciproci
reciproci dei
dei
primi
primi nn numeri
numeri naturali
naturali */
*/
float
float somma_quadr_rec(int
somma_quadr_rec(int n) n)
{{
float
float s; s;
int
int i;i;
ss == 0.0F;
0.0F;
for
for (i(i == 1;1; ii <=
<= n;
n; i++)
i++)
ss == ss ++ 1.0F/(float)(i*i);
1.0F/(float)(i*i);
return
return s; s;
}}
cast
#include
#include <stdio.h>
<stdio.h>
#include
#include <math.h>
<math.h>
float
somma_quadr_rec(int n);
n);
void
void main()
main()
{{
int
int n;
n;
printf(“inserire
il valore
valore di
di n:
n: ”);
”);
scanf(“%d”,&n);
scanf(“%d”,&n);
printf(“somma
printf(“somma quadr.
quadr. rec.
rec. di
di %d
%d termini:%f\n”,
termini:%f\n”,
n,somma_quadr_rec(n));
n,somma_quadr_rec(n));
}}
/*
/* function
dei quadrati
quadrati dei
dei reciproci
reciproci dei
dei
primi
primi nn numeri
numeri naturali
naturali */
*/
float
somma_quadr_rec(int n) n)
{{
float
float s; s;
int
int i;i;
ss == 0.0F;
0.0F;
for
for (i(i == 1;1; ii <=
<= n;
n; i++)
i++)
ss == ss ++ 1.0F/pow(i,2);
1.0F/pow(i,2);
return
return s; s;
}}
problema:
calcolo della somma di un insiemi di dati
di input (immessi da tastiera)
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
int
int n,i;
n,i;
float
float numero,s=0.0F;
numero,s=0.0F;
printf(“inserire
printf(“inserire il il numero
numero dei
dei numeri:
numeri: ”);
”);
scanf(“%d”,&n);
scanf(“%d”,&n);
for
for (i (i == 1;
1; ii <=
<= n;
n; i++)
i++)
{{
printf(“inserire
printf(“inserire %d-simo
%d-simo numero:
numero: ”,i);
”,i);
ss == ss ++ numero;
numero;
}}
printf(“somma
printf(“somma dell’insieme
dell’insieme di
di %d
%d termini:%f\n”,n,s);
termini:%f\n”,n,s);
}}
function
functionsomma_alterni(n):
somma_alterni(n):real
real
problema: var n,i: integer
var n,i: integer
1
calcolo della sommatoria a segni alterni var
varsomma,addendo,segno:
somma,addendo,segno:real
¦
real
somma :=
somma := 0.00.0
i segno
segno:= :=-1.0
-1.0
n
2i 1
for i=1,n do
for i=1,n do
z addendo
addendo:=
somma :=
:=1.0/(2.0*float(i)+1.0)
1.0/(2.0*float(i)+1.0)
somma+segno*addendo
i 1 somma := somma+segno*addendo
segno:=
segno :=-segno
-segno
endfor
endfor
returnsomma
return somma
end
end
/*
/* function
function sommatoria
sommatoria aa segni
segni alterni
alterni */
*/
float
float somma_segni_alt(int
somma_segni_alt(int n) n)
{{
float
float s=0.0F,
s=0.0F, addendo,
addendo, segno=-1.0F;
segno=-1.0F;
int
int i;
i;
for
for (i
(i == 1;
1; ii <=
<= n;
n; i++)
i++)
{{
addendo
addendo == 1.0F/(2.0F*(float)i+1.0f);
1.0F/(2.0F*(float)i+1.0f);
ss == ss ++ segno*addendo;
segno*addendo;
segno
segno == -segno;
-segno;
}}
return s;
return s;
}}
conversioni automatiche in espressioni aritmetiche
int
int i;
i; il valore dell’espressione
float
float f;
f;
i + f
espressione
ii ++ ff è di tipo float
mista
equivalente a
espressioni
miste (float)i + f
ii ** ff
il valore dell’espressione è di tipo float
ii // ff
ii == ff il valore di f trasformato in int viene assegnato a i
ff == ii il valore di i trasformato in float viene assegnato a f

conversioni automatiche in espressioni aritmetiche
int
int i,j;
i,j; i + d ha valore di tipo double (double)i+d
double
double d;
d;
float
float f;
f; f + d ha valore di tipo double (double)f+d
double
double d;
d;
espressioni ii ** dd ii // dd
hanno valore di tipo double
miste ff ** dd ff // dd
ff == i/j i/j Attenzione: divisione intera in double
i/j dd == i/j
ii == dd il valore di d trasformato in int viene assegnato a i
dd == ii il valore di i trasformato in double viene assegnato a d
ff == dd il valore di d trasformato in float viene assegnato a f
dd == ff il valore di f trasformato in double viene assegnato a d

problema: n! 1 2 3 ! n 0! 1 , 1! 1
calcolo del fattoriale di un numero naturale function
functionfattoriale(n):
fattoriale(n):integer
integer
var n, fatt: integer
var n, fatt: integer
fatt
fatt:= :=11
ififn>1
n>1then
then
int
int fattorialeI(int
fattorialeI(int n)
n) for i=2,ndo
for i=2,n
fatt
do
fatt := fatt**i i
:= fatt
float
float fattorialeF(int
fattorialeF(int n)
n) endfor
endfor
endif
endif
return
returnfatt
fatt
end
end
scrivere
scrivere un main che
un main che visualizza
visualizza
ilil fattoriale
fattoriale di
di nn calcolato
calcolato
sia
sia concon fattorialeI
fattorialeI
sia
sia concon fattorialeF
fattorialeF
per
per nn cheche varia
varia dada 11 aa 14
14
/*
/* function
function perper il
il fattoriale
fattoriale di
di nn (restituisce
(restituisce un
un int)*/
int)*/
int
int fattorialeI(int
fattorialeI(int n) n)
{{
int fatt,i;
int fatt,i;
fatt
fatt == 1;
1;
if
if (n
(n >> 1)
1)
for
for (i
(i == 2;
2; ii <=
<= n;
n; i++)
i++)
fatt
fatt == fatt
fatt ** i;
i;
return
return fatt;
fatt;
}}
/*function
/*function per per il
il fattoriale
fattoriale didi n(restituisce
n(restituisce un
un float)*/
float)*/
float
float fattorialeF(int
fattorialeF(int n) n)
{{
int
int i;
i;
float
float fatt
fatt == 1.0F;
1.0F;
if
if (n
(n >> 1)
1)
for
for (i
(i == 2;
2; ii <=
<= n;
n; i++)
i++)
fatt
fatt == fatt
fatt ** (float)i;
(float)i;
return
return fatt;
fatt;
}}
scrivere
scrivereun mainche
unmain chevisualizza
visualizzaililfattoriale
fattorialedidinncalcolato
calcolatosia
siacon fattorialeIsia
confattorialeI siacon fattorialeF per
confattorialeF pernn
che
chevaria
variada
da11aa14
14
#include
#include <stdio.h>
<stdio.h>
int
int fattorialeI(int);
fattorialeI(int);
float
float fattorialeF(int);
fattorialeF(int);
void main()
void main()
{{
int n,
int n, f_int;
f_int;
float f_float;
float f_float;
printf(“
printf(“ valore
valore di
di nn fattorialeI
fattorialeI fattorialeF\n
fattorialeF\n ”);
”);
for (n = 1; n <= 14;
for (n = 1; n <= 14; n++)n++)
{{
f_int
f_int == fattorialeI(n);
fattorialeI(n);
f_float
f_float = fattorialeF(n);
= fattorialeF(n);
printf(“%7d
printf(“%7d %15d
%15d %15.0f
%15.0f \n”,n,f_int,f_float);
\n”,n,f_int,f_float);
}}
}}
Titolo modulo : Function C per problemi applicativi di base

[07-C]
Sviluppo di di function in C per il calcolo di massimo, di minimo e

di ricerca, su insiemi di dati forniti da tastiera
Argomenti trattati:
9 programmi C per il massimo, il minimo e il massimo/minimo
9 programma C per la ricerca sequenziale
Prerequisiti richiesti: AP-05-03-C, AP-06-03-T, AP-06-04-T

problema:
calcolo dell'elemento massimo di un insieme di dati immessi da tastiera
var numero_letto, massimo: real
var numero_letto, massimo: real
#include
#include <stdio.h>
<stdio.h> var n, i: integer
var n, i: integer
read n,numero_letto
void
void main()
main() read n,numero_letto
massimo := numero_letto
for i=2,n do
/*
/* massimo
massimo di di un
un insieme
insieme didi dati
dati for i=2,n do
read numero_letto
read numero_letto
immessi da tastiera
immessi da tastiera */ */ if numero_letto > massimo then
if numero_letto > massimo then
{{ endif
endif
endfor
endfor
int n,i;
int n,i; print massimo
print massimo
end
float
float numero_letto,
numero_letto, massimo;
massimo;
end
printf(“inserire
numero dei
dei numeri
numeri (>1):
(>1): ”);
”);
scanf(“%d”,&n);
scanf(“%d”,&n);
printf(“inserire
printf(“inserire il il primo
primo numero:
numero: ”);
”);
scanf(“%d”,&numero_letto);
massimo
massimo == numero_letto;
numero_letto;
for
for (i
(i == 2;
2; ii <=
<= n;
n; i++)
i++)
{{
printf(“inserire %d-simo numero:
numero: ”,i);
”,i);
scanf(“%f”,&numero_letto);
if(numero_letto
if(numero_letto >> massimo)
massimo)
massimo == numero_letto
massimo numero_letto ;;
}}
printf(“massimo
printf(“massimo dell’insieme
dell’insieme di di %d
%d termini:%f\n”,n,massimo);
termini:%f\n”,n,massimo);
}}
problema:
calcolo dell'elemento minimo di un insieme di dati immessi da tastiera
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
/*
/* minimo
minimo didi un
un insieme
insieme didi dati
dati
immessi da tastiera
immessi da tastiera */ */
{{
int n,i;
int n,i;
float
float numero_letto,
numero_letto, minimo;
minimo;
printf(“inserire
numero dei
dei numeri
numeri (>1):
(>1): ”);
”);
scanf(“%d”,&n);
scanf(“%d”,&n);
printf(“inserire
primo numero:
numero: ”);
”);
minimo
minimo == numero_letto;
numero_letto;
for
for (i
(i == 2;
2; ii <=
<= n;
n; i++)
i++)
{{
numero: ”,i);
”,i);
if(numero_letto
if(numero_letto << minimo)
minimo)
minimo == numero_letto
minimo numero_letto ;;
}}
printf(“minimo
printf(“minimo dell’insieme
%d termini:%f\n”,n,minimo);
termini:%f\n”,n,minimo);
}}
problema:
calcolo dell'elemento massimo e dell’elemento minimo di un insieme di dati
immessi da tastiera
#include program calcolo_massimo_minimo
#include <stdio.h>
<stdio.h> var numero_letto, max, min: real
var numero_letto, max, min: real
var n, i: integer
void main()
void main() var n, i: integer
read n,numero_letto
read n,numero_letto
/*
/* massimo
massimo ee minimo
minimo didi un
un insieme
insieme didi max := numero_letto
max := numero_letto
min := numero_letto
dati
dati immessi
immessi da da tastiera
tastiera */ */
min := numero_letto
for i=2,n do
for i=2,n do
{{ read numero_letto
read numero_letto
if numero_letto > max then
int if numero_letto > max then
int n,i;
n,i; max := numero_letto
max := numero_letto
else if numero_letto < min then
float numero_letto, max,
float numero_letto, max, min; min; else if numero_letto < min then
min := numero_letto
min := numero_letto
printf(“inserire
numero dei
dei numeri
numeri (>1): ”);
(>1): endif endif
”); endif
scanf(“%d”,&n);
scanf(“%d”,&n);
endif
endfor
endfor
printf(“inserire print max, min
primo numero:
numero: ”);
”); end
print max, min
end
max
max == numero_letto
numero_letto ;; min min == numero_letto
numero_letto ;;
for
for (i
(i == 2;
2; ii <=
<= n;
n; i++)
i++)
{{
numero: ”,i);
”,i);
if(numero_letto
if(numero_letto >> massimo)
massimo)
max = numero_letto ;;
max = numero_letto
else
else if(numero_letto
if(numero_letto << min) min)
min
min == numero_letto
numero_letto ;;
}}
printf(“max
printf(“max ee min min dell’insieme
%d termini:%f
termini:%f %f\n”,n,max,min);
%f\n”,n,max,min);
}}
problema:
ricerca di una chiave in un insieme di dati immessi da tastiera
#include var chiave,dato_letto: character
#include <stdio.h>
<stdio.h> var chiave,dato_letto: character
var n, i: integer
void main()
void main() var n, i: integer
/*
/* ricerca
ricerca sequenziale
sequenziale di di una
una chiave
chiave read chiave,n
read chiave,n
in un insieme di i := 0
in un insieme di i := 0
esito_ricerca := false
dati immessi da tastiera */ esito_ricerca := false
dati immessi da tastiera */ repeat
repeat
{{ read dato_letto
read dato_letto
i := i+1
int n,i=0,esito_ricerca=0;
int n,i=0,esito_ricerca=0; i := i+1
if chiave = dato_letto then
if chiave = dato_letto then
char
char chiave,
chiave, dato_letto;
dato_letto; esito_ricerca := true
esito_ricerca := true
printf(“inserire il numero dei caratteri (>1): ”); endif
endif
printf(“inserire il numero dei caratteri (>1): ”); until esito_ricerca or i = n
scanf(“%d”,&n); until esito_ricerca or i = n
scanf(“%d”,&n); print esito_ricerca
print esito_ricerca
printf(“inserire
printf(“inserire la la chiave
chiave (1
(1 car):
car): ”);
”);
end
end
fflush(stdin);
fflush(stdin);
scanf(“%c”,&chiave);
scanf(“%c”,&chiave);
do
do {{
printf(“inserire
%d-simo carattere:”,i);
carattere:”,i);
fflush(stdin);
fflush(stdin);
scanf(“%c”,&dato_letto);
scanf(“%c”,&dato_letto);
i++;
i++;
if(dato_letto
if(dato_letto ==
== chiave)
chiave)
esito_ricerca
esito_ricerca == 11 ;;
}}
while
while (!(esito_ricerca
(!(esito_ricerca |||| i==n));
i==n));
printf(“"esito
printf(“"esito ricerca della chiave
ricerca della chiave %c
%c nell’insieme
nell’insieme di
di %d
%d termini:%d
termini:%d \n",
\n",
chiave,n,esito_ricerca););
chiave,n,esito_ricerca););
}}
esercizi
esercizi realizzare
realizzare le
le seguenti
seguenti function
function C
C
int maxI(int a,int b)
float maxF(float a, float b)
char maxC(char a, char b)
int minI(int a, int b)
float minF(float a, float b)
char minC(char a, char b)
che determinano il max o il min tra due dati
int e_pari(int n)
int e_dispari(int n)
che determinano se un intero è pari o è dispari
(consiglio: usare n%2)
#include
#include <stdio.h>
<stdio.h>
int
int maxI(int
maxI(int a, a, int
int b);
b);
void
void main()
main()
{{
int x,y;
int x,y;
printf(“inserire
printf(“inserire ii valori
valori dei
dei 22 numeri
numeri (int):
(int): ”);
”);
scanf(“%d
scanf(“%d %d”,&x,&y);
%d”,&x,&y);
printf(“il
printf(“il piu’piu’ grande
grande tra
tra %d
%d ee %d
%d :: %d\n”,x,y,maxI(x,y));
%d\n”,x,y,maxI(x,y));
}}
/*
/* massimo
massimo tratra due
due numeri
numeri interi
interi */ */
int maxI(int a, int
int maxI(int a, int b) b)
{{
if
if (a
(a >> b)
b)
return
return a; a;
else
else
return b;
return b;
}}
/*
/* determina
determina se se un
un numero
numero intero
intero e’
e’ pari
pari */
*/
int
int epari(int
epari(int n)n)
{{
if
if (n%2
(n%2 ==
== 0)
0)
return
return 1;1;
else
else
return
return 0;0;
}}
/*
/* determina
determina se
se un
un numero
numero intero
intero e’
e’ pari
pari */
*/
int
int epari(int
epari(int n)
n)
{{
return !(n%2);
return !(n%2);
}}
/*
/* determina
determina se
se un
un numero
numero intero
intero e’
e’ dispari
dispari */
*/
int
int edispari(int
edispari(int n)n)
{{
return
return n%2;
n%2;
}}
Titolo unità didattica: Strutture dati: array [07]
Titolo modulo : Proprietà di base degli array [01-T]
Generalità sul concetto di tipo strutturato array
Argomenti trattati:
9 nomi collettivi nei linguaggi naturali
9 l’idea di “struttura di dati”
9 tipi di dati strutturati nei linguaggi di programmazione
9 caratteristiche peculiari degli array: array 1D e 2D, size, shape
9 algoritmi per il calcolo della somma, media e varianza degli
elementi di un array
Prerequisiti richiesti: AP-02-*-T, AP-04-*-T, AP-06-02-T

RUJDQL]]D]LRQHH UHOD]LRQLWUD GDWL
nei
nei linguaggi
linguaggi naturali
naturali ee nelle
nelle applicazioni
applicazioni
reali
reali èè possibile
possibile ee utile
utile indicare
indicare con
con un
un
unico
unico nome
nome un un insieme
insieme di di dati
dati
nomi
nomi collettivi
collettivi
organizzazione
organizzazione tra
tra ii dati
dati
RUJDQL]]D]LRQHH UHOD]LRQLWUD GDWL
organizzazione
organizzazione tra
tra ii dati:
dati:
ii dati
dati aggregati
aggregati hanno
hanno una
una struttura
struttura
esistenza di
struttura
relazioni tra i dati
¾ fila di persone
varie forme di relazioni strutturali tra i dati
¾ albero genealogico
¾ tabella di nomi
GDWLRUJDQL]]DWLLQ
GDWLRUJDQL]]DWLLQ ILOD
ILOD
HVFHGDOOD HQWUDQHOOD
ILOD ILOD
ODSRVL]LRQHUHODWLYDWUDLGDWLGLSHQGHGDO
WHPSRLQFXLLOGDWRª HQWUDWRQHOODILOD
GDWLRUJDQL]]DWL
GDWLRUJDQL]]DWL
DG
DG DOEHUR
DOEHUR
ODSRVL]LRQHUHODWLYDWUDLGDWLGLSHQGHGDOODORUR
UHOD]LRQHJHUDUFKLFD
dati
dati organizzati
organizzati in
in tabelle
tabelle
HVHPSLRGLWDEHOODGLQXPHULLQWHUL

una unica riga di caselle

dati
dati organizzati
organizzati in
in tabelle
tabelle
una unica riga di caselle

9 ogni casella contiene un dato

9 tutti i dati sono dello stesso tipo
9 ogni dato è individuabile attraverso un numero
intero (indice)
non si possono scambiare due caselle, ma si può
scambiare il loro contenuto
dati
dati organizzati
organizzati in
in tabelle
tabelle

26 è l’elemento di indice 5 della tabella

scambio dell’elemento di indice 2 e
l’elemento di indice 6 della tabella
esempio: nn righe
esempio:
44righe
righe ee m
m colonne
colonne
righeee
77colonne
colonne

ogni elemento è individuato da due indici

l’indice di riga
elemento
elemento
l’indice di colonna di posto: 3,2
di posto: 3,2
tipi strutturati primitivi nei
linguaggi di programmazione
ilil tipo
tipo strutturato
strutturato array
array
l'array denota un insieme di dati organizzati a tabella
9
9 array
9
9 array
array aa una
una dimensione
dimensione (array
(array 1D)
1D)
array aa due
due dimensioni
dimensioni (array
(array 2D)
2D)
9
9 array
array aa nn dimensioni
dimensioni (array
(array nD)
nD)
tipo strutturato array nei linguaggi
di programmazione
proprietà del tipo array
9 WXWWLJOLHOHPHQWLGLXQDYDULDELOHGLWLSR
DUUD\ VRQRYDULDELOLGHOORVWHVVRWLSR
9 LOQXPHURFRPSOHVVLYRGLHOHPHQWLVL]HGL
XQDYDULDELOHGLWLSRDUUD\ ª ILVVDWR DO
PRPHQWRGHOODGLFKLDUD]LRQHH QRQª
PRGLILFDELOH
9 OಬLQVLHPHGHLYDORULDVVXPLELOLGDJOLLQGLFL
GLXQDYDULDELOHGLWLSRDUUD\ VKDSHª
ILVVDWR DOPRPHQWRGHOOD GLFKLDUD]LRQH
la dichiarazione di variabili di tipo array
9 l’identificatore della variabile array

deve specificare
9 lo shape dell’array
9 il tipo (degli elementi)

var <variabile>: array(<shape>)
of <tipo elementi>
(VHPSLR
var
var inflaz_mese:
inflaz_mese: array(1..12)
array(1..12) of
of real
real
var
var temperatura_oraria:
temperatura_oraria: array(1..24)
array(1..24) ofof
real
real
var
var rigo:
rigo: array(1..80)
array(1..80) of
of character
character
var
var psi:
psi: array(-5..7)
array(-5..7) of
of integer
integer
var
var pagina:
pagina: array(1..20,1..80)
array(1..20,1..80) of of
character
character
var
var teta:
teta: array(0..3,-1..1)
array(0..3,-1..1) ofof real
real
la specificazione di un elemento di un array
(accesso a un elemento di una variabile di

tipo array) deve indicare
9 l’indice (o gli indici) dell’elemento dell’array

<variabile>(<indice>)
ogni elemento di una variabile di tipo array 1D è

individuato dal nome della variabile seguito in
parentesi da un indice
la specificazione di un elemento di un array
(accesso a un elemento di una variabile di

tipo array) deve indicare
9 l’indice (o gli indici) dell’elemento dell’array

<variabile>(<indice_riga>,<indice_col>)
ogni elemento di una variabile di tipo array 2D è

individuato dal nome della variabile seguito in
parentesi da due indici
.04 .04 .05 .05 .03 .02 .04 .03 .03 .06 .05 .04
1 2 3 4 5 6 7 8 9 10 11 12
inflaz_mese(1)
inflaz_mese(1) :=
:= 0.05
0.05
inflaz_mese(8)
inflaz_mese(8) :=
:= inflaz_mese(8)+0.01
inflaz_mese(8)+0.01
ii :=
:= 10
10
inflaz_mese(i)
inflaz_mese(i) :=
:= (inflaz_mese(i+1)+…
(inflaz_mese(i+1)+…
inflaz_mese(i-1))/2.
inflaz_mese(i-1))/2.
.05 .04 .05 .05 .03 .02 .04 .04 .03 .04 .05 .04
1 2 3 4 5 6 7 8 9 10 11 12
problema:
calcolo della somma dei valori di un array 1D
dati di input: l'array (variabile a), il size dell’array

(variabile n)
dato di output: la somma (variabile somma
sommare l' i-simo elemento dell'array alla
somma degli (i-1) precedenti
function
function somma_array(a,n):
somma_array(a,n): realreal
var
var n,
n, i:
i: integer
integer
var somma:
var somma: real real
var
var a:
a: array(1..n)
array(1..n) of
of real
real nn
somma
somma := := 0.0
0.0 somme
somme
for
for i=1,n
i=1,n do do
somma
somma := := somma
somma ++ a(i)
a(i)
endfor
endfor
return
return somma
somma
end
end
problema:
calcolo della media aritmetica dei valori di un array 1D

(variabile n)
dato di output: la media (variabile media
sommare l' i-simo elemento dell'array alla
somma degli (i-1) precedenti
function
function media_array(a,n):
media_array(a,n): real
real
var
var n,
n, i:
i: integer
integer
var media
var media :: real
real
var
var a:
a: array(1..n)
array(1..n) ofof real
real nn
media
media := := 0.0
0.0 somme
somme
for
for i=1,n
i=1,n do do
media
media := := media
media ++ a(i)
a(i)
endfor
endfor
media
media := := media/float(n)
media/float(n)
return
return media
media
end
end
V ¦ ai P
n
problema: 1
n 1 i 1
2 2
calcolo della varianza
dei valori di un array 1D
dati di input: l'array (variabile a), media

il size dell’array (variabile n)
dato di output: la varianza (variabile varianza
¾ calcolo della media

struttura dell’algoritmo:
¾ calcolo della sommatoria

¾ divisione per n-1
V ¦ ai P
n
problema: 1
n 1 i 1
2 2
calcolo della varianza
dei valori di un array 1D
dati di input: l'array (variabile a),

media
il size dell’array (variabile n)
dato di output: la varianza (variabile varianza
sommare il quadrato della differenza tra
l'i-simo elemento dell'array e la media dei
valori dell’array alla somma dei quadrati delle
omologhe (i-1) differenze precedenti
2n
2n
function
function varianza_array(a,n):
varianza_array(a,n): real
real somme
var
somme
var n,i:
n,i: integer
integer n+1
var media, varianza :
var media, varianza : realreal n+1
var a:
var a: array(1..n)
array(1..n) of of real
real prodotti
prodotti
var media_array:
var media_array: realreal function
function ++ costo
costo di
di
media
media :=:= media_array(a,n)
media_array(a,n) media_array
media_array
varianza
varianza := := 0.0
0.0
for
for i=1,n
i=1,n dodo
varianza
varianza := := varianza+(a(i)-media)^2
varianza+(a(i)-media)^2
endfor
endfor
varianza
varianza := := varianza/float(n-1)
varianza/float(n-1)
return
return varianza
varianza
end
end
function
function varianza_array(a,n):
varianza_array(a,n): real
real
var
var n,i:
n,i: integer
integer
var
var a:a: array(1..n)
real
var
var media:
media: real
real 3*n
3*n
var
var media_array:
media_array: realreal function
function somme
somme
varianza
varianza := := -1.0
-1.0 n+2
if n>1 then
n+2
if n>1 then prodotti
varianza
varianza := := 0.0
0.0
prodotti
media
media := := media_array(a,n)
media_array(a,n)
for
for i=1,n
i=1,n do
do
varianza
varianza :=:= varianza+(a(i)-media)^2
varianza+(a(i)-media)^2
endfor
endfor
varianza
varianza := := varianza/float(n-1)
varianza/float(n-1)
endif
endif
return varianza
return varianza
end
end
Titolo modulo : Algoritmi elementari con array [02-T]
Sviluppo di algoritmi incrementali per problemi base quando i dati

sono elementi di array
Argomenti trattati:
9 algoritmo per la determinazione del massimo elemento di un array
9 algoritmo per la determinazione del minimo elemento di un array
9 algoritmo per la determinazione del massimo elemento e del suo
indice

problema:
calcolo del massimo dei valori di un array 1D

(variabile n)
dato di output: il massimo (variabile max_array
confrontare l'i-simo elemento dell'array con il
massimo dei precedenti (i-1) valori dell’array
e determinare il nuovo massimo
inizializzazione:
max_array
max_array :=
:= a(1)
a(1)
costrutto di selezione all’interno del ciclo:
if
if a(i)
a(i) >> max_array
max_array then
then
max_array
max_array :=
:= a(i)
a(i)
endif
endif
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
36
max_array
problema:
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
36
max_array
problema:
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
36
max_array
problema:
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
44
max_array
problema:
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
44
max_array
problema:
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
44
max_array
problema:
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
44
max_array
problema:
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
49
max_array
problema:
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
49
max_array
problema:
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
49
max_array
problema:
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
49
max_array
problema:
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
49
max_array
problema:
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
49
max_array
function
function massimo_array(a,n):
massimo_array(a,n): real
real
var
var n,
n, i:i: integer
integer
var
var a:
a: array(1..n)
real
var max_array:
var max_array: real real
max_array
max_array := := a(1)
a(1)
for
for i=2,n
i=2,n do do
if
n-1
n-1
if a(i)
a(i) >> max_array
max_array
then confronti
confronti
then
max_array
max_array := := a(i)
a(i)
endif
endif
endfor
endfor
return max_array
return max_array
end
end
function
function minimo_array(a,n):
minimo_array(a,n): real
real
var
var n,
n, i:i: integer
integer
var
var a:
a: array(1..n)
real
var min_array:
var min_array: real real
min_array
min_array := := a(1)
a(1)
for
for i=2,n
i=2,n do do
if
n-1
n-1
if a(i)
a(i) << min_array
min_array
then confronti
confronti
then
min_array
min_array := := a(i)
a(i)
endif
endif
endfor
endfor
return min_array
return min_array
end
end
problema:
calcolo del massimo (e del suo indice) dei valori di
un array 1D

(variabile n)
dati di output: il massimo (variabile max_array),
l’indice del massimo (variabile i_max
confrontare l'i-simo elemento dell'array con il
massimo dei precedenti (i-1) valori dell’array
e determinare il nuovo massimo e il suo indice
inizializzazione:
max_array
max_array :=:= a(1)
a(1)
i_max
i_max :=
:= 11
costrutto di selezione all’interno del ciclo:
if
if a(i)
a(i) >> max_array
max_array then
then
max_array
a(i)
i_max
i_max :=
:= ii
endif
endif
problema:
un array 1D
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
36 1
max_array i_max
problema:
un array 1D
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
36 1
max_array i_max
problema:
un array 1D
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
36 1
max_array i_max
problema:
un array 1D
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
44 3
max_array i_max
problema:
un array 1D
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
44 3
max_array i_max
problema:
un array 1D
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
44 3
max_array i_max
problema:
un array 1D
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
44 3
max_array i_max
problema:
un array 1D
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
49 6
max_array i_max
problema:
un array 1D
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
49 6
max_array i_max
problema:
un array 1D
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
49 6
max_array i_max
problema:
un array 1D
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
49 6
max_array i_max
problema:
un array 1D
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
49 6
max_array i_max
problema:
un array 1D
36 21
36 44 11
21 44 11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
49 6
max_array i_max
procedure
procedure max_val_ind(in:
max_val_ind(in: a,n;
a,n;
out:
out: max_array,i_max)
max_array,i_max)
var
var n,
n, i,i, i_max:
i_max: integer
integer
var
var a:
a: array(1..n)
real
var max_array:
max_array
max_array := := a(1)
a(1)
i_max :=
i_max := 1 1 n-1
n-1
for
for i=2,n
i=2,n do do confronti
confronti
if
if a(i)
a(i) >> max_array
max_array
then
then
max_array
a(i)
i_max :=
i_max := ii
endif
endif
endfor
endfor
end
end
Titolo modulo : Algoritmo di ricerca sequenziale in un

array [03-T]
Appartenenza di un dato a un array
Argomenti trattati:
9 algoritmo incrementale per la determinazione
dell’appartenenza di un valore a un array
9 costo dell’algoritmo di ricerca sequenziale

problema:
determinare se un dato è un elemento di un array
ricerca (search) di un dato (chiave) in un array
problema:
determinare se un oggetto appartiene a un insieme
insieme
insieme array
array 1D
1D
DSSURFFLRLQFUHPHQWDOHSHUODULFHUFD
DSSURFFLRLQFUHPHQWDOHSHUODULFHUFD
DOJRULWPRGLULFHUFDVHTXHQ]LDOH
DOJRULWPRGL
DOJRULWPRGLULFHUFDVHTXHQ]LDOH
DOJRULWPRGLULFHUFD VHTXHQ]LDOH
T
problema:
dati di input: il dato FKLDYH da ricercare (variabile

chiave), l'array (variabile a), il size dell’array
(variabile n)
dato di output: true, false
(variabile esito_confronto
costrutto ripetitivo: ciclo repeat
confrontare a(i) e chiave
se sono uguali: restituire true
se sono state esaminate tutte le componenti:
restituire false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
38 false
chiave esito_confronto
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
38 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
38 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
38 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
38 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
38 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
38 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
38 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
38 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
38 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
38 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
11 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
11 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
11 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
11 false
problema:
36 21 44
36 21 44 11
11 18
18 49
49 27
27 13
13 22
22 25
25 19
19
1 2 3 4 5 6 7 8 9 10 11
11 true
function
function appartiene(chiave,a,n):
appartiene(chiave,a,n): logicallogical
var
var n,i:
n,i: integer
integer
var
var chiave:
chiave: real
real
var esito_confronto:
var esito_confronto: logical
logical
var
real
ii :=
:= 00 nn
esito_confronto
esito_confronto := := false
false confronti
confronti
repeat
repeat (al
(al più)
più)
ii :=
:= i+1
i+1
if
if chiave
chiave == a(i)
a(i) then
then
esito_confronto
esito_confronto := := true
true
endif
endif
until esito_confronto
until esito_confronto or or ii == nn
return
return esito_confronto
esito_confronto
end
end
function
function appartiene(chiave,a,n):
appartiene(chiave,a,n): logical
logical
var
var n,i:
n,i: integer
integer
var
var chiave:
chiave: real
real
var esito_confronto:
logical
var
real
ii :=
:= 00 n+1
n+1
repeat
repeat confronti
confronti
ii :=
:= i+1
i+1 (al
(al più)
più)
until
until chiave
chiave == a(i)
a(i) or
or ii == nn
if
if chiave
chiave == a(i)
a(i) then
then
esito_confronto
esito_confronto := := true
true
else
else
esito_confronto
esito_confronto := := false
false
endif
endif
end
end
Titolo modulo : Algoritmo di fusione di array ordinati [04-T]
Fusione di due array ordinati in un nuovo array ordinato
Argomenti trattati:
9 array ordinato
9 algoritmo incrementale per la fusione di array ordinati
9 costo dell’algoritmo di fusione

problema:
fusione (merge) di due array 1D ordinati.
I due array hanno intersezione vuota.
una variabile aa di
una variabile di tipo
tipo array
array (1D)
(1D) èè ordinata
ordinata
(in
(in senso
senso crescente)
crescente) se
se
a(i) a(j)
a(i) per ii << jj
a(j) per
due variabili a, b di tipo array hanno intersezione

vuota se non hanno elementi comuni
problema:
generazione
generazione di di un
un array
array ordinato
ordinato di size nn ++ m
di size m
aa partire
partire da
da due
due array
array ordinati
ordinati di size nn ee m
di size m
caso
caso particolare
particolare del
del problema
problema di di determinazione
determinazione
dell'unione
dell'unione di
di due
due insiemi
insiemi
problema:
dati di input: il primo array ordinato (variabile a),
il size del primo array (variabile n_a), il
secondo array ordinato (variabile b), il size
del secondo array (variabile n_b)
dati di output: l’array “fuso” (variabile c)
operazione ripetuta (al generico passo i,
i=1,n_a+n_b):
determinare l’i-simo elemento dell’array c,
considerando il minore tra i due elementi
sotto esame di a e di b
i_a
a 21 33 34 47 91 93 95
b 15 18 23 27 35 41 48 50 58
i_b per ognuna delle tre variabili

array si considera un indice, che
determina l’elemento
c
sotto esame
di quella variabile array
i_c
i_a
a 21 33 34 47 91 93 95
b 15 18 23 27 35 41 48 50 58
i_b
i_c
i_a
a 21 33 34 47 91 93 95
b 15 18 23 27 35 41 48 50 58
i_b
c 15
i_c
i_a
a 21 33 34 47 91 93 95
b 15 18 23 27 35 41 48 50 58
i_b
c 15 18
i_c
i_a
a 21 33 34 47 91 93 95
b 15 18 23 27 35 41 48 50 58
i_b
c 15 18 21
i_c
i_a
a 21 33 34 47 91 93 95
b 15 18 23 27 35 41 48 50 58
i_b
c 15 18 21 23 27 33 34 35 41 47 48 50 58
i_c
dati di input: il primo array ordinato (variabile a), il
size del primo array (variabile n_a), il
secondo array ordinato (variabile b), il size
del secondo array (variabile n_b)
dati di output: l’array “fuso” (variabile c)
operazione ripetuta (al passo i_c, i_c=1,n_a+n_b):
generare l’i_c-simo elemento dell’array c
selezione tra l'elemento corrente di a e

l'elemento corrente di b
i_a indica l'elemento corrente di a e
i_b indica l'elemento corrente di b
procedure
procedure fusione(in:a,
fusione(in:a, n_a,
n_a, b,
b, n_b;
n_b; out:c)
out:c)
var
var n_a,
n_a, n_b,
n_b, i_a,
i_a, i_b,
i_b, i_c:
i_c: integer
integer
var
var a:
a: array(1..n_a)
array(1..n_a) of of character
character
var
var b:
b: array(1..n_b)
array(1..n_b) ofof character
character
var
var c:
c: array(1..n_a+n_b)
array(1..n_a+n_b) of of character
character
...
...
for
for i_c
i_c == 1,n_a+n_b
1,n_a+n_b do do
COSTRUIRE c(i_c)
COSTRUIRE c(i_c)
endfor
endfor
end
end
prima versione (da raffinare) dell’algoritmo di fusione

procedure
procedure fusione(in:
fusione(in: a, a, n_a,
n_a, b, b, n_b;
n_b; out:
out: c)
c)
var
var n_a,
n_a, n_b,
n_b, i_a,i_a, i_b,
i_b, i_c:
i_c: integer
integer
var
var a:a: array(1..n_a)
character
var
var b:b: array(1..n_b)
array(1..n_b) of of character
character
var
var c:c: array(1..n_a+n_b)
character
for
for i_c=1,n_a+n_b
i_c=1,n_a+n_b do do
if
if cici sono
sono siasia elementi
elementi didi aa sia di bb da
sia di da
prendere
prendere in in considerazione
considerazione
then
then
c(i_c)
c(i_c) èè ilil minimo
minimo tratra l’elemento
l’elemento corrente
corrente
di aa ee l’elemento
di l’elemento corrente
corrente di di bb
...
...
seconda versione (da raffinare)
dell’algoritmo di fusione
%
% uno
uno dei
dei duedue array
array èè stato
stato inserito
inserito commenti
%
% completamente
completamente in in cc
else
else if array bb non
if l’l’ array non deve
deve essere
essere più
più considerato
considerato
then
then
c(i_c)
c(i_c) :=
:= l’elemento
l’elemento corrente di aa
corrente di
else
else
c(i_c)
c(i_c) :=
:= l’elemento
l’elemento corrente
corrente di
di bb
endif
endif
endif
endif
endfor
endfor
end
end
seconda versione (da raffinare)

dell’algoritmo di fusione
procedure
fusione(in: a,a, n_a,
n_a, b, b, n_b;
n_b; out:
out: c)
c)
var
var n_a,
n_a, n_b,
n_b, i_a,
i_a, i_b,
i_b, i_c:
i_c: integer
integer
var
var a: a: array(1..n_a)
character
var
var b: b: array(1..n_b)
array(1..n_b) of of character
character
var
var c: c: array(1..n_a+n_b)
character
i_a
i_a :=:= 1,
1, i_b
i_b :=
:= 11
for
for i_c=1,n_a+n_b
i_c=1,n_a+n_b do do
if
if i_a
i_a =<
=< n_a
n_a and
and i_b
i_b =<=< n_b
n_b then
then
%
% cici sono
sono sia
sia elementi
elementi di di aa sia
sia di
di bb da
da commenti
%
% prendere
prendere in in considerazione
considerazione
if
if a(i_a)
a(i_a) << b(i_b)
b(i_b)
then
then
c(i_c)
c(i_c) :=
:= a(i_a),
a(i_a), i_a
i_a :=
:= i_a+1
i_a+1
...
...
else
else
c(i_c)
c(i_c) :=
:= b(i_b),
b(i_b), i_b
i_b :=
:= i_b+1
i_b+1
endif
endif
%
% uno
uno dei
dei due
due array
array non
non deve
deve essere
essere
%
% più
più considerato
considerato
else
else if
if i_b
i_b >> n_b
n_b then
then
%
% considerare
considerare solosolo aa
c(i_c)
c(i_c) :=
:= a(i_a),
a(i_a), i_a
i_a :=
:= i_a+1
i_a+1
else
else
%
% considerare
considerare solosolo bb
c(i_c)
c(i_c) :=
:= b(i_b),
b(i_b), i_b
i_b :=
:= i_b+1
i_b+1
endif
endif
endif
endif
endfor
endfor
end
end
costo
costodell’algoritmo
dell’algoritmodi
difusione
fusione
i_a
i_a :=:= 1,1, i_b
i_b :=
:= 11
for
for i_c=1,n_a+n_b
i_c=1,n_a+n_b do do
if
if i_a
i_a =<=< n_an_a and
and i_b
i_b =<
=< n_bn_b then
then
if
if a(i_a)
a(i_a) << b(i_b)
b(i_b) then
then
c(i_c)
c(i_c) :=:= a(i_a),
a(i_a), i_a
i_a := := i_a+1
i_a+1
else
else
c(i_c)
c(i_c) :=
:= b(i_b),
b(i_b), i_bi_b :=:= i_b+1
i_b+1
endif
endif
else
else if if i_b
i_b >> n_b
n_b then
then
c(i_c)
c(i_c) :=:= a(i_a),
a(i_a), i_a
i_a := := i_a+1
i_a+1
else
else
c(i_c)
c(i_c) :=:= b(i_b),
b(i_b), i_b
i_b :=:= i_b+1
i_b+1
endif
endif n_a+n_b
n_a+n_b
endif
endif confronti
confronti(tra
(traelementi
elementididiaaeedi
dib)
b)
endfor
endfor al
alpiù
più
Titolo modulo : Algoritmo per la determinazione

dell’uguaglianza di due array [05-T]
Uguaglianza delle componenti di ugual posto di due array 1D
Argomenti trattati:
9 definizione di uguaglianza di due array
9 algoritmo incrementale per la determinazione dell’uguaglianza
9 costo dell’algoritmo

problema:
determinare se due array 1D sono uguali
due variabili aa ee bb di
due variabili di tipo
tipo array
array (1D) (1D)
sono
sono uguali
uguali
se
se hanno
hanno lo lo stesso
stesso size
size ee
se a(i)
se a(i) == b(i)
b(i) perper tutti gli ii
tutti gli
se per un i si ha che a(i) H b(i) VRQRGLYHUVL

DOORUDL due array sono diversi;
altrimenti (cioè se per tutti gli i, a(i) e b(i)
sono uguali) i due array sono uguali
problema:
determinare se due array 1D sono uguali
dati di input: il primo array (variabile a), il

secondo array (variabile b), il size degli
array (variabile n)
dato di output: true (uguali) , false (diversi)
(variabile uguale)
confrontare a(i) e b(i)
se sono diversi o se sono state esaminate
tutte le componenti dei due array, terminare
il ciclo
a 31 26 14 12 22 27 10
b 31 26 14 12 22 18 37
uguale := true
repeat
i := i+1
if a(i) != b(i) then
true uguale := false
uguale endif
until !uguale or i=n
a 31 26 14 12 22 27 10
GLYHUVL
b 31 26 14 12 22 18 37
uguale := true
repeat
i := i+1
false uguale := false
uguale endif
a 31 26 14 12 22 27 10
b 31 26 14 12 22 27 37
uguale := true
repeat
i := i+1
uguale endif
a 31 26 14 12 22 27 10
GLYHUVL
b 31 26 14 12 22 27 37
uguale := true
repeat
i := i+1
false uguale := false
uguale endif
a 31 26 14 12 22 27 10
XJXDOL
b 31 26 14 12 22 27 10
uguale := true
repeat
i := i+1
uguale endif
versione 1
function
function uguaglianza_array(a,b,n):
uguaglianza_array(a,b,n): logical
logical
var
var n, n, i:i: integer
integer
var
var a, a, b:b: array(1..n)
array(1..n) ofof character
character
var
var uguale:
uguale: logical
logical
ii := 0 nn
:= 0
uguale := true confronti
confronti tra
tra gli
gli elementi
elementi
uguale := true
repeat degli
degli due
due array
array
repeat
ii := i+1 (al
(al più)
più)
:= i+1
if
if a(i)
a(i) != != b(i)
b(i) then
then
uguale
uguale := := false
false
endif
endif
until !uguale or
i=n uguale=false or i=n
return
return uguale
uguale
end
end
versione 2
function
logical
var
var n, n, i:i: integer
integer
var
var a, a, b:b: array(1..n)
character
var
var uguale:
uguale: logical
logical n+1
n+1
ii :=
:= 11
confronti
confronti tra
tra gli
gli
while a(i) = b(i) and
while a(i) = b(i) and i < n i < n
elementi
elementi degli
degli due
due
ii := i+1
:= i+1 array
array
endwhile
endwhile (al
(al più)
più)
if a(n) = b(n) and i=n
if a(n) = b(n) and i=n then then
uguale
uguale := := true
true
else
else
uguale
uguale := := false
false
endif
endif
return
return ugualeuguale
end
end
versione 3
function
logical
var
integer
var
var a,a, b:b: array(1..n)
array(1..n) of of character
character
var
var uguale:
uguale: logical
logical
ii :=
:= 11 nn
uguale
uguale := := true
true confronti
confronti tra
tra gli
gli
while
while uguale
uguale and and ii <=
<= nn elementi
elementi degli
degli due
due
if a(i) ! = b(i) then array
array
uguale := false (al
(al più)
più)
uguale := false
endif
endif
ii :=
:= i+1
i+1
endwhile
endwhile
return uguale
return uguale
end
end
Titolo modulo : Algoritmi di base su array 2D [06-T]
Sviluppo di algoritmi per problemi di base con dati in Array 2D
Argomenti trattati:
9 array 2D
9 algoritmo incrementale per il massimo, minimo di array 2D
9 algoritmo di somma, media di array 2D
9 accesso a porzioni di array 2D (diagonale, triangolo,..)

problema:
dati di input: l'array 2D (variabile a), il numero di

righe dell’array (variabile n) il numero di
colonne dell’array (variabile m)
dato di output: il valore massimo (variabile
max_2D)
costrutto ripetitivo: 2 cicli for innestati
operazione ripetuta (al generico passo i,j):
confrontare l’(i,j)-simo elemento
dell'array 2D con il massimo dei precedenti
valori dell’array e determinare il nuovo
massimo
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
inizializzazione
22
22 25
25 10
10 16
16 for i=1,n do
for j=1,m do
52
52 35
35 59
59 67
67 confronto con
l’elemento (i,j)
endfor
endfor
36
max_2D
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
inizializzazione
22
22 25
25 10
10 16
16 for i=1,n do
for j=1,m do
52
52 35
35 59
59 67
67 confronto con
l’elemento (i,j)
endfor
endfor
36
max_2D
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
inizializzazione
22
22 25
25 10
10 16
16 for i=1,n do
for j=1,m do
52
52 35
35 59
59 67
67 confronto con
l’elemento (i,j)
endfor
endfor
36
max_2D
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
inizializzazione
22
22 25
25 10
10 16
16 for i=1,n do
for j=1,m do
52
52 35
35 59
59 67
67 confronto con
l’elemento (i,j)
endfor
endfor
44
max_2D
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
inizializzazione
22
22 25
25 10
10 16
16 for i=1,n do
for j=1,m do
52
52 35
35 59
59 67
67 confronto con
l’elemento (i,j)
endfor
endfor
44
max_2D
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
inizializzazione
22
22 25
25 10
10 16
16 for i=1,n do
for j=1,m do
52
52 35
35 59
59 67
67 confronto con
l’elemento (i,j)
endfor
endfor
44
max_2D HFRV® YLDಹ
inizializzazione:
max_2D
max_2D :=
:= a(1,1)
a(1,1)
costrutto di selezione all’interno dei due

cicli innestati:
if
if a(i,j)
a(i,j) >> max_2D
max_2D then
then
max_2D
max_2D := := a(i,j)
a(i,j)
endif
endif
function
function massimo_a2D(a,n,m):
massimo_a2D(a,n,m): real real
var
var n,m,i,j:
n,m,i,j: integer
integer
var
var a:
a: array(1..n,1..m)
array(1..n,1..m) of of real
real
var max_2D:
var max_2D: real real
max_2D
max_2D := := a(1,1)
a(1,1)
for
for i=1,n
i=1,n dodo
for
for j=1,m
j=1,m dodo n*m
n*m
if
if a(i,j)
a(i,j) >> max_2D
max_2D thenthen confronti
confronti
max_2D
max_2D := := a(i,j)
a(i,j)
endif
endif
endfor
endfor
endfor
endfor
return max_2D
return max_2D
end
end
problema:
calcolo del minimo dei valori di un array 2D e dei
suoi indici
procedure
procedure minimo_a2D_ind(in:
minimo_a2D_ind(in: a,n,m; a,n,m; out:
out: min_2D,
min_2D,
i_min,j_min)
i_min,j_min)
var
var n,m,i,j,i_min,
n,m,i,j,i_min, j_min:
j_min: integer
integer
var
var a:
a: array(1..n,1..m)
array(1..n,1..m) of of real
real n*m
n*m
var
var min_2D:
min_2D: real real
min_2D := a(1,1)
confronti
confronti
min_2D := a(1,1)
for
for i=1,n
i=1,n dodo
for j=1,m
for j=1,m do do
if
if a(i,j)
a(i,j) << min_2D
min_2D then
then
min_2D
min_2D := := a(i,j)
a(i,j) ,, i_min
i_min :=
:= ii ,, j_min
j_min :=
:= jj
endif
endif
endfor
endfor
endfor
endfor
end
end
problema:
calcolo della media dei valori di un array 2D
function
function media_a2D(a,n,m):
media_a2D(a,n,m): realreal
var
var n,m,i,j:
n,m,i,j: integer
integer
var
var a:
a: array(1..n,1..m)
array(1..n,1..m) ofof real
real
var somma:
var somma: real
real n*m
n*m
somma
somma := := 0.0
0.0 somme
somme
for
for i=1,n
i=1,n do
do
for
for j=1,m
j=1,m dodo
somma
somma := := somma
somma ++ a(i,j)
a(i,j)
endfor
endfor
endfor
endfor
return somma/float(n*m)
return somma/float(n*m)
end
end
problema:
calcolo del massimo dei valori della diagonale
(principale) di un array 2D
36
36 21
21 44
44 11
11 diagonale principale
18
18 49
49 27
27 13
13
22
22 25
25 10
10 16
16
52
52 35
35 59
59 67
67
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
22 25 10 16 1,1
22 25 10 16
52 35 59 67 LQGLFL
52 35 59 67
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
22 25 10 16 2,2
22 25 10 16
52 35 59 67 LQGLFL
52 35 59 67
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
22 25 10 16 3,3
22 25 10 16
52 35 59 67 LQGLFL
52 35 59 67
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
22 25 10 16 4,4
22 25 10 16
52 35 59 67 LQGLFL
52 35 59 67
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
inizializzazione
22
22 25
25 10
10 16
16 for i=1,n do
confronto con
52
52 35
35 59
59 67
67 l’elemento (i,i)
endfor
XQVRORFLFORfor
36
max_diag
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
inizializzazione
22
22 25
25 10
10 16
16 for i=1,n do
confronto con
52
52 35
35 59
59 67
endfor
XQVRORFLFORfor
36
max_diag
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
inizializzazione
22
22 25
25 10
10 16
16 for i=1,n do
confronto con
52
52 35
35 59
59 67
endfor
XQVRORFLFORfor
49
max_diag
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
inizializzazione
22
22 25
25 10
10 16
16 for i=1,n do
confronto con
52
52 35
35 59
59 67
endfor
XQVRORFLFORfor
49
max_diag
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
inizializzazione
22
22 25
25 10
10 16
16 for i=1,n do
confronto con
52
52 35
35 59
59 67
endfor
XQVRORFLFORfor
49
max_diag
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
inizializzazione
22
22 25
25 10
10 16
16 for i=1,n do
confronto con
52
52 35
35 59
59 67
endfor
XQVRORFLFORfor
67
nn
max_diag FRQIURQWL
FRQIURQWL
problema:
calcolo del massimo dei valori del triangolo
superiore di un array 2D
triangolo 36 21 44 11
superiore
36 21 44 11
18
18 49
49 27
27 13
13
22
22 25
25 10
10 16
16
52
52 35
35 59
59 67
67
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
22 25 10 16 1,1 1,2 1,3 1,4
22 25 10 16
52 35 59 67 LQGLFL
52 35 59 67
LQGLFHGLULJDPLQRUHRXJXDOH
GHOOಬLQGLFHGLFRORQQD
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
22 25 10 16 2,2 2,3 2,4
22 25 10 16
52 35 59 67 LQGLFL
52 35 59 67
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
22 25 10 16 3,3 3,4
22 25 10 16
52 35 59 67 LQGLFL
52 35 59 67
problema:
36
36 21
21 44
44 11
11
18
18 49
49 27
27 13
13
22 25 10 16 4,4
22 25 10 16
52 35 59 67 LQGLFL
52 35 59 67
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
36
max_trisup
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
36
max_trisup
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
36
max_trisup
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
44
max_trisup
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
44
max_trisup
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
44
max_trisup
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
49
max_trisup
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
49
max_trisup
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
49
max_trisup
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
49
max_trisup
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
49
max_trisup
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
49
max_trisup
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
67 44 ++ 33 ++ 22 +1
+1
max_trisup FRQIURQWL
FRQIURQWL
problema:
36
36 21
21 44
44 11
11 inizializzazione
for i=1,n do
18
18 49
49 27
27 13
13 for j=i,m do
22
22 25
25 10
10 16
16 confronto con
l’elemento (i,j)
52
52 35
35 59
59 67
67 endfor
endfor
67 n*(n+1)/2
n*(n+1)/2
max_trisup FRQIURQWL
FRQIURQWL
Titolo modulo : Array in C [08-C]
Generalità sulle proprietà del tipo strutturato array in C
Argomenti trattati:
9 proprietà degli array C
9 array 1D e 2D in C
9 rappresentazione di array C
9 array e puntatori in C
9 notazione standard e notazione a puntatore
9 passaggio di array a function C

array
array 1D
1D dichiarazione
<tipo>
<tipo> <nome_array>[<size>];
<nome_array>[<size>];
float
float inflaz_mese[12];
inflaz_mese[12];
int
int temperatura_oraria[24];
temperatura_oraria[24];
char
char rigo[80];
rigo[80];
int
int psi[13];
psi[13];
<size> deve
<size> deve essere
essere una
una costante
costante oo una
una
espressione
espressione costante
costante
<size> non
<size> non può
può essere
essere una
una variabile
variabile
array
array 1D
1D dichiarazione
<tipo>
<tipo> <nome_array>[<size>];
<nome_array>[<size>];
float
float inflaz_mese[12];
inflaz_mese[12];
int
int temperatura_oraria[24];
temperatura_oraria[24];
char
char rigo[80];
rigo[80];
int
int psi[13];
psi[13];
in
in C
C gli
gli array
array sono
sono allocati
allocati staticamente
staticamente
il compilatore C associa a un array uno spazio
di memoria che dipende dal size
tale spazio di memoria non può variare
(durante l’esecuzione del programma)
int
int a[5];
a[5];
a
0 1 2 3 4
lo
lo shape
shape di
di un
un array
array C
C èè sempre
sempre
0..size-1
0..size-1
ilil primo
primo valore
valore dell’indice
dell’indice èè sempre
sempre 00
l’ultimo
l’ultimo valore
valore dell’indice
dell’indice èè sempre
sempre size-1
size-1
int
int a[5];
a[5]; loloshape
shapedidiun
unarray
arrayCCèèsempre
0..size-1
sempre
0..size-1
a
77 66 11 77 1
0 1 2 3 4
a[0]
a[0] == 77;
77;
a[3]
a[3] == a[0];
a[0];
a[2]
a[2] == 11;
11;
a[4]
a[4] == a[3]-a[2];
a[3]-a[2];
a[1]
a[1] == a[5]+a[2];
a[5]+a[2]; a[5] non esiste
array int a[5],n;
array 1D
1D n = 5;
for(i=0;
for(i=0; i<n;
i<n; i++)
i++) immissione da
tastiera di valori di
scanf(“%d”,&a[i]);
scanf(“%d”,&a[i]); un array
for(i=0;
for(i=0; i<n;
i<n; i++)
i++) visualizzazione dei
printf(“%d ”,a[i]); valori di un array
printf(“%d ”,a[i]);
le
le operazioni
operazioni su
su array
array C
C sono
sono solo
solo
componente
componente per
per componente
componente
non
non sono
sono ammesse
ammesse operazioni
operazioni che
che
agiscono
agiscono globalmente
globalmente su
su un
un intero
intero array
array
array
array 1D
1D dichiarazione-inizializzazione
int
int a[5]={22,-4,9,11,-6};
a[5]={22,-4,9,11,-6};
int
int a[]={22,-4,9,11,-6};
a[]={22,-4,9,11,-6};
all’array viene associato lo spazio di

memoria per memorizzare 5 dati di tipo int
cioè 5*sizeof(int) byte
int
int a[5];
a[5];
aa == {22,-4,9,11,-6};
{22,-4,9,11,-6};
array
array 2D
2D dichiarazione
<tipo>
<tipo> <nome_array>[<righe>][<col>];
<nome_array>[<righe>][<col>];
float
float matrice[5][5];
matrice[5][5];
int
int tabella[15][10];
tabella[15][10];
char
char pagina[40][80];
pagina[40][80];
matrice[0][0]
matrice[0][0] == 1.0;
1.0;
tabella[10][9]
tabella[10][9] == tabella[2][1];
tabella[2][1];
pagina[3][7]
pagina[3][7] == ‘p’;
‘p’;
array
array 2D
2D dichiarazione-inizializzazione
int
int matrice[2][3]=
matrice[2][3]= {{21,16,14},
{{21,16,14},
{12,22,30}};;
{12,22,30}}
int
int A[3][2]=
A[3][2]= {{31,55},
{{31,55},
{21,45},
{21,45},
{72,40}};;
{72,40}}
21 16 14 31 55
A 21 45
12 22 30
72 40
matrice
array
array nD
nD dichiarazione-inizializzazione
int
int cubo[2][3][2]=
cubo[2][3][2]= {{{21,16,14},
{{{21,16,14},
{12,22,30}},
{12,22,30}},
{{-1,-6,11},
{{-1,-6,11},
{91,96,94}}};;
{91,96,94}}}
cubo[1][1][1]
cubo[1][1][1] == 0;
0;
-116
21 -614
11
9122
12 9630
94
cubo
rappresentazione di array C
a un array vengono associate celle contigue

di memoria (con indirizzi consecutivi)
l’indirizzo di un array è l’indirizzo della prima
cella (indirizzo base dell’array)
il primo elemento dell’array (elemento di
indice 0) è memorizzato nella prima cella,
il secondo elemento dell’array (elemento di
indice 1) è memorizzato nella seconda cella,
…..
rappresentazione di array 1D
int
int a[5]={22,-4,9,11,-6};
a[5]={22,-4,9,11,-6};
a celle indirizzo
22 -4 9 11 -6 ..523
indirizzo
0 1 2 3 4
base
22 ..524
-4 ..525
indirizzo: indirizzo base + 1
indirizzo: indirizzo base + 2 9 ..526
indirizzo: indirizzo base + 3 11 ..527
indirizzo: indirizzo base + 4 -6 ..528

..529
..530
int
int matrice[2][3]=
matrice[2][3]= {{21,16,14},
{{21,16,14},
{12,22,30}};;
{12,22,30}}
celle indirizzo
21 16 14 matrice
..523
12 22 30 indirizzo
base
21 ..524
16 ..525
14 ..526
12 ..527
22 ..528
30 ..529
memorizzazione
memorizzazione per
per righe
righe ..530
array
array ee puntatori
puntatori puntatore esplicito a un array
a
pa 22 -4 9 11 -6
0 1 2 3 4
int
int a[5];
a[5];
int
int *pa;
*pa; pa contiene
pa contiene l’indirizzo
l’indirizzo
pa
pa == &a[0];
&a[0]; del
del primo
primo elemento
elemento di di aa
xx == *pa;
*pa; xx contiene
contiene ilil valore
valore di
di
a[0]
a[0]
array
array ee puntatori
puntatori puntatore esplicito a un array
a
pa 22 -4 9 11 -6
0 1 2 3 4 celle indirizzo
..523
int
int a[5];
a[5];
pa 22 ..524
int
int *pa;
*pa;
pa pa+1 -4 ..525
pa == &a[0];
&a[0];
xx == *pa; pa+2 9 ..526
*pa;
pa+3 11 ..527
*(pa+1) a[1]
*(pa+1)
pa+4 -6 ..528
*(pa+2)
*(pa+2) a[2] ..529
*(pa+3) aritmetica degli
*(pa+3) a[3]
indirizzi ..530
array
array ee puntatori
puntatori
a
a 22 -4 9 11 -6
0 1 2 3 4
int
int a[5];
a[5];
int
int *pa;
*pa; pa contiene
pa contiene l’indirizzo
l’indirizzo
pa
pa == a;
a; del
del primo
primo elemento
elemento di di aa
xx == *pa;
*pa; xx contiene
contiene ilil valore
valore di
di
a[0]
a[0]
ilil nome
nome di
di un
un array
array èè un
un PUNTATORE
PUNTATORE (costante)
(costante)
al
al suo
suo primo
primo elemento
elemento
(INDIRIZZO
(INDIRIZZO BASE
BASE dell’array)
dell’array)
il nome di un array è un PUNTATORE
array
array ee puntatori
puntatori (costante) al suo primo elemento
(INDIRIZZO BASE dell’array)
a
a 22 -4 9 11 -6
0 1 2 3 4 celle indirizzo
..523
int
int a[5];
a[5];
a 22 ..524
int
int *pa;
*pa;
pa a+1 -4 ..525
pa == a;
a;
xx == *a; a+2 9 ..526
*a; a[0]
a+3 11 ..527
*(a+1) a[1]
*(a+1)
a+4 -6 ..528
*(a+2)
*(a+2) a[2] ..529
*(a+3) aritmetica degli
*(a+3) a[3]
indirizzi ..530
un
un elemento
elemento di
di un
un array
array può
può essere
essere denotato
denotato
attraverso
attraverso un
un indice
indice (modalità
(modalità standard)
standard)
oppure attraverso
oppure attraverso un
un puntatore
puntatore
(il
(il nome
nome dell’array
dell’array oo un
un puntatore
puntatore esplicito)
esplicito)
int
int a[5]=
a[5]= {14,22,11,6,21};
{14,22,11,6,21};
int
int *pa;
*pa; pa
pa == &a[0];
&a[0];
*pa a[0]
*(a+1) a[1]
*(pa+i) è equivalente a a[i]
*(a+i) a[i]
un
un elemento
elemento di di un
un array
array può
può essere
essere denotato
9
denotato
9 attraverso
attraverso unun indice
indice (notazione
(notazione standard)
9
standard)
9 dereferenziando
dereferenziando una una espressione
espressione basatabasata
sull’aritmetica
sull’aritmetica degli
degli indirizzi
indirizzi (notazione
(notazione aa
puntatore
puntatore ))
a[0] *a
a[1] *(a+1)
a[i] *(a+i)
a[i+1] *(a+i+1)
a[2*i] *(a+2*i)
notazione standard notazione a puntatore
passaggio di array a function
ilil nome
nome di
di un
un array
array èè un
un puntatore
puntatore all’
all’
indirizzo
indirizzo base
base dell’array
dell’array
ilil passaggio
passaggio di di un
un array
array come
come parametro
parametro didi
una function èè per
una function per riferimento
riferimento (per
(per indirizzo)
indirizzo)
ee non
non per
per valore
valore
non
nonc’è
c’èbisogno
bisognodi
diusare
usareun
unpuntatore
puntatoreesplicito
esplicitoall’array
all’array
basta
bastausare
usareililnome
nomedell’array,
dell’array,sia
siaquando
quandoèè
argomento/parametro
argomento/parametrodi diinput,
input,sia
siaquando
quandoèè
argomento/parametro
argomento/parametrodi dioutput
output
notazione standard
array come argomento (nella chiamata alla function):

9 usare solo il nome dell’array
array come parametro (nell’intestazione di function):
9 usare un nome di array seguito da [ ]
passaggio di array a function Esempio
notazione standard
……
int a[10]={10,20,30,40,50,60,70,90,100};
int a[10]={10,20,30,40,50,60,70,90,100};
visualizza_aI(a,10);
……
void
void visualizza_aI(int
visualizza_aI(int v[],int
v[],int n)
n) parametri
parametridi
diinput
input
{{
int i;
int i;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
printf("%4d",v[i]);
printf("%4d",v[i]);
}}
notazione a puntatore
array come argomento (nella chiamata alla function):

9 usare solo il nome dell’array
array come parametro (nell’intestazione di function):
9 usare un puntatore
……
int a[10]={10,20,30,40,50,60,70,90,100};
int a[10]={10,20,30,40,50,60,70,90,100};
……
void
visualizza_aI(int *v,int
*v,int n)
n)
{{
int i;
int i;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
printf("%4d",*(v+i));
}}
……
int a[10]={10,20,30,40,50,60,70,90,100};
int a[10]={10,20,30,40,50,60,70,90,100};
visualizza_aI(&a[0],10);
visualizza_aI(&a[0],10);
……
void
*v,int n)
n)
{{
int i;
int i;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
}}
notazione mista
……
int a[10]={10,20,30,40,50,60,70,90,100};
int a[10]={10,20,30,40,50,60,70,90,100};
……
void
*v,int n)
n)
{{
int i;
int i;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
printf("%4d",v[i]);
printf("%4d",v[i]);
}}
la seguente chiamata è errata

(passa solo il valore di a[0] )
visualizza_aI(a[0],10);
visualizza_aI(a[0],10);
se
se si
si passa
passa ilil valore
valore di
di un
un singolo
singolo elemento
elemento
dell’array,il
dell’array,il passaggio
passaggio èè identico
identico al
al passaggio
passaggio di
di
una
una variabile
variabile scalare
scalare
(passaggio
(passaggio per per valore)
valore)
int
int a[10]={10,20,30,40,50,60,70,90,100};
a[10]={10,20,30,40,50,60,70,90,100};
int
int k;
k; int
int epari(int
epari(int x);
x);
kk == epari(a[0]);
epari(a[0]);
esercizi
esercizi realizzare
realizzare le
le seguenti
seguenti function
function C
C
parametri
parametridi
diinput
input
void
void visualizza_aD(double
visualizza_aD(double v[],int
v[],int n)
n)
9che visualizza sullo schermo un array di
double di size n
parametro
parametro parametro
parametro
di
dioutput
output di
diinput
input
void
void legge_da_tastiera_aD(double
legge_da_tastiera_aD(double v[],int
v[],int n)
n)
9che legge da tastiera un array di double di

size n
void
void visualizza_aD(double
visualizza_aD(double v[],
v[], int
int n)
n)
{{
int i;
int i;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
printf(“\n%lf",v[i]);
printf(“\n%lf",v[i]);
printf(“\n”);
printf(“\n”);
}}
void
legge_da_tastiera_aD(double v[],
v[], int
int n)
n)
{{
int
int i;
i;
printf(“\n
printf(“\n inserire
inserire %d
%d valori
valori (double)”,n);
(double)”,n);
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
{{
printf(“\n
printf(“\n inserire
inserire %d-mo
%d-mo elemento:
elemento: ",i);
",i);
scanf(“%lf”,&v[i]);
scanf(“%lf”,&v[i]);
}}
}}
Titolo modulo : Function in C per problemi di base con array

– parte 1 [09-C]
Sviluppo di function in C per algoritmi di base per array 1D ed

esempi di utilizzo
Argomenti trattati:
9 function in C per somma, media e varianza
9 function in C per la somma cumulativa
9 function in C per il massimo, il minimo e il massimo/minimo
Prerequisiti richiesti: AP-05-03-C, AP-07-02-T, AP-07-08-C

realizzare
realizzareun
unmain
mainCCche
checalcola
calcolala
lasomma
somma
esercizio
esercizio degli
deglielementi
elementidi
diun
unarray
array
#include
#include <stdio.h>
<stdio.h>
/*
/* versione
versione con
con notazione
notazione standard
standard per
per gli
gli
array
array */
*/
void
void main
main ()
()
{{
int a[]
int a[] == {2,15,1,-1,22,0,-2};
{2,15,1,-1,22,0,-2};
int
int i,somma;
i,somma;
somma
somma == 0;
0;
for
for (i=0;i<7;i++)
(i=0;i<7;i++)
somma == somma
somma somma ++ a[i];
a[i];
printf
printf (“somma
(“somma degli
degli elementi:
elementi: %d
%d \n”,somma);
\n”,somma);
printf
printf (“l’array
(“l’array e’\n”);
e’\n”);
for
for (i=0;i<7;i++)
(i=0;i<7;i++)
printf
printf (“(“ %d”,a[i]);
%d”,a[i]);
}}
realizzare
realizzareun
unmain
mainCCche
checalcola
calcolala
lasomma
somma
esercizio
esercizio degli
deglielementi
elementidi
diun
unarray
array
#include
#include <stdio.h>
<stdio.h>
void
void visualizza_aI
visualizza_aI (int
(int v[],
v[], int
int n);
n);
/*
/* versione
versione con
con notazione
notazione aa puntatore
puntatore per
per
gli
gli array
array */
*/
void
void main
main ()
()
{{
int
int a[]
a[] == {2,15,1,-1,22,0,-2};
{2,15,1,-1,22,0,-2};
int
int i,somma;
i,somma;
somma
somma == 0;
0;
for
for (i=0;i<7;i++)
(i=0;i<7;i++)
somma == somma
somma somma ++ *(a+i);
*(a+i);
printf
printf (“somma
(“somma degli
degli elementi:
elementi: %d
%d \n”,somma);
\n”,somma);
printf
e’\n”);
visualizza_aI(a,7);
visualizza_aI(a,7);
}}
realizzare
realizzareuna
unafunction
functionCCche
checalcola
calcolala
lasomma
somma
esercizio
esercizio degli
deglielementi
elementidi
diun
unarray
array
/*
/* somma
somma degli
degli elementi
elementi di
di un
un array
array int
int
–– notazione
notazione standard
standard */
*/
int
int somma_arrayI
somma_arrayI (int(int a[],
a[], int
int n)
n)
{{
int
int s=0,
s=0, i; i;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
ss == ss ++ a[i];
a[i];
return
return s; s;
}}
/*
/* somma
somma degli
degli elementi
elementi di
di un
un array
array int
int
–– notazione
puntatore */
*/
int
int somma_arrayI
somma_arrayI (int(int *a,
*a, int
int n)n)
{{
int
int s=0,
s=0, i; i;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
ss == ss ++ *(a+i);
*(a+i);
return
return s; s;
}}
realizzare
realizzareun
unmain
mainche
chechiama
chiamalalafunction
functionCC
esercizio
esercizio che
checalcola
calcolala
lasomma
sommadegli
deglielementi
elementididiun
unarray
array
#include
#include <stdio.h>
<stdio.h>
int
int somma_arrayI(int
somma_arrayI(int [[ ],
], int);
int);
void
void visualizza_aI
visualizza_aI (int
(int [],
[], int
int );
);
void
void main
main ()
()
{{
int a[]
int a[] == {2,15,1,-1,22,0,-2};
{2,15,1,-1,22,0,-2};
int
int somma;
somma;
somma
somma == somma_arrayI(a,7);
somma_arrayI(a,7);
printf
printf (“somma
(“somma degli
degli elementi:
elementi: %d
%d \n”,somma);
\n”,somma);
printf
e’\n”);
visualizza_aI(a,7);
visualizza_aI(a,7);
}}
realizzare
realizzareun
unmain
mainche
chechiama
chiamalalafunction
functionCC
esercizio
esercizio che
checalcola
calcolala
lasomma
sommadegli
deglielementi
elementididiun
unarray
array
#include
#include <stdio.h>
<stdio.h>
int
somma_arrayI(int *,
*, int);
int);
void
void visualizza_aI
visualizza_aI (int
(int [],
[], int
int );
);
void
void main
main ()
()
{{
int a[]
int a[] == {2,15,1,-1,22,0,-2};
{2,15,1,-1,22,0,-2};
int
int somma;
somma;
somma
somma == somma_arrayI(a,7);
somma_arrayI(a,7);
printf
printf (“somma
(“somma degli
degli elementi:
elementi: %d
%d \n”,somma);
\n”,somma);
printf
e’\n”);
visualizza_aI(a,7);
visualizza_aI(a,7);
}}
realizzare
realizzareun
unmain
mainche
chechiama
chiamalalafunction
functionCC
esercizio
esercizio che
checalcola
calcolala
lasomma
sommadegli
deglielementi
elementididiun
unarray
array
#include
#include <stdio.h>
<stdio.h>
int
somma_arrayI(int [],
[], int);
int);
void
visualizza_aI(int [],
[], int
int );
);
void
void main
main ()
()
{{
int a[100],i,somma,n_elem;
int a[100],i,somma,n_elem;
printf(“inserire
printf(“inserire ilil numero
numero di
di elementi
elementi (<=100):”);
(<=100):”);
scanf(“%d”,&n_elem);
for
for (i=0;i<n_elem;i++)
(i=0;i<n_elem;i++)
scanf(“%d,&a[i]);
scanf(“%d,&a[i]);
somma
somma == somma_arrayI(a,n_elem);
somma_arrayI(a,n_elem);
printf
printf (“somma
(“somma degli
degli elementi:
elementi: %d
%d \n”,somma);
\n”,somma);
printf
e’\n”);
visualizza_aI(a,n_elem);
}}
int vengono
int a[100];
a[100]; utilizzate
associa 100 solo le
celle all’array a prime 10
celle
printf(“inserire
numero di
di …
elementi
(<=100):”);
scanf(“%d”,&n_elem); 10
10
scanf(“%d,&a[i]);
scanf(“%d,&a[i]);
somma
somma == somma_arrayI(a,n_elem);
somma_arrayI(a,n_elem);
printf
printf (“somma
(“somma degli
degli elementi:
elementi: %d
%d agiscono
\n”,somma);
\n”,somma); solo sulle
printf
e’\n”); prime 10
visualizza_aI(a,n_elem); celle
}}
realizzare
realizzareuna
unafunction
functionCCche
checalcola
calcolala
lamedia
media
esercizio
esercizio degli
deglielementi
elementidi
diun
unarray
array
/*
/* media
media degli
degli elementi
elementi di
di un
un array
array double
double
–– notazione
notazione standard
standard */
*/
double
double media_arrayD(double
media_arrayD(double a[],
a[], int
int n)
n)
{{
double
double s; s;
int
int i;i;
ss == 0.0;
0.0;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
ss == ss ++ a[i];
a[i];
return
return s/n;s/n;
}}
realizzare
realizzareuna
unafunction
functionCCche
checalcola
calcolala
la
esercizio
esercizio varianza
varianzadegli
deglielementi
elementididiun
unarray
array
/*
/* varianza
varianza degli
degli elementi
elementi di
di un
un array
array double
double
–– notazione
notazione standard
standard */
*/
double
double varianza_arrayD(double
varianza_arrayD(double a[], a[], int
int n)
n)
{{
double
double s=0.0,
s=0.0, media;
media;
int
int i;i;
media
media == media_arrayD(a,n);
media_arrayD(a,n);
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
ss == ss ++ pow(a[i]
pow(a[i] –– media,2);
media,2);
return
return s/(n-1);
s/(n-1);
}}
realizzare
realizzareuna
unafunction
functionCCche
checalcola
calcolal’array
l’array
esercizio
esercizio delle
dellesomme
sommecumulative
cumulativedegli
deglielementi
elementidi diun
un
array
array
array array somme cumulative

7 9 1 8 7 16 17 25
/*
/* somma
somma cumulativa
cumulativa degli
degli elementi
elementi di
di un
un array
array double
double
–– notazione
notazione standard
standard */
*/
void
void somma_cumD(double
somma_cumD(double a[],int
a[],int n,double
n,double sum_cum[])
sum_cum[])
{{
int
int i;i; parametro di uscita
sum_cum[0]
sum_cum[0] == a[0];
a[0];
for
for (i=1;i<n;i++)
(i=1;i<n;i++)
sum_cum[i]
sum_cum[i] == sum_cum[i-1]
sum_cum[i-1] ++ a[i];
a[i];
}}
#include
#include <stdio.h>
<stdio.h>
void
somma_cumD(double [],
[], int,
int, double
double []);
[]);
void
legge_da_tastiera_aD(double [],
[], int
int );
);
void
void visualizza_aD
visualizza_aD (double
(double [],
[], int
int );
);
void
void main
main ()
()
{{
int
int n_elem;
n_elem;
double
double vet[100],vet_somme_cum[100];
vet[100],vet_somme_cum[100];
printf(“inserire
numero di
di elementi
(<=100):”);
legge_da_tastiera_aD(vet,n_elem);
legge_da_tastiera_aD(vet,n_elem);
somma_cumD(vet,n_elem,vet_somme_cum);
somma_cumD(vet,n_elem,vet_somme_cum);
visualizza_aD(vet_somme_cum,n_elem);
visualizza_aD(vet_somme_cum,n_elem);
}}
void
somma_cumD(double a[],int
a[],int n,double
n,double sum_cum[])
sum_cum[])
{{
int
int i;
i;
sum_cum[0]
sum_cum[0] == a[0];
a[0];
for
for (i=1;i<n;i++)
(i=1;i<n;i++)
sum_cum[i]
sum_cum[i] == sum_cum[i-1]
sum_cum[i-1] ++ a[i];
a[i];
}}
realizzare
realizzareun
unmain
mainCCche
chedetermina
determinaililmassimo
massimo
esercizio
esercizio elemento
elementodidiun
unarray
array
#include
#include <stdio.h>
<stdio.h>
void
void main
main ()
()
{{
int
int a[]
a[] == {2,15,1,-1,22,0,-2};
{2,15,1,-1,22,0,-2};
int
int i,max;
i,max;
max
max == a[0];
a[0];
for
for (i=1;i<7;i++)
(i=1;i<7;i++)
if(a[i]
if(a[i] >> max)
max)
max
max == a[i];
a[i];
printf
printf (“elemento
(“elemento massimo:
massimo: %d
%d \n”,max);
\n”,max);
printf
e’\n”);
for
for (i=0;i<7;i++)
(i=0;i<7;i++)
printf
printf (“(“ %d”,a[i]);
%d”,a[i]);
}}
realizzare
realizzareuna
unafunction
functionCCche
chedetermina
determinailil
esercizio
esercizio massimo
massimoelemento
elementodidiun
unarray
array
/*
/* massimo
massimo tra
tra gli
gli elementi
elementi di
di un
un array
array int
int
–– notazione
notazione standard
standard */
*/
int
int massimo_arrayI
massimo_arrayI (int
(int a[],
a[], int
int n)
n)
{{
int
int max,
max, i;
i;
max
max == a[0];
a[0];
for
for (i=1;i<n;i++)
(i=1;i<n;i++)
if(a[i]
if(a[i] >> max)
max)
max
max == a[i];
a[i];
return
return max;
max;
}}
realizzare
realizzareun
unmain
mainchechechiama
chiamala
lafunction
functionCC
esercizio
esercizio che
chedetermina
massimoelemento
elementodidiun
unarray
array
#include
#include <stdio.h>
<stdio.h>
int
int massimo_arrayI(int
massimo_arrayI(int [[ ],], int);
int);
void
void legge_da_tastiera_aI(int
legge_da_tastiera_aI(int [],[], int
int );
);
void
void visualizza_aI
visualizza_aI (int
(int [],
[], int
int );
);
void
void main
main ()
()
{{
int
int a[100],massimo,n_elem;
a[100],massimo,n_elem;
printf(“inserire
numero di
di elementi
(<=100):”);
legge_da_tastiera_aI(a,n_elem);
massimo
massimo == massimo_arrayI(a,n_elem);
massimo_arrayI(a,n_elem);
printf
printf (“il
(“il massimo
massimo tra
tra gli
gli elementi:
elementi: %d
%d \n”,massimo);
\n”,massimo);
printf
e’\n”);
}}
realizzare
realizzareuna
unafunction
functionCCche
chedetermina
determinailil
esercizio
esercizio minimo
minimoelemento
elementodidiun
unarray
array
/*
/* minimo
minimo tra
tra gli
gli elementi
elementi di
di un
un array
array int
int
–– notazione
notazione standard
standard */
*/
int
int minimo_arrayI
minimo_arrayI (int
(int a[],
a[], int
int n)
n)
{{
int
int min,
min, i;
i;
min
min == a[0];
a[0];
for
for (i=1;i<n;i++)
(i=1;i<n;i++)
if(a[i]
if(a[i] << min)
min)
min
min == a[i];
a[i];
return
return min;
min;
}}
realizzare
realizzareuna
unafunction
functionCCche
chedetermina
determinailil
esercizio
esercizio massimo
massimoeeililminimo
minimoelemento
elementodi
diun
unarray
array
/*
/* massimo
massimo ee minimo
minimo tra
tra gli
gli elementi
elementi di
di un
un
array
array int
int –– notazione
notazione standard
standard */
*/
void
void max_min_arrayI(int
max_min_arrayI(int a[],int
a[],int n,
n,
int
int *max,
*max, int
int *min)
*min)
{{
int i;
int i;
*max
*max == a[0];
a[0];
*min
*min == a[0];
a[0];
for
for (i=1;i<n;i++)
(i=1;i<n;i++)
if(a[i]
if(a[i] >> *max)
*max)
*max
*max == a[i]
a[i] ;;
else
else if(a[i]
if(a[i] << *min)
*min)
*min == a[i]
*min a[i] ;;
}}
realizzare
realizzareun
unmain
mainchechechiama
chiamalalafunction
functionCC
esercizio
esercizio che
chedetermina
massimoeeililminimo
minimoelemento
elemento
di
diun
unarray
array
#include
#include <stdio.h>
<stdio.h>
int
int max_min_arrayI(int
max_min_arrayI(int [],
[], int,
int, int
int *,
*, int
int *);
*);
void
legge_da_tastiera_aI(int [],
[], int
int );
);
void
void visualizza_aI
visualizza_aI (int
(int [],
[], int
int );
);
void
void main
main ()
()
{{
int
int a[100],massimo,minimo,n_elem;
a[100],massimo,minimo,n_elem;
printf(“inserire
il numero
numero di
di elementi
(<=100):”);
max_min_arrayI(a,n_elem,&massimo,&minimo);
max_min_arrayI(a,n_elem,&massimo,&minimo);
printf
printf (“il
(“il massimo
massimo tra
tra gli
gli elementi:
elementi: %d
%d \n”,massimo);
\n”,massimo);
printf
printf (“il
(“il minimo
minimo tra
tra gli
gli elementi:
elementi: %d
%d \n”,minimo);
\n”,minimo);
printf
e’\n”);
}}

– parte 2 [10-C]
Sviluppo di function in C per problemi di base per array 1D ed

esempi di utilizzo
Argomenti trattati:
9 function in C per la ricerca sequenziale
9 porzioni di array in C
9 utilizzo di function C su porzioni di array
Prerequisiti richiesti: AP-05-03-C, AP-07-03-T, AP-07-08-C

realizzare una function C che determina
esercizio
esercizio l’appartenenza di un dato a un insieme
(array 1D)
algoritmo
algoritmo di
di ricerca
ricerca sequenziale
sequenziale
function
function appartiene_a(x,a,n):
appartiene_a(x,a,n): logical
logical
int
int appartiene_aF(float
appartiene_aF(float chiave,float
chiave,float a[],int
a[],int n)
n)
tipo logico
simulato
parametri
di input
function
functionappartiene_a(chiave,a,n): logical
/* function che determina l’appartenenza
/* function che determina l’appartenenza
var n,i: integer
var n,i: integer
di
appartiene_a(chiave,a,n):
di un
unlogical
numero(chiave) var
varchiave: real
numero(chiave) aa unun array
array
var
(a)
chiave:
(a) di
real
di
esito_confronto:
size
size
logical
nn
--algoritmo di ricerca sequenziale--
var
vara:
--algoritmo di ricerca sequenziale-- a:array(1..n)
array(1..n)of ofreal
real
i i:= 0
:= 0
*/
*/ repeat
repeat
i i:=
:=i+1
int appartiene_aF(float chiave,float
int appartiene_aF(float chiave,floatuntil chiave
i+1
= a(i)
a[],int
a[],int
or i = n
n)
n)
until chiave = a(i) or i = n
{{ ififchiave
chiave==a(i)a(i)then
then
esito_confronto
esito_confronto:= :=true
true
int
int i;i; else
else
esito_confronto
esito_confronto:= :=false
ii == 0;
0; endif
endif
false
while(chiave != a[i] && i < return

n-1) esito_confronto
while(chiave != a[i] && i end <end n-1)esito_confronto
return
ii == i+1;
i+1;
if
if (chiave
(chiave ==== a[i])
a[i])
return
return 1;
1;
else
else
return
return 0;
0;
}}
versione 1
/*
/* function
function che
che determina
determina l’appartenenza
l’appartenenza di
di un
un
numero(chiave)
numero(chiave) aa un
un array
array (a)
(a) di
di size
size nn
--algoritmo
--algoritmo didi ricerca
ricerca sequenziale--
sequenziale--
*/
*/
int
appartiene_aF(float chiave,float
chiave,float a[],int
a[],int n)
n)
{{
int
int i;
i;
ii == 0;
0;
for(i=0;
for(i=0; i<n;
i<n; i++)
i++)
if
if (chiave
(chiave ==
== a[i])
a[i])
return
return 1;
1;
return
return 0;
0;
}}
versione 2
realizzare
realizzareun
unmain
mainche
chechiama
chiamala
lafunction
functionCCdi
di
esercizio
esercizio ricerca
ricercasequenziale
sequenziale appartiene_aF
appartiene_aF
#include
#include <stdio.h>
<stdio.h>
int
appartiene_aF(float ,float
,float [],int
[],int ); );
void
void legge_da_tastiera_aF(float
legge_da_tastiera_aF(float [], [], int
int ););
void visualizza_aF (float [], int
void visualizza_aF (float [], int ); );
void
void main
main ()
()
{{
float
float a[100],chiave;
a[100],chiave;
int
int esito_ricera,n_elem;
esito_ricera,n_elem;
printf(“inserire
numero di
di elementi
(<=100):”);
legge_da_tastiera_aF(a,n_elem);
printf(“inserire
chiave di
di ricerca:”);
ricerca:”);
scanf(“%f”,&chiave);
esito_ricerca
esito_ricerca == appartiene_aF(chiave,a,n_elem);
appartiene_aF(chiave,a,n_elem);
if
if (esito_ricerca)
(esito_ricerca) il predicato è il valore di esito_ricerca
printf
printf (“%f
(“%f appartiene
appartiene all’array
all’array \n”,chiave);
\n”,chiave);
else
else
printf (“%f
printf (“%f non
non appartiene
\n”,chiave);
printf
e’\n”);
visualizza_aF(a,n_elem);
}}
realizzare
realizzareun
unmain
mainche
chechiama
chiamala
lafunction
functionCCdi
di
esercizio
esercizio ricerca
ricercasequenziale
sequenziale appartiene_aF
appartiene_aF
#include
#include <stdio.h>
<stdio.h>
int
appartiene_aF(float ,float
,float [],int
[],int );
);
void
legge_da_tastiera_aF(float [], [], int
int );
);
void visualizza_aF (float [], int
void visualizza_aF (float [], int ); );
void
void main
main ()
()
{{
float
float a[100],chiave;
a[100],chiave;
int
int n_elem;
n_elem;
printf(“inserire
numero di
di elementi
(<=100):”);
printf(“inserire
chiave di
di ricerca:”);
ricerca:”);
scanf(“%f”,&chiave); il predicato è il valore
if
if (appartiene_aF(chiave,a,n_elem))
(appartiene_aF(chiave,a,n_elem)) restituito dalla function
printf
printf (“%f
(“%f appartiene
\n”,chiave);
else
else
printf (“%f
printf (“%f non
non appartiene
\n”,chiave);
printf
e’\n”);
}}
porzione di un array
modalità per specificare una porzione (ovvero
un insieme di elementi contigui) di un array 1D,
come argomento di chiamata a function)
4
lunghezza della porzione
a 77 66 11 -7 1 18 14 51 44 39
0 1 2 3 4 5 6 7 8 9
indirizzo base a
dell’array &a[0] porzione 0..3
realizzare
realizzareun
unmain
mainche
chechiama
chiamalalafunction
functionCC
esercizio
esercizio int
somma_arrayI(int [[ ], ], int)
int)
per
percalcola
calcolala
lasomma
sommadeideiprimi
primi44elementi
elementididiun
un
array
array(porzione
(porzione 0..3)
0..3)
#include
#include <stdio.h>
<stdio.h>
int
], int);
int);
void
void visualizza_aI
visualizza_aI (int
(int [],
[], int
int );
);
void
void main
main ()
()
{{
int
int a[]
a[] == {76,66,11,-7,1,18,14,51,44,39};
{76,66,11,-7,1,18,14,51,44,39};
int
int s;
s;
ss == somma_arrayI(a,4);
somma_arrayI(a,4); /*/* somma
somma dei
dei primi
primi
quattro
quattro elementi
elementi didi aa */
*/
printf
printf (“somma
(“somma primi
primi 44 elementi:
elementi: %d\n”,s);
%d\n”,s);
printf
e’\n”);
}}
realizzare
realizzareun
unmain
mainche
chechiama
chiamala
lafunction
functionCC
esercizio
esercizio int
massimo_arrayI(int [[ ], ], int)
int)
per
perdeterminare
determinareililmassimo
massimodei
deiprimi
primi kkelementi
elementi
di
diun
unarray
array(porzione
(porzione 0..k-1)
0..k-1)
#include
#include <stdio.h>
<stdio.h>
int
massimo_arrayI(int [[ ],], int);
int);
void
legge_da_tastiera_aI(int [], [], int
int );
);
void
void visualizza_aI
visualizza_aI (int
(int [],
[], int
int );
);
void
void main
main ()
()
{{
int
int a[100],massimo,k,n_elem;
a[100],massimo,k,n_elem;
printf(“inserire
numero didi elementi
(<=100):”);
printf(“inserire
printf(“inserire kk (<=
(<= %d):”,n_elem);
%d):”,n_elem);
scanf(“%d”,&k);
scanf(“%d”,&k);
massimo
massimo == massimo_arrayI(a,k);
massimo_arrayI(a,k); /* /* massimo
massimo dei
dei primi
primi kk elem.
elem. */
*/
printf
printf (“il
(“il massimo
massimo tra
tra ii primi
primi %d
%d elementi:
elementi: %d\n”,k,massimo);
%d\n”,k,massimo);
printf
e’\n”);
}}
porzione di un array
modalità per specificare una porzione (ovvero
un insieme di elementi contigui) di un array 1D,
come argomento di chiamata a function)
4
lunghezza della porzione
a 77 66 11 -7 1 18 14 51 44 39
0 1 2 3 4 5 6 7 8 9
indirizzo della prima

cella della porzione porzione 2..5
&a[2]
realizzare
realizzareun
unmain
mainche
chechiama
chiamala
lafunction
functionCC
esercizio
esercizio int
somma_arrayI(int [[ ], ], int)
int)
per
percalcola
calcolala
lasomma
sommadegli
deglielementi
elementidella
della
porzione 2..5 di
porzione 2..5 diun
unarray
array
#include
#include <stdio.h>
<stdio.h>
int
], int);
int);
void
void visualizza_aI
visualizza_aI (int
(int [],
[], int
int );
);
void
void main
main ()
()
{{
int a[]
int a[] == {76,66,11,-7,1,18,14,51,44,39};
{76,66,11,-7,1,18,14,51,44,39};
int
int s;
s;
ss == somma_arrayI(&a[2],4);
somma_arrayI(&a[2],4); /* /* somma
somma della
della
porzione
porzione didi lunghezza
lunghezza 44 che
che inizia
inizia da
da a[2]
a[2] */
*/
printf
printf (“somma
(“somma elementi
elementi porzione:
porzione: %d\n”,s);
%d\n”,s);
printf
e’\n”);
}}
realizzare
realizzareun
unmain
mainchechechiama
chiamalalafunction
functionCC
esercizio
esercizio int
massimo_arrayI(int [[ ], ], int)
int)
per
perdeterminare
massimodegli
deglielementi
elementidella
dellaporzione
porzione
i_ini..i_fin didiun
i_ini..i_fin unarray
array
#include
#include <stdio.h>
<stdio.h>
int
int massimo_arrayI(int [[ ],
massimo_arrayI(int ], int);
int);
void
void legge_da_tastiera_aI(int [],
legge_da_tastiera_aI(int [], int
int );
);
void visualizza_aI (int [], int
void visualizza_aI (int [], int ); );
void
void main
main ()
()
{{
int a[100],massimo,i_ini,i_fin,n_elem;
int a[100],massimo,i_ini,i_fin,n_elem;
printf(“inserire
numero di
di elementi
(<=100):”);
printf(“inserire
printf(“inserire indice
indice iniziale
iniziale porzione(<=
porzione(<= %d):”,n_elem);
%d):”,n_elem);
scanf(“%d”,&i_ini);
printf(“inserire
indice finale
finale porzione(>
porzione(> %d
%d ee <=
<= %d):”,
%d):”,
i_ini,n_elem);
i_ini,n_elem);
scanf(“%d”,&i_fin);
massimo
massimo == massimo_arrayI(&a[i_ini],i_fin-i_ini+1);
massimo_arrayI(&a[i_ini],i_fin-i_ini+1); /* /* massimo
massimo
degli
degli elementi
elementi della
della porzione
porzione i_ini
i_ini .... i_fin
i_fin */*/
printf
printf (“massimo della porzione %d .. %d: %d\n”,i_ini,i_fin, massimo);
(“massimo della porzione %d .. %d: %d\n”,i_ini,i_fin, massimo);
printf (“l’array e’\n”);
printf (“l’array e’\n”);
}}
realizzare una function C che determina il
esercizio
esercizio massimo elemento di un array e il suo indice
procedure
proceduremax_val_ind(in:
max_val_ind(in:a,n; a,n;out:
out:max_array,i_max)
max_array,i_max)
var n, i, i_max: integer
var n, i, i_max: integer
vara:
var a:array(1..n)
real
var max_array:
max_array
max_array:= :=a(1)
a(1)
i_max :=
i_max := 1 1
for
fori=2,n
i=2,ndo do
ififa(i)
a(i)>>max_array
max_array
then
then
max_array
max_array:= :=a(i)
a(i)
i_max :=
i_max := ii
endif
endif
endfor
endfor
end
end
parametri di input
void
void max_val_ind(float
max_val_ind(float a[],int
a[],int n,
n,
float
float *max,int
*max,int *i_max)
*i_max)
parametri di output
void
a[],int n,
n,
float
float *max_array,
*max_array, int
int *i_max)
*i_max)
{{
int i;
int i;
*max_array == a[0];
*max_array a[0];
*i_max
*i_max == 0;
0;
for
for (i=1;i<n;i++)
(i=1;i<n;i++)
if
if (a[i]
(a[i] >> *max_array)
*max_array)
{{
*max_array
*max_array == a[i];
a[i];
*i_max
*i_max == i;
i;
}}
}}
max_val_ind(mio_a,mio_n,&mio_max_a,&mio_i_max)
max_val_ind(mio_a,mio_n,&mio_max_a,&mio_i_max)
realizzare
realizzareun
unmain
mainche
chechiama
chiamalalafunction
functionCC
esercizio
esercizio max_val_ind per
max_val_ind perdeterminare
massimodegli
degli
elementi
elementidella
dellaporzione i_ini..i_fin didiun
porzione i_ini..i_fin unarray
arrayeeilil
suo
suoindice
indice
#include
#include <stdio.h>
<stdio.h>
void
a[],int n,float
n,float *max_array,int
*max_array,int *i_max);
*i_max);
void
void visualizza_aF(float
visualizza_aF(float [],
[], int
int );
);
void
void main
main ()
()
{{
float
float a[]={76.F,66.F,11.F,-7.F,1.F,18.F,14.F,51.f,44.f,39.F};
a[]={76.F,66.F,11.F,-7.F,1.F,18.F,14.F,51.f,44.f,39.F};
float massimo;
float massimo;
int
int i_ini,i_fin,
i_ini,i_fin, indice_max;
indice_max;
printf(“inserire
indice iniziale
iniziale porzione(<=
porzione(<= 10):”);
10):”);
printf(“inserire
indice finale
finale porzione(>%d
porzione(>%d ee <=10):”,i_ini);
<=10):”,i_ini);
max_val_ind(&a[i_ini],i_fin-i_ini+1,&massimo,&indice_max);
max_val_ind(&a[i_ini],i_fin-i_ini+1,&massimo,&indice_max);
printf
printf (“massimo
(“massimo della
della porzione
porzione %d%d ..
.. %d:
%d: %f\n
%f\n indice
indice :%d”,
:%d”,
i_ini,i_fin,massimo,indice_max);
i_ini,i_fin,massimo,indice_max);
printf
e’\n”);
visualizza_aF(a,10);
visualizza_aF(a,10);
}}
inserire indice iniziale porzione(<= 10):2
spiazzamento dell’indice inserire indice finale porzione(>2 e <=10):5

massimo della porzione 2 .. 5: 18.000000
indice :3
array :
porzione 2..5 76.000000

66.000000
11.000000
-7.000000
1.000000
18.000000
indice locale della porzione 14.000000
51.000000
44.000000
39.000000
0 1 2 3
a 77 66 11 -7 1 18 14 51 44 39
0 1 2 3 4 5 6 7 8 9
il vero valore dell’indice è

i_ini + indice_max indice assoluto

– parte 3 [11-C]
Sviluppo di function in C per problemi di base per array 1D ed

esempi di utilizzo
Argomenti trattati:
9 function in C per la fusione di array ordinati
9 function in C per la determinare l’uguaglianza di array
9 esempi di generazione di griglie 1D e campionamenti in C
Prerequisiti richiesti: AP-05-03-C, AP-07-04-T, AP-07-05-T, AP-07-07-T,

AP-07-08-C
realizzare una function C per la fusione
esercizio
esercizio di due array 1D ordinati
algoritmo
algoritmo di
di fusione
fusione (merge)
(merge) di
di array
array ordinati
ordinati
procedure
fusione(in: a,
a, n_a,
n_a, b,
b, n_b;
n_b; out:
out: c)
c)
parametri
di input
void
void fusioneC(char
fusioneC(char a[],int
a[],int n_a,char
n_a,char b[],int
b[],int n_b,
n_b,
char
char c[])
c[])
gli array non hanno

parametro valori in comune
di output
(array disgiunti)
procedure fusione(in: a, n_a, b, n_b; out: c)
void fusioneC(char a[],int
void fusioneC(char a[],int n_a,char n_a,char var b[],int
b[],int
n_a, n_b,char
n_b, i_a, i_b, i_c: integer c[])
n_b,char c[])
{{ var a: array(1..n_a) of character
var b: array(1..n_b) of character
int
int i_a=0,i_b=0,i_c;
i_a=0,i_b=0,i_c; var c: array(1..n_a+n_b) of character
i_a := 1, i_b := 1
for (i_c=0; i_c < n_a+n_b; i_c++)
for (i_c=0; i_c < n_a+n_b; i_c++)for i_c=1,n_a+n_b do
{{ if i_a =< n_a and i_b =< n_b
then
if(i_a<n_a
if(i_a<n_a && && i_b<n_b)
i_b<n_b) % ci sono sia elementi di a sia di b da
% prendere in considerazione
{{ if a(i_a) < b(i_b)
if(a[i_a] then
if(a[i_a] << b[i_b]){
b[i_b]){ c(i_c) := a(i_a), i_a := i_a+1
c[i_c]
c[i_c] == a[i_a];
a[i_a]; else
c(i_c) := b(i_b), i_b := i_b+1
ia++;}
ia++;} endif
else % uno dei due array non deve esse
else {{ % più considerato
c[i_c]
c[i_c] == b[i_b];
b[i_b]; else if i_b > n_b then
% considerare solo a
ib++;}
ib++;} c(i_c) := a(i_a), i_a := i_a+1
}} else
% considerare solo b
else
else if(i_b
if(i_b >=>= n_b)
n_b) {{ c(i_c) := b(i_b), i_b := i_b+1
endif
c[i_c] = a[i_a];
c[i_c] = a[i_a]; endif
ia++;} endfor
ia++;} end
else
else {{
c[i_c]
c[i_c] == b[i_b];
b[i_b];
ib++;}
ib++;}
}}
}}
versione 1
void
void fusioneC(char
fusioneC(char a[],int
a[],int n_a,char
n_a,char b[],b[],
int
int n_b,char
n_b,char c[])
c[])
{{
int
int i_a=0,i_b=0,i_c=0;
i_a=0,i_b=0,i_c=0;
while
while (i_a
(i_a << n_a
n_a &&
&& i_b
i_b <n_b)
<n_b)
{{
if(a[i_a] << b[i_b])
if(a[i_a] b[i_b]) viene prima usato il valore
c[i_c++]
c[i_c++] == a[i_a++];
a[i_a++]; dell’indice e poi tale valore
else viene incrementato
else
c[i_c++]
c[i_c++] == b[i_b++];
b[i_b++];
}}
while
while (i_a
(i_a << n_a)
n_a)
c[i_c++] == a[i_a++];
c[i_c++] a[i_a++];
while
while (i_b
(i_b << n_b)
n_b)
c[i_c++] == b[i_b++];
c[i_c++] b[i_b++];
}}
versione 2
realizzare una function C per determinare
esercizio
esercizio l’uguaglianza di due array 1D
function
logical
int
int uguaglianza_arrayC(char
uguaglianza_arrayC(char a[],char
a[],char b[],int
b[],int n)
n)
int
function
a[],char
function b[],int
uguaglianza_array(a,b,n):
b[],int
uguaglianza_array(a,b,n): n)
logical
n)
logical
var
varn, n,i:i:integer
integer
{{ var
vara, a,b:b:array(1..n)
array(1..n)of ofcharacter
character
var uguale: logical
int
int i=1,uguale=1;
i=1,uguale=1; var uguale: logical
i i:=
:=11
while(uguale
while(uguale && && i<n)
i<n) uguale:=
uguale :=truetrue
while
while ugualeand
uguale andi i<=<=nn
{{ ififa(i)
a(i)!=!=b(i)
b(i)then
then
uguale := false
uguale := false
if(a[i]
if(a[i] !=
!= b[i])
b[i]) endif
endif
i i:=
:=i+1
uguale
uguale == 0;
0; endwhile
i+1
endwhile
i++;
i++; return
returnuguale
uguale
end
end
}}
return
return uguale;
uguale;
}}
realizzare un main C che definisce un array
esercizio
esercizio testo e richiama la function
int uguaglianza_arrayC(char a[],
char b[],int n)
per determinare l’uguaglianza della prima metà
e della seconda metà dell’array testo
int
a[],char b[],int
b[],int n)
n)
uguaglianza_arrayC(testo,&testo[n_mezzi],n_mezzi)
inizio I inizio II lunghezza

metà metà porzioni
#include <stdio.h>
int uguaglianza_arrayC(char a[],char b[],int n);
int epari(int x);
void main()
{
char testo[]={'q','u','e','q','u','i'};
int i,n_elem, n_mezzi;
n_elem = 6;
if (epari(n_elem))
n_mezzi = n_elem/2;
else
printf("la lunghezza del testo deve essere un numero pari\n");
for(i=0;i<n_elem;i++)
printf("%c",testo[i]);
printf("\n");
if(uguaglianza_arrayC(testo,&testo[n_mezzi],n_mezzi))
printf("le due meta sono uguali");
else
printf("le due meta non sono uguali");
}
int epari(int x)
{
return !(x%2);
}
realizzare una function C che campiona su una
esercizio
esercizio griglia una funzione data come parametro
procedure
procedure campiona(in:fun,a,b,n;out:f_c)
campiona(in:fun,a,b,n;out:f_c)
realizzare un main C che richiama la function C

campiona per determinare il campionamento
su una griglia uniforme di 50 punti sull’intervallo
[S,3S] della funzione
3 sin ( x )
x 10
2
void campionaF(float fun(float),float a,

float b,int n,float f_c[]);
procedure
procedure campiona(in:fun,a,b,n;out:f_c)
campiona(in:fun,a,b,n;out:f_c)
var
var fun: real function
fun: real function
var a,b: real
var a,b: real
var
var n:
n: integer
integer
var
var f_c:
f_c: array(1..n)of
array(1..n)of realreal
var passo,p_griglia:
var passo,p_griglia: realreal
passo :=
passo := abs(b-a)/float(n-1)
abs(b-a)/float(n-1)
p_griglia
p_griglia := aa
:=
for
for i=1,n
i=1,n dodo
f_c(i):=
f_c(i):= fun(p_griglia)
3 sin ( x )
x 10
fun(p_griglia)
p_griglia :=
p_griglia := aa ++ float(i)*passo
float(i)*passo
y 2
endfor
endfor
end
end
float
float mia_fun(float
mia_fun(float x)
x)
{{
return
return (3.0F*sin(x))/(pow(x,2)+10.F);
(3.0F*sin(x))/(pow(x,2)+10.F);
}}
void campionaF(float fun(float),float a,
float b,int n,float f_c[])
{
float passo,p_griglia;
int i;
passo = (b-a)/(n-1);
p_griglia = a;
for (i=0;i<n;i++)
{
f_c[i] = fun(p_griglia);
p_griglia = a + (i+1)*passo;
}
}
float mia_fun(float x)
{
return (3.0*sin(x))/(pow(x,2.)+10.0);
}
#include <stdio.h>
#include <math.h>
void campionaF(float fun(float),float,float
,int ,float []);
float mia_fun(float );
void main()
{ SDVVDJLR GLXQD
const float pi=3.1415926F; IXQFWLRQDXQಬDOWUD
float mia_a,mio_b; IXQFWLRQ
int mio_n,i;
float mio_f_c[100];
mia_a = pi;
mio_b = 3.F*pi;
mio_n = 50;
campionaF(mia_fun,mia_a,mio_b,mio_n,mio_f_c);
for (i=0;i<mio_n;i++)
printf(" %f",mio_f_c[i]);
}

2D [12-C]
Array 2D : mappa di memorizzazione e utilizzo
Argomenti trattati:
9 mappa di memorizzazione di array 2D in C
9 passaggio di array 2D a una function C
9 function in C per la somma, il massimo e la ricerca in array 2D
9 function in C per problemi di base su porzioni di array 2D
9 function in C per il trattamento elementare di immagini

int
int matrice[2][3]=
matrice[2][3]= {{21,16,14},
{{21,16,14},
{12,22,30}};;
{12,22,30}}
celle indirizzo
21 16 14 matrice
..523
12 22 30 indirizzo
base
21 ..524
16 ..525
14 ..526
12 ..527
22 ..528
30 ..529
memorizzazione
memorizzazione per
per righe
righe ..530
0,0 0,1 0,2 0,0

0,1 prima riga
1,0 1,1 1,2
0,2
array 2D 2x3 1,0
1,1 seconda riga
1,2
indirizzo primo elemento
+1
+2 indirizzo base di un
+3 array 2D
+4 &matrice[0][0]
&matrice[0][0]
+5
int matrice[2][3];
indirizzo base di un array 2D
&matrice[0][0]
&matrice[0][0]
il nome di un array 2D non è un puntatore

costante all’indirizzo base dell’array 2D
matrice è equivalente a &matrice[0]
è un puntatore all’indirizzo base di un array di 2

puntatori, ognuno dei quali punta a un array di 3 int
un array 2D può essere considerato

un array di puntatori ad array
0,0
0,0 0,1 0,2 0,1 prima riga

0,2
1,0 1,1 1,2 1,0
array 2D 2x3 1,1 seconda riga

1,2
int
int matrice[2][3];
matrice[2][3];
matrice[1][2]
matrice[1][2]
*(&matrice[0][0]+3*1+2)
*(&matrice[0][0]+3*1+2)
*(indirizzo base
*(indirizzo base +5)
+5)
float A[4][5]
A[i][j]
A[i][j]
mappa di
memorizzazione
*(&A[0][0]+n_col*i+j)
*(&A[0][0]+n_col*i+j)
èè ilil numero
numero di di colonne
colonne
utilizzato
utilizzato nella
nella dichiarazione
dichiarazione
dell’array
dell’array 2D
2D
float A[n_rig][n_col]
A[i][j]
A[i][j]
trasformazione
trasformazione mappa di
eseguita
eseguita dal
dal memorizzazione
compilatore
compilatore
*(&A[0][0]+n_col*i+j)
*(&A[0][0]+n_col*i+j)
èè ilil numero
numero di di colonne
colonne
utilizzato
utilizzato nella
nella dichiarazione
dichiarazione
dell’array
dell’array 2D
2D
un
un elemento
elemento didi un
un array
array 2D
2D può
può essere
essere denotato
9
denotato
9 attraverso
attraverso due
due indici
indici (notazione
(notazione standard)
9
standard)
9 dereferenziando
dereferenziando la la mappa
mappa di
di memorizzazione
memorizzazione
(notazione
(notazione aa puntatore
puntatore ))
int
int M[n_rig][n_col];
M[n_rig][n_col];
M[0][0] *(&M[0][0])
M[i][j] *(&M[0][0]+n_col*i+j)
M[i][j] *(M[i]+j)
M[i][j] (*(M+i))[j]
notazione standard notazione a puntatore
un array 2D può essere considerato
un array di puntatori ad array
int
int M[4][6];
M[4][6];
M indirizzi base
array righe gli array righe
indirizzo
indirizzo
indirizzo base
M[2]
terza riga
M[2][1]
passaggio di un array 2D a una function
nella function deve essere

esplicitamente specificato il
numero delle colonne di un
parametro array,
affinché il compilatore possa generare la
corretta mappa di memorizzazione
non è necessario conoscere
il numero delle righe
passaggio di un array 2D a una function
allocazione statica
quando un array 2D appare come

parametro nell’intestazione di una
function, il numero delle colonne
deve essere esattamente uguale al
valore specificato per il numero delle
colonne nella dichiarazione
dell’argomento nel chiamante
realizzare
realizzareuna
unafunction
functionCCche
chevisualizza
visualizzagli
gli
esercizio
esercizio elementi
elementidi
diun
unarray
array2D
2D
/*
/* visualizzazione
visualizzazione degli
degli elementi
elementi di di un un array
array 2D 2D int
int
–– notazione
notazione standard
standard */
*/
void
void visualizza_a2DI(int
visualizza_a2DI(int a[][100],
a[][100], int int n,int
n,int m) m)
{{
size colonne numero numero
int i,j;
int i,j; nella effettivo di effettivo di
for
for (i=0;i<n;i++)
(i=0;i<n;i++) dichiarazione righe colonne
{{ utilizzate utilizzate
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
printf(“%5d”,
printf(“%5d”, a[i][j]);
a[i][j]);
printf(“\n”);
printf(“\n”);
}}
}}
void visualizza_a2DI (int (*a)[100], int n,int m)

realizzare
realizzareuna
unafunction
functionCCche
chevisualizza
visualizzagli
gli
esercizio
esercizio elementi
elementidi
diun
unarray
array2D
2D
/*
/* visualizzazione
visualizzazione degli
degli elementi
elementi didi un un array
array 2D 2D int
int
–– notazione
puntatore */
*/
void
void visualizza_a2DIp(int
visualizza_a2DIp(int *pa,int
*pa,int n_col,
n_col, int int n, n, int
int m) m)
{{
size colonne numero numero
int i,j;
int i,j; nella effettivo di effettivo di
for
for (i=0;i<n;i++)
(i=0;i<n;i++) dichiarazione righe colonne
{{ utilizzate utilizzate
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
printf(“%5d”,
printf(“%5d”, *(pa+n_col*i+j));
*(pa+n_col*i+j));
printf(“\n”);
printf(“\n”);
}}
}}
#include
#include <stdio.h>
<stdio.h>
void
void visualizza_a2DIp(int *,int,int,int);
visualizza_a2DIp(int *,int,int,int);
void main()
void main()
{{
int
int a[2][3]={{1,2,3},{4,5,6}};
a[2][3]={{1,2,3},{4,5,6}};
int b[4][4]={{10,20,30,40},{50,60,70,80},{100,200,300,400},{500,600,700,800}};
int b[4][4]={{10,20,30,40},{50,60,70,80},{100,200,300,400},{500,600,700,800}};
int
int c[3][2]={{9,9},{7,6},{5,4}}
c[3][2]={{9,9},{7,6},{5,4}} ;;
visualizza_a2DIp(&a[0][0],3,
visualizza_a2DIp(&a[0][0],3, 2, 2, 3);
3);
visualizza_a2DIp(&b[0][0],4, 4,
visualizza_a2DIp(&b[0][0],4, 4, 4); 4);
visualizza_a2DIp(&c[0][0],2,
visualizza_a2DIp(&c[0][0],2, 3, 3, 2);
2);
}}
void
visualizza_a2DIp(int *pa,int
*pa,int n_col,
n_col, int
int n,
n, int
int m)
m)
{{
int
int i,j;
i,j;
for (i=0;i<n;i++)
for (i=0;i<n;i++)
{{
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
printf("%5d",
printf("%5d", *(pa+n_col*i+j));
*(pa+n_col*i+j));
printf("\n”);
printf("\n”);
}}
}}
#include
#include <stdio.h>
<stdio.h>
void
void visualizza_a2DIp(int *,int,int,int);
void main(){
void main(){
int
int a[2][3]={{1,2,3},{4,5,6}};
a[2][3]={{1,2,3},{4,5,6}};
int b[4][4]={{10,20,30,40},{50,60,70,80},{100,200,300,400},{500,600,700,800}};
int b[4][4]={{10,20,30,40},{50,60,70,80},{100,200,300,400},{500,600,700,800}};
int
int c[3][2]={{9,9},{7,6},{5,4}}
c[3][2]={{9,9},{7,6},{5,4}} ;;
visualizza_a2DIp(&a[0][0],3,
visualizza_a2DIp(&a[0][0],3, 2, 2, 2);
2);
visualizza_a2DIp(&b[0][0],4, 3,
visualizza_a2DIp(&b[0][0],4, 3, 3);3);
visualizza_a2DIp(&c[0][0],2,
visualizza_a2DIp(&c
visualizza_a2DIp(&c[0][0],2, 3,
3, 1);}
1);}
realizzare
realizzareuna
unafunction
functionCCche
checalcola
calcolala
lasomma
somma
esercizio
esercizio degli
deglielementi
elementidi
diun
unarray
array2D
2D
/*
/* somma
somma degli
degli elementi
elementi di
di un
un array
array 2D
2D int
int
–– notazione
notazione standard
standard */
*/
int
int somma_array2DI(int
somma_array2DI(int a[][100],
a[][100], int
int n,int
n,int m)
m)
{{
int
int s=0,i,j;
s=0,i,j;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
ss == ss ++ a[i][j];
a[i][j];
return
return s; s;
}}
realizzare
realizzareuna
unafunction
functionCCche
checalcola
calcolala
lasomma
somma
esercizio
esercizio degli
deglielementi
elementidi
diun
unarray
array2D
2D
/*
/* somma
somma degli
degli elementi
elementi di
di un
un array
array 2D
2D int
int
–– notazione
puntatore */
*/
int
somma_array2DI(int *pa, *pa, int
int n_col,
n_col, int
int n,int
n,int m)
m)
{{
int
int s=0,i,j;
s=0,i,j;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
ss == ss ++ *(pa+n_col*i+j);
*(pa+n_col*i+j);
return
return s; s;
}}
realizzare
realizzareun
unmain
mainche
chechiama
chiamalalafunction
functionCCche
checalcola
calcola
esercizio
esercizio lalasomma
sommadegli
deglielementi
elementididiun
unarray
array2D
2D
#include
#include <stdio.h>
<stdio.h>
int
somma_array2DI(int [][100],
[][100], int,
int, int);
int);
void
visualizza_a2DI(int [][100],
[][100], int,
int, int
int );
);
void
void main
main ()()
{{
int
int a[100][100],i,j,somma,n,m;
a[100][100],i,j,somma,n,m;
printf(“inserire
numero di
di righe
righe (<=100):”);
(<=100):”);
scanf(“%d”,&n);
scanf(“%d”,&n);
printf(“inserire
numero di
di colonne
colonne (<=100):”);
(<=100):”);
scanf(“%d”,&m);
scanf(“%d”,&m);
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
scanf(“%d”,&a[i][j]);
somma
somma == somma_array2DI(a,n,m);
somma_array2DI(a,n,m);
printf
printf (“somma
(“somma degli
degli elementi:
elementi: %d
%d \n”,somma);
\n”,somma);
printf
e’\n”);
visualizza_a2DI(a,n,m);
}}
lalasomma
sommadegli
deglielementi
elementididiun
unarray
array2D
2Dpuò
puòessere
esserecalcolata
calcolatausando
usando
lalafunction somma_arrayIper
functionsomma_arrayI pergli
gliarray
array1D
1D
#include
#include <stdio.h>
<stdio.h>
void
*,int,int,int);
int
somma_arrayI(int [],int);
[],int);
void
void main
main ()
()
{{
int
int a[3][3]={{2,1,3},{6,9,1},{6,5,7}};
a[3][3]={{2,1,3},{6,9,1},{6,5,7}};
int
int i,j,somma,n=3,m=3;
i,j,somma,n=3,m=3;
somma
somma == somma_arrayI(&a[0][0],
somma_arrayI(&a[0][0], n*m);
n*m);
printf
printf (“somma
(“somma degli
degli elementi:
elementi: %d
%d \n”,somma);
\n”,somma);
printf
e’\n”);
visualizza_a2DIp(&a[0][0],3,n,m);
visualizza_a2DIp(&a[0][0],3,n,m);
}}
attenzione: gli elementi di un array 2D non sono memorizzati

in celle consecutive, nel caso di utilizzo parziale
lalasomma
sommadegli
deglielementi
elementididiun
unarray
array2D
2Dpuò
puòessere
esserecalcolata
calcolatausando
usando
lalafunction somma_arrayIper
functionsomma_arrayI pergli
gliarray
array1D
1D
#include
#include <stdio.h>
<stdio.h> attenzione: gli elementi di un
int
somma_arrayI(int [],int); array 2D non sono memorizzati
[],int);
void
visualizza_a2DI(int [][100],
[][100], int,
int, int
int );
); nel caso di
void
in celle consecutive,
void main
main ()
()
{{ utilizzo parziale (n,m < 100)
int
int a[100][100],i,j,somma,n,m;
a[100][100],i,j,somma,n,m;
printf(“inserire
numero di
di righe
righe (<=100):”);
(<=100):”);
scanf(“%d”,&n);
scanf(“%d”,&n);
printf(“inserire
numero di
di colonne
colonne (<=100):”);
(<=100):”);
scanf(“%d”,&m);
scanf(“%d”,&m);
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
somma
somma == somma_arrayI(&a[0][0],
somma_arrayI(&a[0][0], n*m);n*m);
printf
printf (“somma
(“somma degli
degli elementi:
elementi: %d %d \n”,somma);
\n”,somma);
printf
e’\n”);
}}
realizzare
realizzareuna
unafunction
functionCCche
chedetermina
determinailil
esercizio
esercizio massimo
massimoelemento
elementodidiun
unarray
array2D
2D
/*
/* massimo
massimo tra
tra gli
gli elementi
elementi di
di un
un array
array 2D
2D int
int
–– notazione
notazione standard
standard */
*/
int
int massimo_array2DI(int
massimo_array2DI(int a[][100],int
a[][100],int n,int
n,int m)
m)
{{
int
int max,i,j;
max,i,j;
max
max == a[0][0];
a[0][0];
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
if(a[i][j]
if(a[i][j] >> max)
max)
max
max == a[i][j];
a[i][j];
return
return max;
max;
}}
realizzare
realizzareuna
unafunction
functionCCche
chedetermina
determinailil
esercizio
esercizio massimo
massimoelemento
elementodidiun
unarray
array2D
2D
/*
/* massimo
massimo tratra gli
gli elementi
elementi di
di un
un array
array 2D
2D int
int
–– notazione
puntatore */
*/
int
int massimo_array2DIp(int
massimo_array2DIp(int *pa,int
*pa,int n_col,int
n_col,int n,int
n,int m)
m)
{{
int
int max,
max, i,j;
i,j;
max
max == *pa;
*pa;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
if(*(pa+n_col*i+j)
if(*(pa+n_col*i+j) >> max)
max)
max
max == *(pa+n_col*i+j);
*(pa+n_col*i+j);
return
return max;
max;
}}
realizzare
realizzareun
unmain
mainche
chechiama
chiamalalafunction
functionCCche
che
esercizio
esercizio determina
massimoelemento
elementodidiununarray
array2D
2D
#include
#include <stdio.h>
<stdio.h>
int
int massimo_array2DIp(int
massimo_array2DIp(int *,int,int,int);
*,int,int,int);
void
visualizza_a2DI(int [][100],int,int);
[][100],int,int);
void
void main
main ()
()
{{
int
int a[100][100],massimo,n,m;
a[100][100],massimo,n,m;
printf(“inserire
numero di
di righe
righe (<=100):”);
(<=100):”);
scanf(“%d”,&n);
scanf(“%d”,&n);
printf(“inserire
numero di
di colonne
colonne (<=100):”);
(<=100):”);
scanf(“%d”,&m);
scanf(“%d”,&m);
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
massimo
massimo == massimo_array2DIp(&a[0][0],100,n,m);
massimo_array2DIp(&a[0][0],100,n,m);
printf
printf (“il
(“il massimo
massimo tra
tra gli
gli elementi:
elementi: %d
%d \n”,massimo);
\n”,massimo);
printf
e’\n”);
}}
realizzare
realizzareuna
unafunction
functionCCche
chedetermina
determina
esercizio
esercizio l’appartenenza
l’appartenenzadi
diuna
unachiave
chiaveaaun
unarray
array2D
2D
/*
/* function
function che
che determina
determina l’appartenenza
l’appartenenza di
di un
un
dato(chiave)
dato(chiave) aa un
un array
array 2D
2D
--algoritmo
--algoritmo didi ricerca
ricerca sequenziale
sequenziale per
per array
array 2D--
2D--
*/
*/
int
int appartiene_a2DF(float
appartiene_a2DF(float chiave,float
chiave,float a[][100],int
a[][100],int n,int
n,int m)
m)
{{
int i,j;
int i,j;
for(i=0;
for(i=0; i<n;
i<n; i++)
i++)
for(j=0;
for(j=0; j<m;
j<m; j++)
j++)
if
if (chiave
(chiave ==
== a[i][j])
a[i][j])
return
return 1;
1;
return
return 0;
0;
}}
esercizi
esercizi
realizzare un main C che legge da tastiera un
array 2D di tipo double (insieme con il
numero effettivo di righe e di colonne) e
calcola, visualizzando su schermo:
9 la media di ogni riga
9 la media di ogni colonna
9 la somma dei quadrati degli elementi
main C per il calcolo della media di ogni riga di un
array 2D
dati di input: valori dell’array 2D A[][],n,m

dati di output: le n medie: array media_riga[]
media_riga A
for (i=0;i<n;i++)
determinare il valore di media_riga[i]);
media_riga A
for (i=0;i<n;i++){
calcolare la somma della i–sima riga;
media_riga[i]=somma/m;
}
media_riga A
for (i=0;i<n;i++)
{
somma = 0.0;
for (j=0;j<m;j++)
somma = somma+A[i][j];
media_riga[i] = somma/m;
}
#include
#include <stdio.h>
<stdio.h>
void
void visualizza_a2DD(double [][100],int,int);
visualizza_a2DD(double [][100],int,int);
void visualizza_aI(int [],int);
void visualizza_aI(int [],int);
void
void main
main ()
()
{{
double A[100][100],media_riga[100];
double A[100][100],media_riga[100];
int i,j,n,m,somma;
int i,j,n,m,somma;
printf(“inserire
numero didi righe
righe (<=100):”);
(<=100):”);
scanf(“%d”,&n);
scanf(“%d”,&n);
printf(“inserire
numero didi colonne
colonne (<=100):”);
(<=100):”);
scanf(“%d”,&m);
scanf(“%d”,&m);
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
scanf(“%d”,&A[i][j]);
scanf(“%d”,&A[i][j]);
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
{{
somma
somma == 0.0;
0.0;
for (j=0;j<m;j++){
for (j=0;j<m;j++){
somma
somma == somma+A[i][j];
somma+A[i][j];
}}
media_riga[i]
media_riga[i] == somma/m;
somma/m;
}}
printf (“le
printf (“le medie
medie delle
delle %d
%d righe:\n”,n);
righe:\n”,n);
visualizza_aI(media_riga,n);
visualizza_aI(media_riga,n);
printf
(“l’array 2D2D e’\n”);
e’\n”);
visualizza_a2DD(A,n,m);
visualizza_a2DD(A,n,m);
}}
realizzare
realizzareuna
unafunction
functionCCche,
che,dato
datoun
unarray
array2D2Dche
che
esercizio
esercizio rappresenta
rappresentauna
unaimmagine
immagineininbianco/nero,
bianco/nero,trasformi
trasformil’array
l’arrayinin
modo
modochecheesso
essorappresenti
rappresentiililnegativo
negativodell’immagine
dell’immaginedidi
partenza
partenza
una immagine in bianco/nero è rappresentabile con

un array 2D di short in cui ogni elemento
rappresenta un pixel e il valore dell’elemento è il
livello di grigio del pixel corrispondente
immagine in bianco/nero di al più 256x256 pixel,

256 livelli di grigio (0 Ænero, 255 Æbianco)
/*
/* negativo
negativo di di una
una immagine
immagine bianco/nero
bianco/nero aa
256
256 livelli
livelli didi grigio
grigio */
*/
void
void negativo_immagine(short
negativo_immagine(short foto[][256],int
foto[][256],int n,int
n,int m)
m)
{{
int
int i,j;
i,j;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
foto[i][j]
foto[i][j] == 255
255 -- foto[i][j];
foto[i][j];
}}
#include
#include <stdio.h>
<stdio.h>
void
void negativo_immagine(short [][256],int,int);
negativo_immagine(short [][256],int,int);
void visualizza_a2DS(short [][256],int,int);
void visualizza_a2DS(short [][256],int,int);
void
void main()
main()
{{
short
short mia_foto[256][256];
mia_foto[256][256];
/*
/* ….qui deve
….qui deve essere
essere definito
definito l’array
l’array mia_foto
mia_foto ….*/
….*/
negativo_immagine(mia_foto,128,128);
negativo_immagine(mia_foto,128,128); /* mia_foto èè solo
/* mia_foto solo */
*/
visualizza_a2DS (mia_foto,128,128); /* 128x128
visualizza_a2DS (mia_foto,128,128); /* 128x128 pixel pixel */
*/
}}
/*
/* negativo
negativo didi una
una immagine
bianco/nero aa
256
256 livelli
livelli didi grigio
grigio */
*/
void negativo_immagine(short foto[][256],int n,int
void negativo_immagine(short foto[][256],int n,int m) m)
{{
int
int i,j;
i,j;
for (i=0;i<n;i++)
for (i=0;i<n;i++)
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
foto[i][j]
foto[i][j] == 256
256 -- foto[i][j];
foto[i][j];
}}
void
void visualizza_a2DS(short
visualizza_a2DS(short a[][256],
a[][256], int
int n,int
n,int m)
m)
{{
int
int i,j;
i,j;
for (i=0;i<n;i++)
for (i=0;i<n;i++)
{{
for (j=0;j<m;j++)
for (j=0;j<m;j++)
printf("%5d",
printf("%5d", a[i][j]);
a[i][j]);
printf("\n");
printf("\n");
}}
}}
realizzare
realizzareuna
unafunction
functionCCche,
che,dato
datoun
unarray
array2D
2Dche
che
esercizio
esercizio rappresenta
rappresentauna
unaimmagine
immagineininbianco/nero,
bianco/nero,trasforma
trasformal’array
l’arrayinin
modo
modochecheesso
essorappresenti
rappresentil’immagine
l’immaginedidimassimo
massimocontrasto
contrasto
dell’immagine
dell’immaginedidipartenza
partenza
una immagine in bianco/nero è rappresentabile con

un array 2D di short in cui ogni elemento
rappresenta un pixel e il valore dell’elemento è il
livello di grigio del pixel corrispondente
immagine in bianco/nero di al più 256x256 pixel,

256 livelli di grigio (0 Ænero, 255 Æbianco)
in una immagine in bianco/nero

di massimo contrasto ogni pixel ha
valore bianco (0) oppure nero (255)
/*
/* massimo
massimo contrasto
contrasto di di una
una immagine
bianco/nero aa
256
256 livelli
livelli di di grigio
grigio */
*/
void
void max_contrasto_immagine(short
max_contrasto_immagine(short foto[][256],
foto[][256],
int
int n,int
n,int m)
m)
{{
int
int i,j;
i,j;
for
for (i=0;i<n;i++)
(i=0;i<n;i++)
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
if(foto[i][j]
if(foto[i][j] <= <= 127
127 &&&& foto[i][j]>=0)
foto[i][j]>=0)
foto[i][j]
foto[i][j] == 0;0;
else
else
foto[i][j]
foto[i][j] == 255;
255;
}}
#include
#include <stdio.h>
<stdio.h>
void
void max_contrasto_immagine(short [][256],int,int);
max_contrasto_immagine(short [][256],int,int);
void
void visualizza_a2DS(short
visualizza_a2DS(short [][256],int,int);
[][256],int,int);
void
void main()
main()
{{
short
short mia_foto[256][256];
mia_foto[256][256];
/*
/* ….qui deve
….qui deve essere
essere definito
definito l’array
l’array mia_foto
mia_foto ….*/
….*/
max_contrasto_immagine(mia_foto,128,128);
max_contrasto_immagine(mia_foto,128,128); /* mia_foto èè solo
/* mia_foto solo */
*/
visualizza_a2DS
visualizza_a2DS (mia_foto,128,128);
(mia_foto,128,128); /*
/* 128x128
128x128 pixel
pixel */
*/
}}
/*
/* massimo
massimo contrasto
contrasto di
di una
una immagine
bianco/nero aa
256
256 livelli
livelli di
di grigio
grigio */
*/
void max_contrasto_immagine(short foto[][256],int
void max_contrasto_immagine(short foto[][256],int n,int m)n,int m)
{{
int i,j;
int i,j;
for (i=0;i<n;i++)
for (i=0;i<n;i++)
for
for (j=0;j<m;j++)
(j=0;j<m;j++)
if(foto[i][j]
if(foto[i][j] <=<= 127
127 &&
&& foto[i][j]>=0)
foto[i][j]>=0)
foto[i][j] == 0;
foto[i][j] 0;
else
else
foto[i][j]
foto[i][j] == 255;
255;
}}
Titolo unità didattica: Array e insiemi [08]
Titolo modulo : Algoritmi di base su insiemi - parte 1 [01-T]
Insiemi e array: unione e intersezione
Argomenti trattati:
9 rappresentazione di insiemi come array
9 algoritmo per l’unione di due insiemi
9 algoritmo per l’intersezione di due insiemi

problemi con insiemi
^2, 4, 6, 3` ^4, 3,1`

richiami:
A B
la
la cardinalità
cardinalità di
di un
un insieme
insieme èè ilil numero
numero di
di oggetti
oggetti
dell’insieme
dell’insieme
cA 4 cB 3
in
in un
un insieme
insieme un
un oggetto
oggetto non
non può
può apparire
apparire più
più volte
volte
insiemi rappresentati mediante array
A ^2, 4, 6, 3` B ^4, 3,1`
a 22 44 66 33 b 44 33 11
un
un insieme,
insieme, ii cui
cui oggetti
oggetti sono
sono dati
dati di
di tipo
tipo scalare,
scalare, può
può
essere
essere rappresentato
rappresentato mediante
mediante unun array
array 1D
1D (di
(di quel
quel
tipo)
tipo) di
di size
size almeno
almeno uguale
uguale alla
alla cardinalità
cardinalità
dell’insieme
dell’insieme
^2, 4, 6, 3` ^4, 3,1`

unione di due insiemi:
A B
C A B ^2 , 4 , 6 ,3 ,1`
A B
^2, 4, 6, 3` ^4, 3,1`

A B
C A B ^2 , 4 , 6 ,3 ,1`
C
^2, 4, 6, 3` ^4, 3,1`

A B
C A B ^2 , 4 , 6 ,3 ,1`
cC 5
il numero di elementi dell’insieme unione è
minore o al più uguale alla somma dei numeri
degli elementi dei due insiemi
cC d c A c B
^2, 4, 6, 3` ^4, 3,1`

intersezione di due insiemi:
A B
C A B ^4 ,3`
C
^2, 4, 6, 3` ^4, 3,1`

A B
C A B ^4 ,3`
cC 2
il numero di elementi dell’insieme intersezione
è minore o al più uguale al minimo tra i numeri
c C d min c A , c B
degli elementi dei due insiemi
dati di input: il primo insieme (variabile a), la sua

cardinalità (variabile n_a), il secondo
insieme (variabile b), la sua cardinalità
(variabile n_b)
dati di output: l’insieme unione (variabile c), la
sua cardinalità (variabile n_c)
verificare l’appartenenza di b(i) ad a
se non appartiene, deve essere un
elemento di c
unione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^2, 4, 6,3,1`
array c 2 4 6 3
unione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^2, 4, 6,3,1`
array c 2 4 6 3
unione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^2, 4, 6,3,1`
array c 2 4 6 3
unione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^2, 4, 6,3,1`
array c 2 4 6 3
unione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^2, 4, 6,3,1`
array c 2 4 6 3
unione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^2, 4, 6,3,1`
array c 2 4 6 3
unione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^2, 4, 6,3,1`
array c 2 4 6 3 1
procedure
procedure unione(in:
unione(in: a, a, n_a,
n_a, b,
b, n_b;
n_b;out:
out: c,n_c)
c,n_c)
var
var n_a,
n_a, n_b
n_b ,n_c,
,n_c, i:i: integer
integer
var
var a:a: array(1..n_a)
array(1..n_a) of of real
real
var
var b:b: array(1..n_b)
array(1..n_b) of of real
real
var
var c:c: array(1..n_c)
array(1..n_c) of of real
real
var
var appartiene:
appartiene: logical
logical function
function
%
% inizializzazione
inizializzazione didi cc
for
for i=1,n_a
i=1,n_a do do
c(i)
c(i) :=
:= a(i)
a(i)
endfor
endfor
n_c
n_c := := n_a
n_a
...
...
……
for
for i=1,n_b
i=1,n_b dodo
if
if !appartiene(b(i),a,n_a)
!appartiene(b(i),a,n_a)
then
then
n_c
n_c :=
:= n_c+1
n_c+1
c(n_c)
c(n_c) :=
:= b(i)
b(i)
endif
endif
endfor
endfor
end
end
n_b*n_a
n_b*n_a
confronti
confronti tra
tra elementi
elementi degli
degli array
array
(al
(al più)
più)

(variabile n_b)
dati di output: l’insieme unione (variabile c), la
sua cardinalità (variabile n_c)
verificare l’appartenenza di a(i) a b
se appartiene, deve essere un elemento di c
intersezione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^4,3`
array c
intersezione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^4,3`
array c
intersezione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^4,3`
array c
intersezione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^4,3`
array c
intersezione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^4,3`
array c 4
intersezione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^4,3`
array c 4
intersezione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^4,3`
array c 4
intersezione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^4,3`
array c 4
intersezione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C A B ^4,3`
array c 4 3
intersezione di due insiemi
procedure
procedure intersezione(
intersezione( in:in: a,
a, n_a,
n_a, b,
b, n_b;
n_b; ……
out:
out: c,c, n_c)
n_c)
var
var n_a,
n_a, n_b,
n_b, n_c,
n_c, ii :: integer
integer
var
var a:
a: array(1..n_a)
real
var
var b:
b: array(1..n_b)
real
var
var c:
c: array(1..n_c)
array(1..n_c) of of real
real
var
var appartiene:
appartiene: logical
logical function
function
...
...
……
n_c
n_c :=:= 00
for
for i=1,n_a
i=1,n_a dodo
if
if appartiene(a(i),b,n_b)
appartiene(a(i),b,n_b)
then
then
n_c
n_c :=
:= n_c+1
n_c+1
c(n_c) :=
c(n_c) := a(i)
a(i)
endif
endif
endfor
endfor
end
end n_b*n_a
n_b*n_a
confronti
confronti tra
tra elementi
elementi deidei due
due array
array
(al
(al più)
più)
Titolo modulo : Algoritmi di base su insiemi – parte 2 [02-T]
Insiemi e array: inclusione, sottrazione e uguaglianza
Argomenti trattati:
9 algoritmo per determinare l’inclusione di due insiemi
9 algoritmo per la sottrazione di due insiemi
9 algoritmo per determinare l’uguaglianza di due insiemi

^2, 4, 6, 3` ^4, 3,1`

inclusione di due insiemi:
A B
A B B A
un insieme è incluso in un altro insieme se tutti
i suoi oggetti sono oggetti dell’altro insieme
A B
A ^25 ,12 ` B ^3 ,12 , 44 , 25 , 7 `

A B B A
A
B

(variabile n_b)
dato di output: true (incluso), false (non incluso)
(variabile incluso)
verificare l’appartenenza di ogni a(i) a b
predicato di uscita:
a(i) non appartiene a b or i = n_a
inclusione A ^25 ,12 ` B ^3 ,12 , 44 , 25 , 7 `
array a array b
25 12 3 12 44 25 7
incluso
inclusione A ^25 ,12 ` B ^3 ,12 , 44 , 25 , 7 `
array a array b
25 12 3 12 44 25 7
incluso
inclusione A ^25 ,12 ` B ^3 ,12 , 44 , 25 , 7 `
array a array b
25 12 3 12 44 25 7
true
incluso
inclusione A ^25 ,12 ` B ^3 ,12 , 44 , 25 , 7 `
array a array b
25 12 3 12 44 25 7
true
incluso
inclusione A ^25 ,12 ` B ^3 ,12 , 44 , 25 , 7 `
array a array b
25 12 3 12 44 25 7
true
incluso
function
function inclusione(a,
inclusione(a, n_a,
n_a, b, b, n_b):
n_b): logical
logical
var
var n_a,
n_a, n_b,
n_b, i:i: integer
integer
var
var a: a: array(1..n_a)
real
var
var b: b: array(1..n_b)
real
var
var incluso:
incluso: logical
logical
var
var appartiene:
appartiene: logical
logical function
function
ii :=
:= 00
repeat
repeat
ii :=
:= i+1
i+1
incluso :=
incluso := appartiene(a(i),b,n_b)
until
until !incluso
!incluso or
or ii == n_a
n_a
return
return incluso
incluso
end
end n_b*n_a
n_b*n_a
confronti
confronti tra
tra elementi
elementi deidei due
due array
array
(al
(al più)
più)
^2, 4, 6, 3` ^4, 3,1`

sottrazione di due insiemi:
A B
C AB ^2 , 6 `
l’insieme sottrazione ha per oggetti gli oggetti

del primo insieme che non appartengono al
secondo insieme
^2, 4, 6, 3` ^4, 3,1`

A B
C AB ^2 , 6 `
A B
^2, 4, 6, 3` ^4, 3,1`

A B
C AB ^2 , 6 `
A
^2, 4, 6, 3` ^4, 3,1`

A B
C AB ^2 , 6 `
il numero di elementi dell’insieme sottrazione

è minore o al più uguale al numero degli
elementi del primo insieme
cC d c A

(variabile n_b)
dati di output: l’insieme sottrazione (variabile c),
la sua cardinalità (variabile n_c)
verificare l’appartenenza di a(i) a b
se non appartiene, a(i) deve essere un
elemento di c
sottrazione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C AB ^2 , 6 `
array c
sottrazione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C AB ^2 , 6 `
array c
sottrazione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C AB ^2 , 6 `
array c 2
sottrazione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C AB ^2 , 6 `
array c 2
sottrazione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C AB ^2 , 6 `
array c 2
sottrazione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C AB ^2 , 6 `
array c 2
sottrazione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C AB ^2 , 6 `
array c 2 6
sottrazione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C AB ^2 , 6 `
array c 2 6
sottrazione A ^2, 4, 6,3` B ^4,3,1`
array a array b
2 4 6 3 4 3 1
C AB ^2 , 6 `
array c 2 6
procedure
procedure sottrazione(
sottrazione( in:in: a,
a, n_a,
n_a, b,
b, n_b;
n_b;
out:
out: c, c, n_c)
n_c)
var
var n_a,
n_a, n_b,
n_b, n_c,
n_c, ii :: integer
integer
var
var a:
a: array(1..n_a)
real
var
var b:
b: array(1..n_b)
real
var
var c:
c: array(1..n_c)
array(1..n_c) ofof real
real
var
var appartiene:
appartiene: logical
logical function
function
...
...
……
n_c
n_c :=:= 00
for
for i=1,n_a
i=1,n_a do do
if
if !appartiene(a(i),b,n_b)
!appartiene(a(i),b,n_b)
then
then
n_c
n_c :=
:= n_c+1
n_c+1
c(n_c)
c(n_c) :=
:= a(i)
a(i)
endif
endif
endfor
endfor
end
end n_b*n_a
n_b*n_a
confronti
confronti tra
tra elementi
elementi degli
degli array
array
(al
(al più)
più)
uguaglianza di due insiemi:
A ^25 , 7 ,12 ` B ^12 , 25 , 7 `
due insiemi sono uguali se hanno lo stesso

numero di oggetti e se ogni oggetto di un
insieme è anche oggetto dell’altro insieme
uguaglianza di due insiemi:
dati di input: il primo insieme (variabile a), il

secondo insieme (variabile b), le loro
cardinalità (variabile n)
dato di output: true (uguali), false (diversi)
(variabile uguale)
verificare l’appartenenza di ogni a(i) a b
predicato di uscita:
a(i) non appartiene a b or i = n_a
uguaglianza A ^25 , 7 ,12 ` B ^12 , 25 , 7 `
array a array b
25 7 12 12 25 7
uguale
uguaglianza A ^25 , 7 ,12 ` B ^12 , 25 , 7 `
array a array b
25 7 12 12 25 7
uguale
uguaglianza A ^25 , 7 ,12 ` B ^12 , 25 , 7 `
array a array b
25 7 12 12 25 7
true
uguale
uguaglianza A ^25 , 7 ,12 ` B ^12 , 25 , 7 `
array a array b
25 7 12 12 25 7
true
uguale
uguaglianza A ^25 , 7 ,12 ` B ^12 , 25 , 7 `
array a array b
25 7 12 12 25 7
true
uguale
uguaglianza A ^25 , 7 ,12 ` B ^12 , 25 , 7 `
array a array b
25 7 12 12 25 7
true
uguale
uguaglianza A ^25 , 7 ,12 ` B ^12 , 25 , 7 `
array a array b
25 7 12 12 25 7
true
uguale
function
function uguaglianza_insiemi(a,b,n):
uguaglianza_insiemi(a,b,n): logical logical
var
var n, n, i:
i: integer
integer
var
var a: a: array(1..n)
real
var
var b: b: array(1..n)
real
var
var uguale:
uguale: logical
logical
var
var appartiene:
appartiene: logical
logical function
function
ii :=
:= 00
repeat
repeat
ii :=
:= i+1
i+1
uguale :=
uguale := appartiene(a(i),b,n)
appartiene(a(i),b,n)
until
until !uguale
!uguale or or ii == nn
return
return uguale
uguale
end n 22
end n
confronti
confronti tra
tra elementi
elementi deidei due
due array
array
(al
(al più)
più)
Titolo modulo : Function in C per operazioni di base su

insiemi [03-C]
Sviluppo di function in C che operano su array che realizzano

insiemi ed esempi di utilizzo
Argomenti trattati:
9 function in C per l’unione di due insiemi
9 function in C per l’intersezione di due insiemi
9 function in C per l’inclusione di due insiemi
9 function in C per la sottrazione di due insiemi
9 function in C per l’uguaglianza di due insiemi
Prerequisiti richiesti: AP-07-10-C, AP-08-01-T, AP-08-02-T

realizzare una function C per l’unione di
esercizio
esercizio due array 1D
void
void unioneF(float
unioneF(float a[],int
a[],int n_a,float
n_a,float b[],int
b[],int n_b, n_b,
float
float c[],int
c[],int *n_c)
*n_c)
procedure
procedureunione(in:
unione(in:a,a,n_a,
n_a,b,b,
{{ n_b;out:
n_b;out:c,n_c)
c,n_c)
int
int i,i_c;
i,i_c; var n_a, n_b ,n_c, i: integer
var n_a, n_b ,n_c, i: integer
/* var
vara:a:array(1..n_a)
array(1..n_a)of ofreal
/* inizializzazione
inizializzazione dell’array
dell’array cc */
*/ var b: array(1..n_b) of
real
real
for var b: array(1..n_b) of real
for (i=0;i<n_a;i++)
(i=0;i<n_a;i++) var
varc:c:array(1..n_c)
array(1..n_c)of ofreal
real
c[i] = a[i];
c[i] = a[i]; var appartiene: logical function
var appartiene: logical function
%%inizializzazione
inizializzazionedidicc
i_c = n_a-1;
i_c = n_a-1; for
fori=1,n_a
i=1,n_adodo
for (i=0;i<n_b;i++)
for (i=0;i<n_b;i++) c(i) := a(i)
c(i) := a(i)
endfor
{{ endfor
n_c
n_c:=:=n_a
n_a
if
if (!appartiene_aF(b[i],a,n_a))
(!appartiene_aF(b[i],a,n_a)) for for i=1,n_bdo
i=1,n_b do
{{ if !appartiene(b(i),a,n_a)
if !appartiene(b(i),a,n_a)
then
then
i_c++;
i_c++; n_c
n_c:=:=n_c+1
n_c+1
c[i_c]= c(n_c) :=b(i)
c(n_c) :=
c[i_c]= b[i];
b[i]; endif
b(i)
}} endif
endfor
endfor
}} end
end
*n_c
*n_c == i_c+1;
i_c+1;
}}
realizzare un main che richiama la function
esercizio
esercizio unioneF di due array 1D
/*
/* programma
programma perper l’unione
l’unione didi due
due insiemi.
insiemi.
main
main usa
usa unioneF
unioneF che
che usa
usa appartiene_aF
appartiene_aF */*/
#include
#include <stdio.h>
<stdio.h>
int
int appartiene_aF(float,float
appartiene_aF(float,float [],int);
[],int); /*
/* function
function
sviluppata
sviluppata nelnel modulo
modulo 07-10-C
07-10-C */
*/
void
void unioneF(float
unioneF(float [],int,float
[],int,float [],int,float
[],int,float [],int
[],int *);
*);
void
void main()
main()
{{
int
int n_a,n_b,n_c;
n_a,n_b,n_c;
float
float a[]={1.0,20.0,0.5,4.4,9.0,6.1,7.3,3.0,1.1,8.0};
a[]={1.0,20.0,0.5,4.4,9.0,6.1,7.3,3.0,1.1,8.0};
float
float b[]={8.0,12.0,7.0,0.5,3.0,
b[]={8.0,12.0,7.0,0.5,3.0, 1.1,5.0,1.0};
1.1,5.0,1.0};
float
float c[18];
c[18];
int
int i;
i;
n_a
n_a == 10;
10;
n_b
n_b == 8;
8;
unioneF(a,n_a,b,n_b,c,&n_c);
unioneF(a,n_a,b,n_b,c,&n_c);
printf("numero
printf("numero di di elementi
elementi dell'unione:%d\n",n_c);
dell'unione:%d\n",n_c);
for
for (i=0;i<n_c;i++)
(i=0;i<n_c;i++)
printf("
printf(" %5.1f\n",c[i]);
%5.1f\n",c[i]);
}}
realizzare una function C per l’intersezione di
esercizio
void procedure intersezione(
intersezione(in: in:a,a,b[],int
n_a,
n_a,b,b,n_b;
n_b;out: c,c,n_c)
void intersezioneF(float
intersezioneF(float a[],int proceduren_a,float
a[],int
var n_a, n_b,
n_a,float
n_c, i : integer
b[],int n_b,
out:
n_b, n_c)
float var n_a,*n_c)
n_b, n_c, i : integer
float c[],int
c[],int
var *n_c)
var a: array(1..n_a)of
a: array(1..n_a) ofreal
real
{{ var b: array(1..n_b) of
var b: array(1..n_b) of real real
var
int i,i_c;
int i,i_c; var appartiene: logical
real
function
i_c =
i_c = 0;0; n_c
n_c:=:=00
for for
fori=1,n_a
i=1,n_ado
for (i=0;i<n_a;i++)
(i=0;i<n_a;i++) do
ififappartiene(a(i),b,n_b)
{{ then
then
if (appartiene_aF(a[i],b,n_b)) n_c
n_c:=:=n_c+1
n_c+1
if (appartiene_aF(a[i],b,n_b)) c(n_c)
{{ c(n_c) :=a(i)
:= a(i)
endif
endif
c[i_c]= a[i];
c[i_c]= a[i]; end endfor
endfor
i_c++; end
i_c++;
}}
}}
*n_c
*n_c == i_c;
i_c;
}}
realizzare un main che richiama la function
esercizio
esercizio intersezioneF di due array 1D
/*
/* programma
programma perper l’intersezione
l’intersezione didi due
due insiemi.
insiemi.
main
main usa
usa intersezioneF
intersezioneF che
che usa
usa appartiene_aF
appartiene_aF */*/
#include
#include <stdio.h>
<stdio.h>
void
void visualizza_aF
visualizza_aF (float
(float [],int);
[],int); /*/* modulo
modulo 07-09-C
07-09-C */
*/
int
[],int); /*/* modulo
modulo 07-10-C
07-10-C */
*/
void
void intersezioneF(float
intersezioneF(float [],int,float
[],int,float [],int
[],int *);
*);
void
void main()
main()
{{
int n_a,n_b,n_c;
int n_a,n_b,n_c;
float
float a[]={1.0,20.0,0.5,4.4,9.0,6.1,7.3,3.0,1.1,8.0};
a[]={1.0,20.0,0.5,4.4,9.0,6.1,7.3,3.0,1.1,8.0};
float
float b[]={8.0,12.0,7.0,0.5,3.0,
b[]={8.0,12.0,7.0,0.5,3.0, 1.1,5.0,1.0};
1.1,5.0,1.0};
float
float c[18];
c[18];
int
int i;
i;
n_a
n_a == 10;
10;
n_b
n_b == 8;
8;
intersezioneF(a,n_a,b,n_b,c,&n_c);
intersezioneF(a,n_a,b,n_b,c,&n_c);
printf("numero
printf("numero di di elementi
elementi dell‘intersezione:%d\n",n_c);
dell‘intersezione:%d\n",n_c);
visualizza_aF(c,n_c);
visualizza_aF(c,n_c);
}}
esercizio
esercizio realizzare una function C per l’inclusione di due array 1D
int
int inclusioneF(float
inclusioneF(float a[],int
a[],int n_a,float
n_a,float
function
b[],int
b[],int n_b)
n_b)
functioninclusione(a,
inclusione(a,n_a,n_a,b,b,n_b):
n_b):logical
logical
{{ var n_a, n_b, i: integer
var n_a, n_b, i: integer
int var
vara:a:array(1..n_a)
array(1..n_a)of ofreal
int i,incluso;
i,incluso; var b: array(1..n_b) of
real
real
ii == 0;
0; var b: array(1..n_b) of real
var
varincluso:
incluso:logical
logical
do
do var
var appartiene:logical
appartiene: logicalfunction
function
{{ i i:=:=00
i++; repeat
repeat
i++; i i:=:=i+1
incluso = appartiene_aF(a[i],b,n_b); i+1
incluso = appartiene_aF(a[i],b,n_b); incluso:=:=appartiene(a(i),b,n_b)
incluso appartiene(a(i),b,n_b)
}} until
until !inclusoor
!incluso ori i==n_a
n_a
while(incluso && i<n_a); return incluso
return incluso
while(incluso && i<n_a); end
return
return incluso;
incluso; end
}}
int
inclusioneF(float a[],int
a[],int n_a,float
n_a,float b[],int
b[],int n_b)
n_b)
{{
int
int i,incluso=1;
i,incluso=1;
ii == 0;
0;
for(i=0;i<n_a;i++)
for(i=0;i<n_a;i++)
if(!appartiene_aF(a[i],b,n_b))
if(!appartiene_aF(a[i],b,n_b))
{{
incluso
incluso == 0;
0;
break;
break;
}}
return
return incluso;
incluso;
}}
/*
/* programma
programma per
per l’inclusione
l’inclusione didi due
due insiemi.
insiemi.
main
main usa
usa inclusioneF
inclusioneF che
che usa
usa appartiene_aF
appartiene_aF */ */
#include
#include <stdio.h>
<stdio.h>
void
void visualizza_aF
(float [],int
[],int );); /*
/* modulo
modulo 07-09-C
07-09-C */
*/
void
legge_da_tastiera_aF(float [],int);
[],int); /*/* 07-09-C
07-09-C */
*/
int
[],int); /* /* modulo
modulo 07-10-C
07-10-C */
*/
int
inclusioneF(float [],int,float
[],int,float [],int);
[],int);
void
void main()
main()
{{
int
int i,n_a,n_b;
i,n_a,n_b;
float
float a[100],b[100];
a[100],b[100];
printf(“inserire
printf(“inserire numero
numero di
di elementi
elementi II array
array (<=100):”);
(<=100):”);
scanf(“%d”,&n_a);
scanf(“%d”,&n_a);
legge_da_tastiera_aF(a,n_a);
legge_da_tastiera_aF(a,n_a);
printf(“inserire
printf(“inserire numero
numero di
di elementi
elementi IIII array
array (<=100):”);
(<=100):”);
scanf(“%d”,&n_b);
scanf(“%d”,&n_b);
legge_da_tastiera_aF(b,n_b);
legge_da_tastiera_aF(b,n_b);
if(inclusioneF(a,n_a,b,n_b))
if(inclusioneF(a,n_a,b,n_b))
printf(“il
printf(“il II array
array e’
e’ incluso
incluso nel
nel IIII array\n",);
array\n",);
else
else
printf(“il II array
printf(“il array non
non e’
e’ incluso
incluso nel
nel II
II array\n",);
array\n",);
printf(“I
printf(“I array
array ee II
II array\n",);
array\n",);
visualizza_aF(a,n_a);
visualizza_aF(a,n_a); visualizza_aF(b,n_b);
visualizza_aF(b,n_b);
}}
esercizio
esercizio realizzare una function C per la sottrazione di due array 1D
void procedure
proceduresottrazione( in:
in:a,a,n_b,
n_a,
n_a,b,b,n_b;
void sottrazioneF(float
sottrazioneF(float a[],int
a[],int n_a,float
n_a,float b[],int
sottrazione(
b[],int out: c, n_b,
n_c)
n_b;
out: c, n_c)
float c[],int *n_c)
float c[],intvar*n_c)
var n_a, n_b, n_c, i : integer
n_a, n_b, n_c, i : integer
{{ var
var a:array(1..n_a)
a: array(1..n_a)of ofreal
real
var b: array(1..n_b) of
var b: array(1..n_b) of realreal
int
int i,i_c;
i,i_c; var
real
i_c =
i_c = 0;0; var appartiene: logical function
n_c
n_c:=:=00
for (i=0;i<n_a;i++)
for (i=0;i<n_a;i++) for
fori=1,n_a
i=1,n_adodo
if (!appartiene_aF(a[i],b,n_b))
if (!appartiene_aF(a[i],b,n_b)) if
if!appartiene(a(i),b,n_b)
!appartiene(a(i),b,n_b)
{{ then
then
n_c
n_c:=:=n_c+1
n_c+1
c[i_c] = a[i];
c[i_c] = a[i]; c(n_c) := a(i)
c(n_c) := a(i)
i_c++; endif
endif
i_c++; endfor
}} endfor
end
end
}}
*n_c
*n_c == i_c;
i_c;
}}
realizzare una function C per determinare l’uguaglianza di
esercizio
int
int uguaglianza_insiemiF(float
uguaglianza_insiemiF(float a[],float
a[],float
function b[],int
b[],int n) n) logical
functionuguaglianza_insiemi(a,b,n):
uguaglianza_insiemi(a,b,n): logical
{{ var n, i: integer
var n, i: integer
var
vara:a:array(1..n)
int i,uguale;
int i,uguale; var b: array(1..n) of
real
real
var b: array(1..n) of real
ii == 0;
0; var
varuguale:
uguale:logical
logical
do var
var appartiene:logical
appartiene: logicalfunction
function
do i i:=:=00
{{ repeat
repeat
uguale = i i:=:=i+1
appartiene_aF(a[i],b,n); i+1
uguale = appartiene_aF(a[i],b,n);uguale
i++; uguale:=:=appartiene(a(i),b,n)
appartiene(a(i),b,n)
i++; until
until !ugualeor
!uguale ori i==nn
}} return
returnuguale uguale
end
while(uguale
while(uguale && && i<n);
i<n); end
return
return uguale;
uguale;
}}
int
uguaglianza_insiemiF(float a[],float
a[],float
b[],int
b[],int n)
n)
{{
int
int i;
i;
ii == 0;
0;
for(i=0;i<n;i++)
for(i=0;i<n;i++)
if(!appartiene_aF(a[i],b,n))
if(!appartiene_aF(a[i],b,n))
return
return 0;
0;
return 1;
return 1;
}}
Esempio di file di intestazioni per le function su insiemi
insiemi.h
#include
#include <stdio.h>
<stdio.h>
void
void unioneF(float
unioneF(float [],int,float
[],int,float [],int
[],int *);
*);
void
void intersezioneF(float[],int,float[],int,float[],int*);
intersezioneF(float[],int,float[],int,float[],int*);
int
inclusioneF(float [],int,float
[],int,float [],int);
[],int);
void
void sottrazioneF(float[],int,float[],int,float[],int
sottrazioneF(float[],int,float[],int,float[],int *);
*);
int
uguaglianza_insiemiF(float [],float
[],float [],int);
[],int);
int
[],int);
void
void visualizza_aF
(float [],int);
[],int);
void
legge_da_tastiera_aF(float [],int);
[],int);
#include
#include “insiemi.h”
“insiemi.h”
void
void main()
main()
{{
……
……
}}
Titolo modulo : Tipi enumerativi e tipi derivati in C [04-C]
Proprietà dei tipi enumerativi in C e generazione di tipi derivati
Argomenti trattati:
9 istruzione typedef
9 comando #define
9 tipi enum
9esempi di function C con parametri di tipo enumerativo e
derivato
Prerequisiti richiesti: AP-03-03-C, AP-05-04-C

tipi derivati da tipi primitivi
in C si può dare un nome (identificatore) a un tipo esistente
typedef
typedef <tipo_esistente>
<tipo_esistente> <nuovo_tipo>;
<nuovo_tipo>;
typedef
typedef int
int Integer;
Integer;
typedef
typedef char
char Character;
Character;
il nome (identificatore) è utilizzabile come un nuovo tipo

il nuovo tipo può essere utilizzato per dichiarare variabili o
funzioni
Integer
Integer i,j;
i,j;
Character
Character c,
c, parola[5];
parola[5];
Character
Character int2char(Integer);
int2char(Integer);/*prototipo*/
/*prototipo*/
typedef
typedef <tipo_esistente>
<tipo_esistente> <nuovo_tipo>;
<nuovo_tipo>;
typedef
typedef int
int Integer;
Integer;
typedef
typedef char
char Character;
Character;
il nome (identificatore) è utilizzabile come un nuovo tipo

il nuovo tipo può essere utilizzato per dichiarare variabili o
funzioni
sono equivalenti
Integer
Integer i,j;
i,j; int
int i,j;
i,j;
Character
Character c,
c, parola[5];
parola[5]; char
char c,
c, parola[5];
parola[5];
Character
Character int2char(Integer);
int2char(Integer); char
char int2char(Integer);
int2char(Integer);
migliorare la leggibilità del programma

il nome di un nuovo tipo può riflettere l’uso che si intende fare
di quel tipo nel programma
typedef
typedef int
int Euro;
Euro;
typedef
typedef int
int Ore_lavoro
Ore_lavoro ;;
Euro
Euro stipendio,costo;
stipendio,costo;
Euro
Euro reddito(Ore_lavoro);
reddito(Ore_lavoro);/*prototipo*/
/*prototipo*/
comando (al precompilatore) #define
#define
#define <identificatore>
<identificatore> <valore>
<valore>
il precompilatore sostituisce,
nel testo del programma sorgente, tutte le occorrenze di
<identificatore> con <valore>
#define
#define PI_GRECO
PI_GRECO 3.1415926F
3.1415926F
#define
#define TRUE
TRUE 11
#define
#define FALSE
FALSE 00
area_cerchio
area_cerchio == PI_GRECO*raggio*raggio;
PI_GRECO*raggio*raggio;
……
if
if (a
(a ==
== b)
b)
uguale
uguale == TRUE;
TRUE;
else
else
uguale
uguale == FALSE;
FALSE;
#define
<valore>
#define
#define PI_GRECO
PI_GRECO 3.1415926F
3.1415926F
#define
#define TRUE
TRUE 11
#define
#define FALSE
FALSE 00
area_cerchio
area_cerchio == 3.1415926F*raggio*raggio;
3.1415926F*raggio*raggio;
……
if
if (a
(a ==
== b)
b)
uguale
uguale == 1;
1;
else
else
uguale
uguale == 0;
0;
#define
<valore>
#define
#define NN 100
100
#define
#define N_RIGHE
N_RIGHE 1024
1024
#define
#define N_COLONNE
N_COLONNE 1024
1024
float
float a[N];
a[N];
int
int foto_bn[N_RIGHE][N_COLONNE];
foto_bn[N_RIGHE][N_COLONNE];
for
for (i=0;i<N;i++)…
(i=0;i<N;i++)…
float
float a[100];
a[100];
int
int foto_bn[1024][1024];
foto_bn[1024][1024];
for
for (i=0;i<100;i++)…
(i=0;i<100;i++)…
#define
#define <nome_macro(x)>
<nome_macro(x)> <istruzioni_macro>
<istruzioni_macro>
<nome_macro> con <macro> e
trattando l’identificatore x come parametro
#define
#define QUADRATO(x)
QUADRATO(x) ((x)*(x))
((x)*(x))
……
aa == QUADRATO(b);
QUADRATO(b);
cc == QUADRATO(a+b);
QUADRATO(a+b);
aa == ((b)*(b));
((b)*(b));
cc == ((a+b)*(a+b));
((a+b)*(a+b));
in C si possono creare gerarchie di tipi derivati
#define
#define NN 12
12
typedef
typedef double
double Scalare;
Scalare;
typedef
typedef Scalare
Scalare Vettore[N];
Vettore[N];
typedef
typedef Scalare
Scalare Matrice_quadrata[N][N];
Matrice_quadrata[N][N];
sono stati creati i tipi
Scalare Vettore Matrice_quadrata
Scalare
Scalare velocita_luce
velocita_luce == 299792.458;
299792.458;
Vettore
Vettore inflazione_mese;
inflazione_mese;
Matrice
Matrice M,A,B;
M,A,B;
double velocita_luce = 299792.458;
double inflazione_mese[12];
double M[12][12],A[12][12],B[12][12];
in C si possono creare gerarchie di tipi derivati
#define
#define NN 12
12
typedef
typedef double
double Scalare;
Scalare;
typedef
typedef Scalare
Scalare Vettore[N];
Vettore[N];
typedef
typedef Scalare
Scalare Matrice_quadrata[N][N];
Matrice_quadrata[N][N];
void
void somma(Vettore
somma(Vettore x,Vettore
x,Vettore y,Vettore
y,Vettore z)
z)
{{
int
int i;
i;
for
for (i=0;i<N;i++)
(i=0;i<N;i++)
z[i]
z[i] == x[i]
x[i] ++ y[i];
y[i];
}}
Attenzione: la function somma opera solo su vettori
di size fissato
tipi enumerativi
in C si può creare un nuovo tipo enumerando
tutti i suoi oggetti (tipo enumerativo )
enum
enum <etichetta>
<etichetta> {{<elenco_oggetti>
<elenco_oggetti>}};;
enum
enum giorno
giorno {{Lu,Ma,Me,Gi,Ve,Sa,Do
Lu,Ma,Me,Gi,Ve,Sa,Do}};;
enum
enum seme
seme {{picche,fiori,quadri,cuori
picche,fiori,quadri,cuori}};;
nomeetichetta
del enumeratore enumeratore
nuovo(tag)
tipo
un enumeratore è una costante (simbolica) di tipo int

tipi enumerativi
in C si può creare un nuovo tipo enumerando
tutti i suoi oggetti (tipo enumerativo )
enum
enum <etichetta>
<etichetta> {{<elenco_oggetti>
<elenco_oggetti>}};;
enum
enum giorno
enum
enum seme
seme {{picche,fiori,quadri,cuori
picche,fiori,quadri,cuori}};;
il nuovo tipo (enum <etichetta>) può essere utilizzato per

dichiarare variabili o funzioni
enum
enum giorno
giorno festa,riunione;
festa,riunione;
enum
enum seme
seme carta[40];
carta[40];
enum
enum giorno
giorno chegiornoe(int);/*prototipo*/
chegiornoe(int);/*prototipo*/
tipi enumerativi
le seguenti dichiarazioni sono ammissibili
festa è una variabile di tipo enum giorno
enum
enum giorno
Lu,Ma,Me,Gi,Ve,Sa,Do}}festa;
festa;
enum
enum {{Lu,Ma,Me,Gi,Ve,Sa,Do
Lu,Ma,Me,Gi,Ve,Sa,Do}} festa;
festa;
l’etichetta non è necessaria Giorno è un nuovo

tipo
typedef
typedef enum
enum {Lu,Ma,Me,Gi,Ve,Sa,Do}
{Lu,Ma,Me,Gi,Ve,Sa,Do} Giorno;
Giorno;
typedef
typedef enum
enum giorno
giorno Giorno;
Giorno;
9 gli enumeratori (per es. Lu, Ma, quadri,..) sono costanti
un tipo enumerativo è equivalente al tipo int nel senso che:
9 il valore del primo enumeratore è 0, del secondo è 1, e

(simboliche) di tipo int
così via
enum
enum giorno
è equivalente a
const
const int
int Lu
Lu == 0;
0; #define
#define Lu
Lu 00
const
const int
int Ma
Ma == 1;
1; #define
#define Ma
Ma 11
const
const int
int Me
Me == 2;
2; #define
#define Me
Me 22
const
const int
int Gi
Gi == 3;
3; #define
#define Gi
Gi 33
const
const int
int Ve
Ve == 4;
4; #define
#define Ve
Ve 44
const
const int
int Sa
Sa == 5;
5; #define
#define Sa
Sa 55
const
const int
int Do
Do == 6;
6; #define
#define Do
Do 66

così via
enum
enum giorno
giorno {{Lu=1,Ma,Me,Gi,Ve,Sa,Do
Lu=1,Ma,Me,Gi,Ve,Sa,Do}};;
ililvalore
valoredel
delprimo
primoenumeratore
enumeratoreèè 1,
1,del
delsecondo
secondoèè 2,
2,eecosì
cosìvia
via
enum
enum giorno
giorno festa,riunione;
festa,riunione;
festa
festa == Do;
Do;
riunione
riunione == festa;
festa;
riunione
riunione == Lu
Lu ;;
if(riunione
if(riunione ==== Lu)
Lu)
printf(“
printf(“ %d%d \n”,riunione);
\n”,riunione);
1

così via
enum
enum giorno
giorno {Lu,Ma,Me,Gi,Ve,Sa,Do};
{Lu,Ma,Me,Gi,Ve,Sa,Do};
un
unenumeratore
enumeratoreoccupa
occupalolostesso
stessospazio
spaziodi dimemoria
memoriadidiun un
dato
datodel tipoint
deltipo int
agli
aglienumeratori
enumeratorisisipossono
possonoapplicare
applicaregliglistessi
stessioperatori
operatoridel del
tipo int
tipo int
gli
glienumeratori
enumeratoripossono
possonoessere
essereusati
usatiininespressioni
espressionidi di
confronto

confronto
se
sesisidefiniscono
definisconopiù tipienum
piùtipi enumnon nonsisipossono
possonoriutilizzare
riutilizzaregli
gli
stessi
stessienumeratori

enumeratori
non
nonèèpossibile
possibileassegnare
assegnareun unvalore
valoreaaun unenumeratore
enumeratorecon con
una istruzione di assegnazione (Lu=1;)
una istruzione di assegnazione (Lu=1;)
enum cabala {cane=1,gatto=3,topo=7,spada=18,foglie=78,
… paura=90};
agli
aglienumeratori
enumeratoripossono
possonoessere
essereassegnati
assegnativalori
valorinumerici
numerici
anche
ancheindicando
indicandodirettamente
direttamenteililsimbolo
simboloASCII
ASCII
enum
enum simbolo{nome,numero,fine,piu
simbolo{nome,numero,fine,piu =‘+’,
=‘+’,
meno
meno =‘-’,per
=‘-’,per =‘*’,div
=‘*’,div =‘/’};
=‘/’};
è equivalente a
const
const int
int nome
nome == 0;
0;
const
const int
int numero
numero == 1;
1;
const
const int
int fine
fine == 2;
2;
const
const int
int piu
piu == 43;
43; /*/* rappr.
rappr. ASCII
ASCII di
di =‘+’
=‘+’ */
*/
const
const int
int meno
meno == 45;
45; /*/* rappr.
rappr. ASCII
ASCII di
di =‘-’
=‘-’ */
*/
const
const int
int per
per == 42;
42; /* /* rappr.
rappr. ASCII
ASCII di
di =‘*’
=‘*’ */
*/
const
const int
int div
div == 47;
47; /* /* rappr.
rappr. ASCII
ASCII di
di =‘/’
=‘/’ */
*/
realizzazione del tipo derivato Logical
typedef
typedef enum
enum {false,true}
{false,true} Logical;
Logical;
Logical
Logical trovato;
trovato;
……
trovato == true;
trovato true; /*
/* oo anche
anche trovato
trovato == false;*/
false;*/
……
if(trovato)
if(trovato)
printf(“trovato
printf(“trovato e’vero
e’vero %d”,trovato);
%d”,trovato);
else
else
printf(“trovato
printf(“trovato e’falso
e’falso %d”,trovato);
%d”,trovato);
èèimportante
importanteche
cheililvalore
valoredell’enumeratore
dell’enumeratore
falsesia
false sia00 ee ililvalore
valoredi truesia
di true sia1,
1,
al
alfine
finedi
dimantenere
mantenerela lacompatibilità
compatibilitàcon
conleleoperazioni
operazionilogiche
logiche
del
delCC
trovato e’ vero 1
Esempio: function che restituisce il giorno successivo di un
giorno, passato come parametro di input, e main di chiamata
/*
/* determinazione
determinazione del
del giorno
giorno successivo
successivo
(Lu,Ma,Me,...)
(Lu,Ma,Me,...) didi un
un giorno
giorno dato
dato */
*/
#include
#include <stdio.h>
<stdio.h>
enum
enum giorno
typedef
typedef enum
enum giorno
giorno Giorno;
Giorno;
Giorno
Giorno giorno_dopo(Giorno);
giorno_dopo(Giorno);
void
void main()
main()
{{
Giorno
Giorno oggi,domani;
oggi,domani;
oggi
oggi == Me;
Me;
domani
domani == giorno_dopo(oggi);
giorno_dopo(oggi);
printf("
printf(" se
se oggi
oggi e'
e' %d
%d allora
allora domani
domani e'
e'
%d\n",oggi,domani);
%d\n",oggi,domani);
}}
Giorno
Giorno giorno_dopo(Giorno
giorno_dopo(Giorno x) x)
{{
Giorno
Giorno y;
y;
switch
switch (x){
(x){
case Lu:
case Lu: yy == Ma;
Ma; break;
break;
case
case Ma:
Ma: yy == Me;
Me; break;
break;
case
case Me:
Me: yy == Gi;
Gi; break;
break;
case
case Gi:
Gi: yy == Ve;
Ve; break;
break;
case
case Ve:
Ve: yy == Sa;
Sa; break;
break;
case
case Sa:
Sa: yy == Do;
Do; break;
break;
case
case Do:
Do: yy == Lu;
Lu; break;
break;
}}
return
return y;y;
}}
se oggi e’ 2 allora domani e’ 3

Esempio: function che restituisce il giorno successivo
di un giorno passato come parametro di input e main
/*
/* determinazione
determinazione del
del giorno
giorno successivo
successivo
(Lu,Ma,Me,...)
(Lu,Ma,Me,...) */
*/
#include
#include <stdio.h>
<stdio.h>
enum
enum giorno
typedef
typedef enum
enum giorno
giorno Giorno;
Giorno;
Giorno
Giorno giorno_dopo(Giorno);
giorno_dopo(Giorno);
void
void main()
main()
{{
Giorno
Giorno oggi,domani;
oggi,domani;
char
char *giorni_settimana[]={"lunedi","martedi",
*giorni_settimana[]={"lunedi","martedi",
"mercoledi","giovedi","venerdi",
"mercoledi","giovedi","venerdi",
"sabato","domenica"};
"sabato","domenica"};
array
array di
di puntatori
puntatori aa char
char
array di puntatori a char array di puntatori a
stringhe costanti
lunedi
array di puntatori a char
indirizzi base delle stringhe

martedi
mercoledi
array
giovedi frastagliato
venerdi (costante)
sabato
domenica
giorni_settimana stringhe
oggi
oggi == Me;
Me;
domani
domani == giorno_dopo(oggi);
giorno_dopo(oggi);
printf("
printf(" sese oggi
oggi e'
e' %d
%d allora
allora domani
domani e' e'
%d\n",oggi,domani);
%d\n",oggi,domani);
printf("
printf(" sese oggi
oggi e'
e' %s
%s allora
allora ",
",
giorni_settimana[(int)oggi]);
giorni_settimana[(int)oggi]); puntatore
printf("
printf(" domani
domani e'
e' %s\n",
%s\n",
giorni_settimana[(int)domani]);
giorni_settimana[(int)domani]);
}} puntatore
cast:
cast:valore
valoredi oggieedi
di oggi domanicome
didomani comeinteri
interi
se oggi e’ 2 allora domani e’ 3

se oggi e’ mercoledi allora domani e’ giovedi
versione alternativa della function giorno_dopo
Giorno
Giorno giorno_dopo(Giorno
giorno_dopo(Giorno x)
x)
{{
return ((Giorno)(((int)x
return ((Giorno)(((int)x +1)%7));
+1)%7));
}}
modulo:
modulo:
cast: valore cast:
cast: ilil valore cast: valore
valore di
di xx resto
resto
dell’espressione
dell’espressione come
come intero
intero della
della
èè trasformato
trasformato nelnel divisione
divisione
tipo
tipo Giorno
Giorno intera
intera
Titolo unità didattica: Stringhe ed elaborazione di testi [09]
Titolo modulo : Operazioni elementari su stringhe [01-T]
Le stringhe di caratteri: operazioni di concatenazione, confronto,..
Argomenti trattati:
9 stringhe di caratteri su un alfabeto
9 stringhe e sottostringhe
9 operazioni di base su stringhe

stringhe
stringhe di
di caratteri
caratteri
9una
9unastringa
stringasu suun alfabeto {c
unalfabeto {cjj}}j=1,n è una sequenza di
j=1,n è una sequenza di
caratteri
caratteridell’alfabeto:
dell’alfabeto:
cc1cc2cc3cc4cc5…c
1 2 3 4 5…ckk
9
9una
unastringa
stringaèècostituita
costituitada daununnumero
numero finito
finitodidicaratteri,
caratteri,
che
cheèèla lalunghezza
lunghezza della dellastringa
stringa
(c …ckkha
(c11cc22cc33cc44cc55…c ha lunghezza
lunghezzak) k)
9
9la
lastringa
stringavuota
vuotaèèla lastringa
stringadidilunghezza
lunghezzazero zero
(0-stringa)
9
(0-stringa)
9in
inuna
unastringa,
stringa,ogniogni carattere
carattereha hasuasuaunaunaposizione
posizione
d’ordine
d’ordineche chesisichiama
chiama indice
indicedelladellastringa
9
stringa
9una
unasottostringa
sottostringaèèuna unaporzione
porzionedi diuna
unastringa,
stringa,cioè
cioèuna
una
sequenza
sequenzadi dicaratteri
carattericonsecutivi
consecutividi diuna
unastringa
9
stringa
9una
unasottostringa
sottostringadi dilunghezza
lunghezza p, p,ililcui
cuiprimo
primocarattere
caratteresisi
trova
trovanella
nellaposizione
posizionedi indice iidella
diindice dellastringa
stringaèèdetta
detta
p-sottostringadi
p-sottostringa diinizio
inizioii
stringhe
stringhe di
di caratteri
caratteri
9
9una
unastringa
stringadidilunghezza
lunghezza kkèèdetta
dettak-stringa
9
k-stringa
9l’insieme
l’insiemedi ditutte
tuttele 1-stringhesu
le 1-stringhe suun
unalfabeto
alfabetodidinn
caratteri
caratterihahacardinalità
cardinalità nn
9
9l’insieme
tuttele 2-stringhesu
le 2-stringhe suun
unalfabeto
alfabetodidinn
caratteri 2
cardinalità nn2
9
9l’insieme
tuttele k-stringhesu
le k-stringhe suun
unalfabeto
alfabetodidinn
caratteri k
cardinalità nnk
9
9una
una permutazione
permutazionedi diuna k-stringaèèuna
unak-stringa una k-stringa
k-stringa
composta
compostadaglidaglistessi
stessicaratteri
9
caratteri
9l’insieme
tuttele
lepermutazioni
permutazionidi diuna k-stringaha
una k-stringa ha
cardinalità
cardinalità k! k!
operazioni
operazioni di
di base
base su
su stringhe
stringhe di
di caratteri
caratteri
concatenazione
ricerca
concatenazione
ricerca didi un
un carattere
carattere in
in una
una stringa
confronto
stringa
confronto tra tra due
due stringhe
matching
stringhe
matching di di due
due stringhe
creazione
stringhe
creazione di di una
una copia
copia di di una
una stringa
calcolo
stringa
calcolo della
della lunghezza
lunghezza di di una
una stringa
confronto
stringa
confronto di di sottostringhe
sottostringhe di di due
due
stringhe
copia
stringhe
copia didi una
una sottostringa
sottostringa di di una
una stringa
ricerca
stringa
ricerca didi una
una sottostringa
sottostringa in in una
una
stringa
stringa
concatenazione di stringhe
stringhe:
S1 = cassa S2 = forte
S1 S3
S2
c a s s a f o r t e
si ottiene una nuova stringa S3 che è la concatenazione

delle due stringhe S1 ed S2
S3 = S1 // S2 = cassaforte
ricerca di un carattere in una stringa
ricercare un dato carattere all’interno della stringa

cassaforte
carattere da ricercare: f
NO c a s s a f o r t e
SI
f f f f f f
confronto fra due stringhe
determinare l’uguaglianza o la diseguaglianza
S1 = cassaforte S2 = pianoforte
no no no no no si si si si si
c a s s a f o r t e
p i a n o f o r t e
confronto fra due stringhe
si si si si si si si si si si
c a s s a f o r t e
OK
c a s s a f o r t e
matching fra due stringhe
determinare il numero di caratteri (di ugual

posto) delle due stringhe che risultano uguali
no no no no no si si si si si
c a s s a f o r t e punteggio del
matching
5
p i a n o f o r t e
creazione di una copia di una stringa
stringhe:
S1 = cassaforte S2 = NULL (stringa vuota )
assegnare la stringa S1 a S2
S1
c a s s a f o r t e S1
c a s s a f o r t e
S1=S2
S2
calcolo della lunghezza di una stringa
lunghezza di una stringa, ovvero numero dei caratteri

che costituiscono la stringa
S1
c a s s a f o r t e
cnt=0cnt=1
cnt=2
cnt=3
cnt=4 cnt = 10
cnt=5
cnt=6
cnt=7
cnt=8
cnt=9
cnt=10
concatenazione di sottostringhe
stringhe:
S1 = cassa S2 = forte
concatenare a S1 la sottostringa di S2 formata dai
suoi primi m caratteri (sottostringa di lunghezza m e
inizio 1)
m=3
S1 S2
c a s s a f o r t e
confronto di sottostringhe
stringhe:
verificare l’uguaglianza solo tra le sottostringhe di
lunghezza m e inizio 1
m=5
no no no no no
c a s s a f o r t e
p i a n o f o r t e
confronto di sottostringhe
m=5
si si si si si
c a s s a f o r t e
c a s s a p a n c a
copia di una sottostringa
data una stringa S1, creare una copia di una sua

sottostringa di lunghezza m e inizio 1
m=5
S1
c a s s a f o r t e
c a s s a
S2
estrazione di token da una stringa
data una stringa S1, che contiene un testo, cioè un
insieme di parole separate da separatori (spazio,
segni di punteggiatura, andata a capo, etc..), estrarre
una copia di tutte le parole (token)
S1
n e l m e z z o d e l c a m
m i n , m i r i t r o v a i .
n e l c a m m i n
m e z z o m i
d e l r i t r o v a i
ricerca di una sottostringa in una stringa
(string matching, pattern matching)
• date due stringhe S1 e S2, ricercare le occorrenze

della stringa S2 come sottostringa della stringa S1
no no
si no no no
si no
si no
si no
si si
S1
P o r t a n o l a n a
n o l a
S2
ricerca di una sottostringa in una stringa che più
si avvicina una stringa data
(best matching, matching migliore)
• date due stringhe S1 e S2, trovare la sottostringa della

stringa S1 che ha il maggior numero di caratteri (di
ugual posto) in comune con la stringa S2
no no
si no no
si no no
si si
S1
P o r t a n o l a n a
1 0 0 3
t o n o
S2
ricerca di una sottostringa in una stringa
(string matching, pattern matching)
9 sapere se una stringa (chiave) appare come

sottostringa di un’altra stringa
9 contare il numero delle occorrenze di una
sottostringa in una stringa
9 sapere l’indice di una sottostringa in una
stringa
9 ricercare una sottostringa in una stringa e
sostituirla con un’altra sottostringa
(find/replace)
pattern matching in Bioinformatica Esempio
9 il DNA si trova nel nucleo delle cellule
9 è il programma che il nostro corpo deve

continuamente eseguire
9 l'elemento base del DNA è una molecola

chiamata nucleotide
9 per ogni specie o essere vivente esistono solo

4 nucleotidi, identificati dai nomi
Adenina, Timina, Citosina, Guanina
pattern matching in Bioinformatica
cellula
DNA
9 il DNA è una lunga catena (doppia) di

nucleotidi
ilil DNA
DNA èè un
un testo
testo (stringa)
(stringa) sull’alfabeto
sull’alfabeto {A,T,C,G}
{
{A,T,C,G}
}
un gene è un segmento di DNA, che contiene
l’informazione relativa a una specifica
funzionalità
il DNA è un testo (stringa) contenente tutte le
informazioni necessarie per la vita della
cellula e dell’individuo
l’insieme di tutte le informazioni genetiche, e
quindi dell’intero DNA di un individuo o di
una specie, è detto genoma
A T T C G G T C G A A C C T C G A C T
gene (sottostringa)
ricercare
ricercare un
un
ricercare
ricercare un
un
particolare
particolare
pattern
pattern in
in
gene in
gene in una
una
una
una
sequenza
sequenza di di
stringa
stringa
DNA
DNA
Titolo modulo : Algoritmi per l’elaborazione di testi [02-T]
Algoritmi di analisi di testi e di individuazione di pattern
Argomenti trattati:
9 algoritmo di analisi delle componenti di un testo
9 algoritmo di string matching
9 algoritmo di matching migliore

problema:
dato un testo (stringa), che contiene uno scritto in
lingua italiana, determinare il numero di parole
contenute nel testo (senza segni di interpunzione)
dati di input: la stringa testo, la sua lunghezza
(variabile m)
dato di output: il numero di parole nel testo
(variabile numero_parole)
costrutto ripetitivo: 1 ciclo for
considerare l’i–simo della stringa testo,
determinare se è iniziale di una parola e
incrementare opportunamente i contatori
una parola è una sottostringa racchiusa tra due caratteri spazio
i testo
n e l m e z z o d e l
c a m m i n d i n o s t r a
v i t a m i r i t r o v a i
false 0
in_parola numero_parole
i testo
true 1
i testo
false 1
i testo
true 2
i testo
false 2
function
function conta_parole(testo,m):
conta_parole(testo,m): integerinteger
var
var m,
m, i,i, numero_parole:
numero_parole: integerinteger
var
var in_parola:
in_parola: logical
logical
var
var testo:
testo: string
string
var
var c:
c: character
character
numero_parole
numero_parole := := 00
in_parola
in_parola := := false
false
for
for i=1,m
i=1,m do do
cc :=
:= testo(i)
testo(i) i-simo carattere della stringa testo
if
if cc == ‘‘ ’’
in_parola
in_parola := := false
false
else
else ifif !in_parola
!in_parola
in_parola
in_parola := := true
true
numero_parole :=
numero_parole := numero_parole
numero_parole ++ 11 ;;
endif
endif
endfor
endfor
return
return numero_parole
numero_parole
end
end
problema:
calcolo del numero di volte in cui una stringa data
compare come sottostringa in un’altra stringa data
(string matching)
dati di input: la stringa chiave, la sua lunghezza
(variabile n), la stringa testo, la sua lunghezza
(variabile m)
dato di output: numero di occorrenze
(variabile conta_chiave)
costrutto ripetitivo: 1+1 cicli innestati
operazione ripetuta (al generico passo i, ciclo
for esterno): confrontare la stringa chiave e la
sottostringa (inizio i e lunghezza n) della
stringa testo
j j j j j
n
chiave
testo
i
j j j j j
n
chiave
testo
i
n
chiave
testo
i i+n-1
determinare se queste due

stringhe sono uguali
function
function string_matching(chiave,n,testo,m):
string_matching(chiave,n,testo,m): integerinteger
var
var n,
n, m,
m, i,i, conta_chiave:
conta_chiave: integer
integer
var chiave: string n*(m-n+1)
n*(m-n+1)
var chiave: string
var
var testo:
testo: string
string confronti
confronti
var
var uguale_stringhe:
uguale_stringhe: logical
logical function
function (al
(al più)
più)
conta_chiave
conta_chiave := := 00 (tra
(tracaratteri
caratteridelle
delledue
due
for stringhe)
for i=1,m-n+1
i=1,m-n+1 do do stringhe)
if
if uguale_stringhe(chiave,[testo,i],n)
uguale_stringhe(chiave,[testo,i],n)
then
then
conta_chiave
conta_chiave :=:= conta_chiave
conta_chiave ++ 11
endif
endif
endfor
endfor VRWWRVWULQJDGL
return conta_chiave
return
end
conta_chiave LQL]LR i GHOOD
end
VWULQJD testo
function
function string_matching(chiave,n,testo,m):
string_matching(chiave,n,testo,m): integer
integer
var
var n,
n, m,
m, i,i, conta_chiave:
conta_chiave: integer
integer
var
var chiave:
chiave: array(1..n)
character
var
var testo:
testo: array(1..m)
array(1..m) of of character
character
var
var uguale:
uguale: logical
logical function
function
conta_chiave
conta_chiave := := 00
for
for i=1,m-n+1
i=1,m-n+1 do do
if
if uguaglianza_array(chiave,testo(i..i+n-1),n)
uguaglianza_array(chiave,testo(i..i+n-1),n)
then
then
conta_chiave
conta_chiave := := conta_chiave
conta_chiave ++ 11
endif
endif
endfor
endfor QRWD]LRQHGL
return conta_chiave
return
end
conta_chiave SRU]LRQHGLDUUD\
end
problema:
determinare la sottostringa di una stringa data che ha
il maggior numero di caratteri (di ugual posto) uguali a
quelli di un’altra stringa data (matching migliore)
dati di input: la stringa chiave, la sua lunghezza
(variabile n), la stringa testo, la sua lunghezza
(variabile m)
dato di output: l’indice della sottostringa di matching
migliore (variabile indice)
costrutto ripetitivo: 1+1 cicli innestati
operazione ripetuta (al generico passo i, ciclo
for esterno): determinare il punteggio del
matching tra la stringa chiave e la sottostringa
(inizio i e lunghezza n) della stringa testo
j j j j j
n
chiave
testo
i
numero di caratteri uguali

(punteggio del matching)
j j j j j
n
chiave
testo
i
numero di caratteri uguali

(punteggio del matching)
n
chiave
testo
i i+n-1
determinare il numero di
caratteri uguali di queste
due stringhe
function
function matching_migliore(chiave,n,testo,m):
matching_migliore(chiave,n,testo,m): integerinteger
var
var n,
n, m,
m, i,i, punteggio_max,
punteggio_max, punteggio,
punteggio, indice:
indice: integer
integer
var
var chiave:
chiave: string
string n*(m-n+1)
n*(m-n+1)
var testo: string
var testo: string confronti
var punteggio_matching: integer function (traconfronti
var punteggio_matching: integer function
caratteri delle
punteggio_max (tra caratteri delle
punteggio_max := := 00 due
duestringhe)
stringhe)
for i=1,m-n+1
for i=1,m-n+1 do do
punteggio
punteggio := := punteggio_matching(chiave,[testo,i],n)
punteggio_matching(chiave,[testo,i],n)
if
if punteggio
punteggio >> punteggio_max
punteggio_max
then
then
punteggio_max
punteggio_max := := punteggio
punteggio
indice :=
indice := ii VRWWRVWULQJDGL
endif
endif
endfor LQL]LR i GHOOD
endfor
return indice
return indice
VWULQJD testo
end
end
function
function punteggio_matching(a,b,n):
punteggio_matching(a,b,n): integer
integer
var
var n,
n, i,i, n_caratteri_uguali:
n_caratteri_uguali: integer
integer
var
var a:
a: string
string
var b: string nn
var b: string
n_caratteri_uguali
n_caratteri_uguali := := 00 confronti
confronti
for i=1,n do (tra
(tracaratteri
caratteridelle
delle
for i=1,n do due stringhe)
if due stringhe)
if a(i)
a(i) == b(i)
b(i)
then
then
n_caratteri_uguali
n_caratteri_uguali :=
:= n_caratteri_uguali
n_caratteri_uguali +1 +1
endif
endif
endfor
endfor
return n_caratteri_uguali
return n_caratteri_uguali
end
end
conveniamo di denotare con a(i) e b(i)

l’i-simo carattere della stringa a e della stringa b
Titolo modulo : Stringhe in C [03-C]
Proprietà delle stringhe C
Argomenti trattati:
9 rappresentazione di stringhe in C
9 function C per lettura e visualizzazione di stringhe
9 function in C per operazioni di base su stringhe
9 array di puntatori al tipo char
Prerequisiti richiesti: AP-03-05-C, AP-05-04-C, AP-07-08-C

stringhe
stringhe di
di caratteri
caratteri in
in C
C
in
in C
C ilil tipo
tipo stringa
tringa non
stringa non èè direttamente
direttamente definito
definito
9 il tipo stringa in C è realizzato come un array

1D di elementi di tipo char
9 la fine della sequenza di caratteri della stringa è
specificata esplicitamente dal carattere di
fine stringa: ‘\0’
‘\0’ :: carattere
‘\0’ carattere nullo, NULL, codice
nullo, NULL, codice ASCII
ASCII 00000000
00000000
stringhe
stringhe di
di caratteri
caratteri in
in C
C
in
in C
C ilil tipo
tipo stringa
tringa non
definito

considerare
considerare una
una stringa
stringa come
come sese avesse
avesse lunghezza
lunghezza
variabile,
variabile, delimitata
delimitata da \0, entro
da \0, entro una
una lunghezza
lunghezza
massima
massima determinata
determinata dal
dal size
size dell’array
dell’array
stringhe
stringhe di
di caratteri
caratteri in
in C
C
in
in C
C ilil tipo
tipo stringa
tringa non
definito

ilil size
size dell’array
dell’array deve
deve tener
tener conto
conto anche
anche dello
dello spazio
spazio
necessario
necessario per
per memorizzare
memorizzare ilil carattere
carattere di
di fine
fine
stringa
stringa
stringhe e array in C
char
char nome_Corso_Laurea[12];
nome_Corso_Laurea[12];
char
char testo[1000];
testo[1000];
char
char pagina_libro[1600];
pagina_libro[1600];
char
char gene[250];
gene[250];
char
char genoma[100000000];
genoma[100000000];
Informatica 11 caratteri
I n f o r m a t i c a \0
nome_Corso_Laurea size 12
costanti stringa in C
una
una costante
costante stringa
stringa èè specificata
specificata dalla
dalla sequenza
sequenza
di caratteri racchiusa
di caratteri racchiusa tra
tra doppi
doppi apici
apici
“Informatica”
“Hello world!!”
He ll o w o r l d ! ! \0
0 1 2 3 4 5 6 7 8 9 10 11 12 13
una
unacostante
costantestringa,
stringa,come
comeililnome
nomedi diun
unarray
array1D,
1D,èètrattata
trattata
dal
dalcompilatore
compilatoreCCcome
comeun un puntatore
puntatore costante,
costante,chechepunta
punta
alla
allacella
celladi
dimemoria
memoriadeldel primo
primo carattere
carattere della
della stringa
stringa
(indirizzo
(
(indirizzo base
basedella
dellastringa)
stringa)
dichiarazione-inizializzazione di stringhe in C
char
char nome_Corso_Laurea[12]=“Informatica”;
nome_Corso_Laurea[12]=“Informatica”;
char
char nome_Corso_Laurea[]=“Informatica”;
nome_Corso_Laurea[]=“Informatica”;
char
char nome_Corso_Laurea[]={‘I’,‘n’,‘f’,
nome_Corso_Laurea[]={‘I’,‘n’,‘f’,
‘o’,‘r’,‘m’,‘a’,‘t’,‘i’,‘c’,‘a’,‘\0’};
‘o’,‘r’,‘m’,‘a’,‘t’,‘i’,‘c’,‘a’,‘\0’};
char
char *nome_Corso_Laurea=“Informatica”;
*nome_Corso_Laurea=“Informatica”;
un puntatore viene inizializzato a un indirizzo

costanti stringa e costanti carattere in C
differenza tra costanti stringa e costanti carattere

char
char dd =‘r’;
=‘r’; variabile scalare e costante carattere
char
char s[]=“r”;
s[]=“r”; array di due elementi e costante stringa
char
char *p
*p =“r”;
=“r”; array di due elementi e costante stringa
dd =‘a’;
=‘a’; assegnazione corretta
s[0]
s[0] =‘a’;
=‘a’; assegnazione corretta
ss == “a”;
“a”; assegnazione non corretta
*p
*p == “a”;
“a”; assegnazione non corretta
stringhe e puntatori a char in C
char
char *pnome
*pnome == “Giulio
“Giulio Rossi”;
Rossi”;
ilil puntatore pnomepunta
puntatorepnome puntaal
alprimo
primocarattere
caratteredella
dellacostante
costante
stringa,
stringa,ovvero
ovveroal alprimo
primoelemento
elemento dell’array
dell’array (indirizzo
(indirizzo base)
base) di
di
caratteri
caratteriin
incui
cuièèmemorizzata
memorizzatalalacostante
costantestringa
stringa
char
char *pnome;
*pnome; ERRORE
*pnome
*pnome == “Giulio
“Giulio Rossi”;
Rossi”;
ininCCnon
nonesistono
esistonooperatori
operatoriche
chetrattano
trattanouna
unastringa
stringacome
comeuna
unaunità
unità
char
char *pnome;
*pnome; OK
pnome
pnome == “Giulio
“Giulio Rossi”;
Rossi”;
questa
questaassegnazione
assegnazionenon
noncopia
copialalastringa
stringacostante,
costante,
ma
macoinvolge
coinvolgesolo
soloi ipuntatori
puntatori(gli
(gliindirizzi)
indirizzi)
9
9 viene
9
9 sisi alloca
viene dichiarato
dichiarato un
un puntatore
puntatore
9
9 l’indirizzo
alloca memoria
memoria perper la
la costante
costante stringa
stringa
l’indirizzo base
base della
della stringa
stringa viene
viene assegnato
assegnato al
al
puntatore
puntatore
char
char *pnome;
*pnome;
pnome
pnome == “Giulio
“Giulio Rossi”;
Rossi”;
sono equivalenti
char
char *pnome
*pnome == “Giulio
“Giulio Rossi”;
9
Rossi”;
9 sisi alloca
9
9 viene
alloca memoria
memoria per
per la
la costante
costante stringa
stringa
9
9 l’indirizzo
viene dichiarato
dichiarato un
un puntatore
puntatore
l’indirizzo base
base della
della stringa
stringa viene
viene assegnato
assegnato al
al
puntatore
puntatore
char
char nome[]
nome[] == “Giulio
“Giulio Rossi”;
Rossi”;
9
9 sisi alloca
alloca memoria
memoria per
per un
un array
array adeguata
adeguata almeno
almeno aa
9
9 l’array
contenere
contenere lala costante
costante stringa
stringa
9
9 èè possibile
l’array viene
viene inizializzato
inizializzato con
con la
la costante
costante stringa
stringa
possibile copiare
copiare un’altra
un’altra stringa
stringa nell’array
nell’array
pnome
pnome == &nome[0];
&nome[0];
pnome++
pnome++ ;;
puntaaanome[1]
punta nome[1],, nome[1];
nome[1]; notazione standard
secondo
secondocarattere
caratteredella
della
stringa
*pnome;
*pnome; notazione a puntatore
stringa
visualizzazione di stringhe
char
char nome_Corso_Laurea[12]=“Informatica”;
nome_Corso_Laurea[12]=“Informatica”;
printf(“%s”,nome_Corso_Laurea);
char
char *nome_Corso_Laurea=“Informatica”;
*nome_Corso_Laurea=“Informatica”;
ATTENZIONE
il codice di formato %s (codice di formato stringa)
richiede che il corrispondente argomento nella
chiamata della printf sia un puntatore
printf(“%s”,nome_Corso_Laurea+2);
printf(“%s”,nome_Corso_Laurea+2);
formatica
_
function C per l’I/O di caratteri singoli
mainche
main checonta
contaililnumero
numerodidicaratteri
caratteridigitati
digitatisulla
sullatastiera,
tastiera,
fino
finoal
alcarattere
caratteredi
difine
fineimmissione
immissione(EOF)(EOF)
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
int
int c,i=0;
c,i=0;
while
while ((c
((c == getchar())
getchar()) !=
!= EOF)
EOF)
i++;
i++;
printf(“numero
printf(“numero didi caratteri:
caratteri: %d",i);
%d",i);
putchar(‘\n’);
putchar(‘\n’);
}}
EOF
EOF èè Ctrl+z
Ctrl+z in
in Microsoft
Microsoft VisualC++
VisualC++ (in
(in stdio.h)
stdio.h)
function C per l’I/O di stringhe libreria stdio
char
char stringa[100];
stringa[100];
stringa
stringa == gets();
gets(); fino a nuova linea o EOF
char
char stringa[100];
stringa[100];
gets(stringa);
gets(stringa);
puts(stringa);
puts(stringa);
la function gets( )
ha un parametro di tipo puntatore a char
e restituisce un puntatore a char
la function puts( )
ha un parametro di tipo puntatore a char
#include <stdio.h> #include <stdio.h>
void main() void main()

{ {
int i; int i;
char *p="informatica"; char *p="informatica";
char a[20]="calcolo"; char a[]="calcolo";
puts(p); puts(p);
puts(a); puts(a);
p = "applicata"; *(p+1) = 'N';
for(i=0;i<12;i++) for(i=0;i<9;i++)
a[i] = "numerico"[i]; a[i] = "numerico"[i];
puts(p); puts(p);
puts(a); puts(a);
} }
informatica
calcolo
applicata
numerico
_
function in C per operazioni su stringhe:
lunghezza di una stringa
int
int lunghezza_stringa(char
lunghezza_stringa(char *s)
*s)
{{
int i;
int i;
for
for (i=0;
(i=0; *s
*s !=
!= '\0';
'\0'; i++)
i++)
s++;
s++;
return
return i;
i;
}}
libreria string :
unsigned int strlen(char *str);
concatenazione di due stringhe
void
void cat_stringa(char
cat_stringa(char s[],
s[], char
char t[])
t[])
{{
int
int i,j;
i,j;
jj == lunghezza_stringa(s);
lunghezza_stringa(s);
for
for (i=0;
(i=0; t[i]
t[i] !=
!= '\0';
'\0'; i++)
i++)
s[j++]
s[j++] == t[i];
t[i];
s[j]
s[j] == ‘\0’;
‘\0’;
}}
libreria string :
void strcat(char *str1, char *str2);
concatenazione di sottostringhe
void
void catN_stringa(char
catN_stringa(char s[],
s[], char
char t[],
t[], int
int n)
n)
{{
int
int i,j;
i,j;
jj == lunghezza_stringa(s);
lunghezza_stringa(s);
for
for (i=0;
(i=0; t[i]
t[i] !=
!= '\0‘
'\0‘ &&
&& ii << n;
n; i++)
i++)
s[j++]
s[j++] == t[i];
t[i];
s[j]
s[j] == ‘\0’;
‘\0’;
}}
libreria string :
void strncat(char *str1, char *str2, int n);
copia di una stringa
void
void copia_stringa(char
copia_stringa(char s[],
s[], char
char t[])
t[])
{{
int
int i=0;
i=0;
for
for (i=0;
(i=0; t[i]
t[i] !=
!= '\0';
'\0'; i++)
i++)
s[i]
s[i] == t[i];
t[i];
s[i]
s[i] == ‘\0’;
‘\0’;
}}
libreria string :
char *strcpy(char *str1, char *str2);
copia di una sottostringa
void
void copiaN_stringa(char
copiaN_stringa(char s[],
s[], char
char t[],
t[], int
int n)
n)
{{
int
int i=0;
i=0;
for
for (i=0;
(i=0; t[i]
t[i] !=
!= '\0‘
'\0‘ &&
&& ii << n;
n; i++)
i++)
s[i]
s[i] == t[i];
t[i];
}}
libreria string :
char *strncpy(char *str1, char *str2, int n);
confronto tra due stringhe
int confronto_stringhe(char s[], char t[])
{
int i;
if(lunghezza_stringa(s)!= lunghezza_stringa(s))
return 0;
for (i=0; s[i] != '\0'; i++)
if (s[i] != t[i])
return 0;
return 1;
}
libreria string :
int strcmp(char *str1, char *str2);
confronto tra due sottostringhe
int confrontoN_stringhe(char s[],char t[],int n)

{
int i;
for (i=0; s[i] != '\0‘ && i < n ; i++)
if (s[i] != t[i]) return 0;
return 1;
}
libreria string :
int strncmp(char *str1, char *str2, int n);
ricerca di un carattere in una stringa
int trova_carattere(char s[], char t)

{
int i;
for (i=0; s[i] != '\0'; i++)
if (s[i]== t)
return 1;
return 0;
}
libreria string :
char *strrchr(char *str1, char ch);
array di stringhe
in molte applicazioni si usano collezioni di

stringhe:
elenco di nominativi
sequenze di domande
raccolte di delibere
….
9 array 2D di char (array di array di char)

9 array di puntatori a char
array di stringhe esempio
elenco di 10 nominativi
ciascun nominativo è lungo al più 11 caratteri
char
char elenco_a2D[10][12]={
elenco_a2D[10][12]={ “Alberto”,
“Alberto”,
“Maria”,
“Maria”,
“Luisa”,
“Luisa”,
“Remigio”,
“Remigio”,
“Renzo”,
“Renzo”,
array 2D di char
“Ugo”,
“Ugo”,
(array di array di
char) “Beppe”,
“Beppe”,
“Dino”,
“Dino”,
“Laura”,
“Laura”,
“Michele”,
“Michele”,
};
};
memoria allocata e inizializzata
A l b e r t o \0 0 0 0 0
M a r i a \0 0 0 0 0 0 0
L u i s a \0 0 0 0 0 0 0
R e m i g i o \0 0 0 0 0
R e n z o \0 0 0 0 0 0 0
U g o \0 0 0 0 0 0 0 0 0
B e p p e \0 0 0 0 0 0 0
D i n o \0 0 0 0 0 0 0 0
L a u r a \0 0 0 0 0 0 0
M i c h e l e \0 0 0 0 0
elenco_a2D[10][12]
array di stringhe
elenco_a2D[i][j] è il j-simo carattere

dell’i-sima riga
elenco_a2D[i] è l’i-simo array di char
elenco_a2D[i] è il puntatore all’i-sima riga
if (confronto_stringhe
(elenco_a2D[2],elenco_a2D[3]))
……
if(strcmp(elenco_a2D[2],elenco_a2D[3]))
……
elenco di 10 nominativi
ciascun nominativo è lungo al più 11 caratteri
char *elenco_p1D[10]={“Alberto”,
char *elenco_p1D[10]={“Alberto”,
“Maria”,
“Maria”,
“Luisa”,
“Luisa”,
“Remigio”,
“Remigio”,
“Renzo”,
“Renzo”,
array di “Ugo”,
puntatori a char “Ugo”,
“Beppe”,
“Beppe”,
“Dino”,
“Dino”,
“Laura”
“Laura”
“Michele”,
“Michele”,
};
};
esempio
memoria allocata e inizializzata
A l b e r t o \0
M a r i a \0
L u i s a \0
R e m i g i o \0
R e n z o \0 array
array frastagliato
frastagliato
U g o \0 di
di stringhe
stringhe
B e p p e \0
D i n o \0
L a u r a \0
M i c h e l e \0
*elenco_p1D[10]
Alberto

Maria
Luisa
Remigio
Renzo
Ugo stringhe
Beppe
Dino
Laura
Michele
elenco_p1D
array di stringhe
elenco_p1D[i] è il puntatore all’i-sima

costante stringa
elenco_p1D[i] è l’i-sima costante stringa
if(confronto_stringhe
(elenco_p1D[2],elenco_p1D[3]))
……
if(strcmp(elenco_p1D[2],elenco_p1D[3]))
……
array di stringhe
9 array 2D di char (array di array di char)

9 array di puntatori a char
differenze
¾ le stringhe cui si accede con elenco_a2D[i]

sono modificabili
¾ le stringhe cui si accede con elenco_p1D[i]
sono costanti stringhe e non sono
modificabili
¾ lo spazio di memoria allocato è diverso
#include <stdio.h>
#include <string.h>
void main(){
int i;
char *elenco_nomi[]={"Giulio Giunta",
"Raffaele Montella","Umberto Scafuri",
"Angelo Ciaramella","Mariarosaria Rizzardi",
"Annalisa Amadori"};
char elenco_Corsi[6][20],array_di_char[10];
printf("\n uso di scanf per inserire le
componenti di array di char\n");
for(i=0;i<10;i++)
{
printf(" inserire %d-mo carattere\n",i);
fflush(stdin);
scanf("%c",&array_di_char[i]);
fflush(stdin);
}
printf("\n l'array di char inserito con
scanf\n");
for(i=0;i<10;i++)
printf("%c",array_di_char[i]);
printf("\n inserire i corsi\n");

for(i=0;i<6;i++)
gets(elenco_Corsi[i]);
printf("\n elenco dei corsi inseriti\n");

for(i=0;i<6;i++)
puts(elenco_Corsi[i]);
printf("\n elenco dei nomi\n");

for(i=0;i<6;i++)
printf("%s\n",elenco_nomi[i]);
}
Giulio Giunta
Raffaele Montella
Umberto Scafuri
Angelo Ciaramella
Mariarosaria Rizzardi
Annalisa Amadori
elenco_Nomi stringhe
Titolo modulo : La libreria string del C [04-C]
Proprietà e utilizzo delle principali function C in string
Argomenti trattati:
9 libreria di function C per il trattamento delle stringhe: la libreria
string
9 specifiche e funzionalità di alcune function in string

strcat()
char *strcat(char *str1, char *str2)
9
9 concatena
concatenauna unacopia
copiadella
dellastringa
stringa(puntata
(puntatada)da) str2
str2
alla
allastringa
stringa(puntata
(puntatada) str1eechiude
da)str1 chiudela lanuova
nuova
sequenza
caratteridi str1con
di str1 conililcarattere
caratterenullo
nullo
(terminatore
(terminatoredi distringa)
stringa)
9
9 ililprimo
primocarattere
caratteredi str2sisisovrappone
di str2 sovrapponeal al
terminatore
terminatoreoriginale
originaledi di str1
str1
9
9 lalastringa str2rimane
stringastr2 rimaneinalterata
inalterata
9
9 lalafunction
functionrestituisce str1 anche
restituisce str1 anchevia via return
return
9
9 non
nonsisieffettua
effettuaalcun
alcuncontrollo
controllosuisuisize
sizedegli
degliarray
array
(è(ècompito
compitodel delprogrammatore
programmatoreassicurarsi
assicurarsichechelala
stringa str1abbia
stringastr1 abbiasize
sizesufficiente
sufficienteper
percontenere
contenereii
caratteri
caratterioriginari
originaridi str1eedi
di str1 str2 eeililterminatore)
distr2 terminatore)
strcat(): esempio
#include
#include <string.h>
<string.h>
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
char s1[80],
char s1[80], s2[80];
s2[80];
gets(s1);
gets(s1);
gets(s2);
gets(s2);
strcat(s2,
strcat(s2, s1);
s1);
printf(“%s”,s2);
}}
concatena la prima stringa letta da tastiera alla

seconda stringa letta da tastiera e visualizza la
concatenazione (s2)
strchr()
char *strchr(char *str, char chiave)
9
9 restituisce
restituisceun
unpuntatore
puntatoreall’indirizzo
all’indirizzodel
delprimo
primo
carattere
caratteredella
dellastringa
stringa(puntata
(puntatada) str che
da)str che
risulta
risultauguale
ugualeal alvalore
valoredella
della variabile
variabile chiave
chiave
9
9 se
senon
nonviene
vienetrovata
trovataalcuna
alcunacorrispondenza,
corrispondenza,lala
function
functionrestituisce
restituisceununpuntatore
puntatorenullo
nullo
strchr(): esempio
#include
#include <string.h>
<string.h>
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
char
char *p;
*p;
pp == strchr(“Nel
strchr(“Nel mezzo”,‘m’);
mezzo”,‘m’);
printf(“%c\n”,*p);
}}
p punta al carattere m della costante stringa primo

argomento di chiamata
la printf produce la visualizzazione di m
strcmp()
int strcmp(char *str1, char *str2)
9
9 confronta,
confronta,secondo
secondoleleregole
regolelessicografiche,
lessicografiche,leledue
due
stringhe
stringhe(puntate
(puntateda)
da) str1, str2eerestituisce
str1,str2 restituisceun unintero
intero
ililcui
cuivalore
valoreèè
minore
minoredidizero
zero se str1èèminore
se str1 minore didi str2
str2
zero
zero se str1èèuguale
se str1 uguale aa str2
str2
maggiore
maggioredi dizero
zero se str1èèmaggiore
se str1 maggioredi di str2
str2
strcmp(): esempio
void
void main()
main() /*
/* controllo
controllo password
password */ */
{{
char
char s[80];
s[80];
while(1)
while(1) ciclo potenzialmente infinito
{{
printf(“Inserire
printf(“Inserire la la password:
password: ”);”);
gets(s);
gets(s);
if(strcmp(s,“pass”)
if(strcmp(s,“pass”) != != 0)
0)
printf(“password
printf(“password errata\n”);
errata\n”);
else
else
break;
break;
}}
printf("password
printf("password ok, ok, sisi puo'continuare\n");
puo'continuare\n");
……
……
}}
strcpy()
char *strcpy(char *str1, char *str2)
9
9 copia
copiala lastringa
stringa(puntata
(puntatada) str2in
da) str2 instr1
str1
9
9 la
lasequenza
caratteriin str2deve
in str2 deveessere
essere
chiusa
chiusadaldalcarattere
caratterenullo
nullo(terminatore)
(terminatore)
9
9 la
lafunction
restituisce str1 anchevia
via return
return
9
9 se
segli
gliargomenti
argomentidi dichiamata
chiamataper str1eestr2
per str1 str2
puntano
puntanoallaallastessa
stessastringa,
stringa,ililcomportamento
comportamento
della
dellafunction
functionnon
nonèèdefinito
definito
strcpy(): esempio
……
char
char str[80];
str[80];
strcpy(str,
strcpy(str, “Salve”);
“Salve”);
……
copia la costante stringa “Salve” in str

strlen()
unsigned int strlen(char *str)
9
9 restituisce
restituiscela
lalunghezza
lunghezzadella
dellastringa
stringa(puntata
(puntatada)
da)
str
str
9
9 la
lastringa
stringadeve
deveessere
esserechiusa
chiusadal
dalcarattere
caratterenullo
nullo
(terminatore),
(terminatore),che
che non
nonviene
vieneconteggiato
conteggiatoai aifini
fini
della
delladeterminazione
determinazionedella
dellalunghezza
lunghezza
strlen(): esempio
……
strcpy(s,
strcpy(s, “Salve”);
“Salve”);
printf(“%d”,
printf(“%d”, strlen(s));
strlen(s));
……
produce la visualizzazione del valore 5, la

lunghezza della stringa (puntata da) s
strlwr() e strupr()
char *strlwr(char *str)
9
9 converte
convertein
inminuscolo
minuscolola
lastringa
stringa(puntata
(puntatada)
da) str
str
char *strupr(char *str)
9
9 converte
convertein
inmaiuscolo
maiuscolola
lastringa
stringa(puntata
(puntatada)
da) str
str
strlwr() e strupr(): esempio
#include
#include <string.h>
<string.h>
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
char
char *s1
*s1 == “PROVA
“PROVA STRMINUSCOLO”;
STRMINUSCOLO”;
char
char *s2
*s2 == “prova
“prova strmaiuscolo”;
strmaiuscolo”;
strlwr(s1);
strlwr(s1);
printf(“%s
printf(“%s %s\n”,
%s\n”, s1,
s1, strupr(s2));
strupr(s2));
}}
prova strminuscolo PROVA STRMAIUSCOLO

strncat()
char *strncat(char *str1, char *str2, int n)
9
9 concatena
concatenaal alpiù
piùnncaratteri
caratteridella
dellastringa
stringa(puntata
(puntatada)da)
str2 alla
str2 allastringa str1eechiude
stringa str1 chiudela lasequenza
sequenzadi di
caratteri
caratteridi str1con
distr1 conililcarattere
caratterenullo
nullo(terminatore)
(terminatore)
9
9 ililprimo
primocarattere
caratteredi str2sisisovrappone
di str2 sovrapponeal alterminatore
terminatore
originale
originale didi str1
str1
9
9 lalastringa str2rimane
stringastr2 rimaneinalterata
inalterata
9
9 function
restituisce str1 ancheviavia return
return
9
9 non
nonsisieffettua
effettuaalcun
alcuncontrollo
controllosui
suisize
sizedegli
degliarray
array
(è(ècompito
compitodel delprogrammatore
programmatoreassicurarsi
assicurarsichechelalastringa
stringa
str1abbia
str1 abbiasize
sizesufficiente
sufficienteperpercontenere
contenereiicaratteri
caratteri
originari
originaridi str1eedi
di str1 str2 eeililterminatore)
distr2 terminatore)
strncat(): esempio
#include
#include <string.h>
<string.h>
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
char
char s1[80],s2[80];
s1[80],s2[80];
int
int n;
n;
gets(s1);
gets(s1);
gets(s2);
gets(s2);
nn == 79
79 -- strlen(s2);
strlen(s2);
strncat(s2,
strncat(s2, s1,
s1, n);
n);
}}
concatena i primi n caratteri della prima stringa letta da

tastiera (s1) alla seconda stringa letta da tastiera e
visualizza la concatenazione (s2)
strncmp()
int strncmp(char *str1, char *str2, int n)
9
9 confronta,
confronta,secondo
secondoleleregole
regolelessicografiche,
lessicografiche,al
alpiù
più nn
caratteri
caratteridelle
delledue
duestringhe
stringhe(puntate
(puntateda)
da) str1, str2ee
str1,str2
restituisce
restituisceun
unintero
interoililcui
cuivalore
valoreèè
minore
minoredi
dizero
zero se
sela
lasottostringa
sottostringadi str1èè
distr1
minore
minoredella
dellasottostringa
sottostringadi
di str2
str2
zero
zero se
sela
lasottostringa
distr1
uguale
ugualealla
allasottostringa
sottostringadi
di str2
str2
maggiore
maggioredi
dizero
zero se
sela
lasottostringa
distr1
maggiore
maggioredella
dellasottostringa
sottostringadi di str2
str2
strncmp(): esempio

#include
#include <string.h>
<string.h>
void
void main(int
main(int argc,
argc, char
char *argv)
*argv)
{{
if(strncmp(argv[1],argv[2],8)
if(strncmp(argv[1],argv[2],8) ==
== 0)
0)
printf(“I
printf(“I nomi
nomi sono
sono identici\n”);
identici\n”);
}}
confronta gli 8 caratteri iniziali della prima stringa e

della seconda stringa dopo il comando al sistema
operativo (modalità linea di comando) di esecuzione
del programma C
strncpy()
char *strncpy(char *str1,char *str2,int n)
9
9 copia
copiaalalpiù
piùnncaratteri
caratteridella
dellastringa
stringa(puntata
(puntatada)
da)
str2al
str2 alposto
postodei
deiprimi
primi nncaratteri
caratteridi
distr1
str1
9
9 la
lafunction
restituisce str1 anchevia
via return
return
9
9 non
nonviene
vieneinserito
inseritoililcarattere
caratterenullo
nullo(terminatore)
(terminatore)
strncpy(): esempio
……
char
char str1[180],
str1[180], str2[45];
str2[45];
gets(str1);
gets(str1);
strncpy(str2,
strncpy(str2, str1,
str1, 44);
44);
……
copia i primi 44 caratteri della stringa str1 nella

stringa str2
strstr()
char *strstr(char *str1, char *str2)
9
9 restituisce
restituisceun
unpuntatore
puntatoreall’indirizzo
all’indirizzodel
delprimo
primo
carattere
caratteredella
dellasottostringa
sottostringadella
dellastringa
stringa(puntata
(puntata
da) str1 che
da)str1 cherisulta
risultauguale
ugualeallaallastringa
stringa str2
str2
9
9 se
senon
nonviene
vienetrovata
trovataalcuna
alcunacorrispondenza,
corrispondenza,la la
function
functionrestituisce
restituisceununpuntatore
puntatorenullo
nullo
strstr(): esempio
#include
#include <string.h>
<string.h>
#include
#include <stdio.h>
<stdio.h>
void
void main()
main()
{{
char
char *p;
*p;
pp == strstr(“Sono
strstr(“Sono una
una prova”,
prova”, “una”);
“una”);
}}
p punta al carattere u della stringa primo
argomento di chiamata
la printf visualizza il carattere u (di “Sono
una prova”)
Titolo modulo : Function in C per l’elaborazione di testi [05-C]
Sviluppo di function in C per azioni su stringhe ed elaborazione di

testi
Argomenti trattati:
9 function in C per l’analisi delle componenti di un testo
9 function in C per lo string matching
9 function in C per il matching migliore
Prerequisiti richiesti: AP-09-02-T, AP-09-04-C

analisi componenti di un testo, string matching, best matching
9
9 trattamento
trattamentotesti:
testi:
word-processor
word-processor
correttori
correttori ortografici
ortografici
estrazione
estrazioneparole
parolechiave
chiavedi diun
unlibro
9
libro
9antivirus:
antivirus:
ricerca
ricercadella
dellafirma
firmadel
delvirus
9
virus
9siti
sitiweb:
web:
classificazione
classificazionedeideisiti
sitiin
infunzione
funzionedidi
determinate
determinateparole
parolerilevate
rilevatenel
nelcontenuto
contenuto
delle
dellepagine
9
pagine
9bioinformatica:
bioinformatica:
ricerca
ricercadidideterminate
determinate sequenze
sequenze all’interno
all’interno del
del
DNA
DNA
#include
#include <stdio.h>
<stdio.h> conteggio del numero di caratteri,
#define
#define TRUE
TRUE 11 del numero di parole e
#define
#define FALSE
FALSE 00 del numero di linee di un testo
void
void main()
main()
{{
char
char c;
c;
int
int conta_c,conta_p,conta_l,in_p;
conta_c,conta_p,conta_l,in_p;
conta_c
conta_c == 0;
0; conta_p
conta_p ==

Lingua

Corso Programmazione C

Caricato da

Informazioni sul documento

Descrizione:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Descrizione:

Copyright:

Formati disponibili

Corso Programmazione C

Titolo originale:

Caricato da

Descrizione:

Copyright:

Formati disponibili

Titolo unità didattica: Concetto di Algoritmo [01]

Titolo modulo : Algoritmi per esecutori umani [01-T]

Algoritmi come “istruzioni operative di uso” nella vita quotidiana

Prerequisiti richiesti: nessuno

nel senso più ampio della parola, il libretto delle istruzioni

Algoritmi de numero indorun

Troviamo […] in Firenze da novantamila bocche tra

un algoritmo viene progettato per

svitare i bulloni della ruota bucata

togliere la ruota bucata

mettere la ruota di scorta

avvitare i bulloni della ruota di scorta

si supponga che l’operazione

è necessario descrivere l’operazione

svitare un bullone della loop

svitare un bullone della

sequenza 1 (c’è la ruota di scorta):

sequenza 2 (non c’è la ruota di scorta):

Titolo modulo : Algoritmi per calcolare [02-T]

Algoritmi per risolvere semplici problemi aritmetici

Prerequisiti richiesti: AP-01-1-T

insieme qualunque di numeri Î i valori non sono predeterminati

un algoritmo viene progettato per essere eseguito

insieme qualunque di numeri Î i valori non sono predeterminati

un algoritmo viene progettato per essere eseguito

sommare un numero al totale

sequenza di operazioni elementari:

il risultato dell'esecuzione dell'algoritmo

sequenza di operazioni elementari:

il risultato dell'esecuzione dell'algoritmo

9 Non ambiguità: “ogni passo di un algoritmo deve essere

precisamente definito; le operazioni che devono essere

9 Input: "... le quantità che sono note all’inizio e che devono

essere fornite prima che l’esecutore inizi l’esecuzione

9 Output: "... la soluzione del problema; quantità che hanno

9 Efficacia: "... Tutte le operazioni da effettuare nell’algoritmo

devono essere sufficientemente elementari da poter essere,

i dati che devono essere necessariamente noti

il risultato dell'esecuzione è detto dato (o dati)

i dati che non sono né di input né di output sono

Titolo modulo : Variabili e tipi [01-T]

Nozioni di base sulle variabili in programmazione

Prerequisiti richiesti: AP-01-*-T

introdurre le nozioni di base

9 numero intero (integer)

9 stringa di caratteri (string)

una convenzione può essere:

 cognome è il nome della variabile

 cognome è il nome della variabile

variabile di tipo real

variabile di tipo integer

3.5578 variabile di tipo real

53 variabile di tipo integer

cambiamento del valore della variabile

visualizzazione (su schermo) del valore

Titolo modulo : Operazione di assegnazione [02-T]

Operazioni di base sulle variabili in programmazione

Prerequisiti richiesti: AP-02-01-T

cognome è il nome della variabile

cognome è il nome della variabile

deve coinvolgere variabili, dati e operatori

deve avere un unico valore

viene valutato il valore dell’espressione

dopo la prima assegnazione il valore

dopo la seconda assegnazione il valore

dopo la prima assegnazione a alfa è associato 4

dopo la prima assegnazione a alfa è associato 4

dopo la terza beta è indefinita,

dopo la prima assegnazione a alfa è associato 4

ma - ERRORE - un dato non può essere

usa l’alfabeto binario

considera una direttiva del programma

traduce la direttiva in una sequenza di

esegue tale sequenza di istruzioni

conserva i dati di input e di output