INFORMATICA
Strutture condizionali
Strutture condizionali
• Sono le istruzioni che rappresentano il ben noto costrutto
IF – THEN – ELSE della programmazione strutturata.
• In C, come peraltro in tutti gli altri linguaggi, è disponibile
in tre forme:
- if (then)
- if (then) else
- switch
© Piero Demichelis
2
L’istruzione if
• Permette di eseguire una istruzione, semplice o
composta, in modo condizionato. Sintassi:
if (espressione) istruzione ;
• espressione è di tipo logico (variabile o espressione
logica o espressione relazionale con risultato logico) e
deve essere sempre racchiusa tra parentesi tonde;
istruzione può essere semplice o composta (nel qual caso
va racchiusa tra parentesi graffe).
• Il significato è: valuta espressione e, se il risultato è vero,
esegui istruzione, altrimenti ignorala e prosegui con
l'istruzione immediatamente successiva all’if .
© Piero Demichelis
3
L’istruzione if
• Il fatto che espressione debba fornire un risultato di tipo
logico significa solo che deve fornire un risultato intero!
• Si ricordi che in C89 il tipo logico è simulato dal tipo
intero short.
• In definitiva dunque per espressione è accettabile
qualsiasi cosa fornisca un risultato intero: sarà
interpretata come falsa se il suo valore risulta 0, vera se il
suo valore risulta diverso da 0.
© Piero Demichelis
4
L’istruzione if
• Il fatto che la valutazione della condizione si riduca in
definitiva a un test per vedere se vale 0 oppure un valore
intero diverso da 0 comporta che le seguenti istruzioni:
- if ( a != 0 ) { .....
- if ( a ) { .....
siano assolutamente equivalenti. Infatti qualsiasi valore di
a diverso da 0 rende la condizione vera in entrambi i casi.
© Piero Demichelis
5
Istruzione if
• Questo costrutto realizza la struttura IF – THEN della
programmazione strutturata: l'unica differenza è l'assenza
della parola chiave THEN qui sottintesa.
• Diagramma di flusso:
V
I
espressione
F
istruzione
O
© Piero Demichelis
6
Istruzione if: esempio
• Realizzare un programma che richieda da tastiera due
numeri interi e visualizzi sul monitor il massimo dei due.
• Il problema si può risolvere con un semplice if:
-
Legge da tastiera i due numeri chiamandoli x e y;
Ipotizzo che x sia il più grande;
Se y è più grande di x allora scambio tra loro i valori di x e y;
Stampa il valore di x (che contiene sicuramente il valor massimo).
• Per scambiare tra loro i valori di x e y:
- salvo il valore di x in una variabile di appoggio (provv
- copio y in x (x
y);
- copio provv in y (y
provv).
© Piero Demichelis
x);
7
Istruzione if: esempio
#include <stdio.h>
main()
{
int x, y, provv;
printf (“\nIntroduci due numeri interi: ");
scanf ("%d%d", &x, &y);
if (y > x)
{
provv = x;
x = y;
/* scambia x e y tra loro */
y = provv;
}
printf ("\nIl maggiore è %d il minore è %d\n", x, y);
}
© Piero Demichelis
8
Osservazioni su if
• Attenzione a scrivere un’istruzione di questo tipo:
if ( a = 0 ) {.....
dove quasi certamente si intendeva porre la condizione di
a uguale a zero.
• Purtroppo la sintassi per realizzare quell’espressione
relazionale è sbagliata (si doveva scrivere a == 0) ma
l’istruzione in se è formalmente corretta per cui il
compilatore non genera errore (al più qualche
compilatore segnala un warning).
© Piero Demichelis
9
Istruzione if ... else
• Consente di eseguire una istruzione (semplice o
composta) oppure un'altra istruzione (anch’essa semplice
o composta) a seconda del verificarsi o meno di una certa
condizione.
• Sintassi:
if (espressione) istruzione 1; else istruzione 2;
• espressione è una variabile logica o una espressione con
risultato logico racchiusa tra parentesi tonde;
• istruzione 1 e istruzione 2 possono essere semplici o
composte (ovvero un gruppo di istruzioni racchiuse tra
parentesi graffe).
© Piero Demichelis
10
Istruzione if ... else
• Significato: valuta espressione e, se il risultato è vero,
esegui istruzione 1 e ignora istruzione 2 , altrimenti
ignora istruzione 1 ed esegui istruzione 2.
• Questo costrutto realizza la struttura IF - THEN – ELSE
della programmazione strutturata: anche in questo caso
se ne differenzia per l’assenza della parola chiave THEN
qui sottintesa.
© Piero Demichelis
11
Istruzione if ... else
Diagramma di flusso:
I
V
espressione
istruzione 1
F
istruzione 2
O
• Poiché non esistono limitazioni a istruzione, queste possono
contenere qualsiasi costrutto, compresi altri if (si parla allora di
if annidati ).
© Piero Demichelis
12
Istruzione if ... else: esempio 1
• Realizzare un programma che richieda da tastiera due
numeri frazionari e visualizzi sul monitor il massimo dei
due.
• Il problema si risolve con un if ... else (trascurando il caso
x = y):
- Legge da tastiera i due numeri chiamandoli x e y;
- Se x è più grande di y allora visualizza x ;
altrimenti visualizza y.
© Piero Demichelis
13
Istruzione if ... else: esempio 1
#include <stdio.h>
main()
{
double x, y;
printf (“\nIntroduci due numeri reali: ");
scanf ("%lf%lf", &x, &y);
if (x > y)
printf (“\nIl maggiore è: %lf”, x);
else
printf (“\nIl maggiore è: %lf”, y);
}
© Piero Demichelis
14
Istruzione if ... else: esempio 2
• Realizzare un programma che calcoli quoziente e resto di
due numeri interi positivi letti da tastiera e segnali errore
se uno dei due è negativo.
• Pseudocodice:
- Legge i due numeri da tastiera e li chiama n1 e n2;
- Se n1 e n2 sono entrambi positivi:
• calcola il quoziente ( n1 / n2);
• calcola il resto (n1 % n2);
• visualizza quoziente e resto;
altrimenti
• visualizza messaggio d’errore.
© Piero Demichelis
15
Istruzione if ... else: esempio 2
#include <stdio.h>
main()
{
int n1, n2, quoz, resto;
printf (“\nIntrodurre due numeri interi: ");
scanf ("%d%d", &n1, &n2);
if ((n1 >= 0) && (n2 > 0))
{
quoz = n1 / n2;
resto = n1 % n2;
/* oppure resto = n1 - (quoz * n2); */
printf (“\nQuoziente= %d, resto= %d", quoz, resto);
}
else
printf (“\nErrore nei dati");
}
© Piero Demichelis
16
Istruzione if ... else: esempio 3
• Leggere due valori A e B, e calcolarne la differenza in valore assoluto
D = |A-B|
• Soluzione
#include <stdio.h>
main()
{
int a, b, d;
printf (“\nIntroduci i 2 valori (A e B): “);
scanf (“%d %d”, &a, &b);
if (a >= b)
d = a - b;
else
d = b - a;
printf (“\nValore assoluto: %d”, d);
}
© Piero Demichelis
17
Istruzione if ... else: osservazioni
• L'istruzione che precede l'else deve essere chiusa
normalmente con il punto e virgola. L'else infatti fa parte
della struttura if ... else e non entra in gioco nell'analisi
sintattica dell'istruzione che la precede, la quale deve
avere quindi una chiusura regolare.
• Negli if annidati possono sorgere delle ambiguità. Ad
esempio nel costrutto:
if (espressione 1) if (espressione 2) istruzione 1; else istruzione 2;
non è chiaro se l'else appartiene all'if più interno o più
esterno.
• L'uso delle parentesi { e } può dirimere qualsiasi dubbio.
© Piero Demichelis
18
Istruzione if ... else: osservazioni
• La precedente istruzione può essere riscritta come:
if (espressione 1) {
if (espressione 2)
istruzione 1;
else
istruzione 2;
}
• oppure:
if (espressione 1) {
if (espressione 2)
istruzione 1;
}
else
istruzione 2;
else appartenente all’if interno
else appartenente all’if esterno
© Piero Demichelis
19
Istruzione if ... else: osservazioni
• Non conviene usare if annidati su troppi livelli: si
introducono difficoltà in fase di test (debugging) e
rallentamenti nell'esecuzione del programma.
• Inoltre sono da evitare istruzioni del tipo:
if (dato1 == dato2)
flag = VERO;
else
flag = FALSO;
che possono essere sostituite più elegantemente dalle
assegnazioni:
flag = (dato 1 == dato2);
© Piero Demichelis
20
Esempio: equazione di II grado
• L’applicazione classica della struttura if ... else è la
soluzione completa dell’equazione di II grado.
• La soluzione è fornita da un costrutto if ... else nel quale
sono annidati altre strutture di tipo if ... else e if che
risolvono i vari rami secondari.
• La soluzione deve tener conto di tutti i possibili casi che
possono determinarsi nella soluzione (equazione
impossibile, indeterminata, di I grado, ecc.).
© Piero Demichelis
21
Esempio: equazione di II grado
Legge i coefficienti a, b e c
a = 0?
b = 0?
c = 0?
Equazione
indeterminata
delta = b*b – 4*a*c
Equazione di I grado:
x= -(c / b)
Equazione
impossibile
delta = 0?
w = 2*a
w1= -(b / w)
w2= | delta | / w
delta < 0?
Radice reali:
x1= w1+ w2 x2= w1- w2
© Piero Demichelis
Radice doppia
x = -(b / (2 * a))
Radice complesse
coniugate: x = w1± j w2
22
Istruzione switch
• Quando la condizione da imporre non è intrinsecamente
binaria ma si deve distinguere tra più casi ed eseguire le
istruzioni approppriate per ogni singolo caso, l‘if annidato
può non essere più conveniente per complessità, leggibilità
e, qualche volta, anche per tempo di esecuzione
(valutazione di n condizioni).
• Per questi casi c‘è l'istruzione switch.
© Piero Demichelis
23
Istruzione switch
Diagramma di flusso:
caso 1
caso 2
I
caso n
espressione
caso 3
istr. 1
istr. 2
.................
istr. 3
istr. n
O
© Piero Demichelis
24
Istruzione switch
• Sintassi:
switch (espressione)
{
case <costante 1>:
<istruzione 1>
break;
case <costante 2>:
<istruzione 2>
break;
...
...
default:
< istruzione default>
}
© Piero Demichelis
25
Istruzione switch
- espressione : espressione a valore numerico di tipo int o char, ma
non float o double.
- <costante1>, <costante2>, ... sono costanti dello stesso tipo
dell'espressione
- <istruzione 1>, <istruzione 2>, .... sono sequenze di istruzioni
(senza graffe!)
• Significato:
- In base al valore di espressione, esegui le istruzioni del case
corrispondente.
- Nel caso nessun case venga intercettato, esegui le istruzioni
corrispondenti al caso default.
© Piero Demichelis
26
Istruzione switch: osservazioni
• I vari case devono rappresentare condizioni
MUTUAMENTE ESCLUSIVE!
• I vari case vengono eseguiti in sequenza, uno dopo
l’altro: per evitarlo è necessario interrompere il flusso
usando l’istruzione break alla fine di ogni blocco di
istruzioni (il flusso prosegue con la prima istruzione
successiva alla switch.
• Se il blocco di default non è presente e nessun case viene
soddisfatto, l’esecuzione procede con la prima istruzione
che segue la switch.
© Piero Demichelis
27
Istruzione switch: esempio
main()
{
int x;
printf (“\nIntroduci un numero intero: “);
scanf (“%d”, &x);
switch (x) {
case 1:
printf (“\nHai introdotto 1“);
break;
case 2:
printf (“\nHai introdotto 2“);
break;
default:
printf (“\nHai introdotto un numero diverso da 1 e 2“);
}
}
© Piero Demichelis
28
Osservazioni su switch
• I case possono essere indicati nell’ordine che si desidera e non in
ordine strettamente crescente o decrescente.
main()
{ int x;
printf (“\nIntroduci un numero intero: “);
scanf (“%d”, &x);
switch (x) {
case 92:
printf (“\nHai introdotto 92“);
break;
case -14:
printf (“\nHai introdotto -14“);
break;
case 36:
printf (“\nHai introdotto 36“); }
}
© Piero Demichelis
29
INFORMATICA
Strutture iterative
Strutture iterative
• Si dice ciclo (loop) una sequenza di istruzioni che deve
essere ripetuta più volte consecutivamente.
• Si consideri ad esempio il calcolo del fattoriale di un
numero n > 0:
n! = n . (n - 1) . (n - 2) ........ 2
con il caso particolare 0! = 1.
• Sembrerebbe che basti una semplice assegnazione, ma
se non si conosce a priori il valore di n, è impossibile
scrivere l’istruzione che esegue il calcolo del fattoriale,
poiché la formula contiene tanti fattori quanti ne indica n.
© Piero Demichelis
31
Strutture iterative
• Proviamo a riscrivere la formula del fattoriale come:
n! =(( ..... (((1 . 2) . 3) . 4) .....(n - 1) . n)
• Osservando la formula possiamo:
- attribuire ad una variabile fatt il valore 1,
- quindi moltiplicare fatt per 2 ed attribuire il risultato
ancora a fatt,
- poi fatt per 3 e così via fino a n.
© Piero Demichelis
32
Strutture iterative
• L'algoritmo di soluzione può quindi essere formalizzato
mediante un algoritmo iterativo:
- assegna il valore 1 a fatt;
- se n vale 0, hai finito;
- con k che varia da 1 a n con passo unitario esegui:
• moltiplica fatt per k ed attribuisci il risultato a fatt.
• Il prodotto fatt . k viene eseguito n volte com’è
necessario.
• La scelta di algoritmi ciclici influenza spesso altri
componenti del programma, come la base dati.
© Piero Demichelis
33
Strutture iterative
• Nel linguaggio C i cicli iterativi sono realizzati da tre
costrutti:
while
: realizza il costrutto WHILE - DO;
do – while : realizza il costrutto REPEAT - UNTIL;
for
: realizza il ciclo a contatore.
© Piero Demichelis
34
Istruzione while
• Sintassi:
while (<condizione>)
<istruzione>
I
<condizione>
• Finché <condizione> è
vera esegue <istruzione>
che può essere semplice
o composta.
© Piero Demichelis
F
O
V
<istruzione>
35
Istruzione while : osservazioni
• Il costrutto while realizza il costrutto while – do della
programmazione strutturata.
• <condizione> deve essere di tipo logico ed è ricalcolata ad ogni
iterazione;
• se <condizione> risulta falsa già alla prima iterazione <istruzione>
non viene eseguita neppure una volta;
• se <condizione> non diventa mai falsa non si esce mai dal loop!
• essendo <istruzione> una normale istruzione composta può
contenere qualsiasi tipo di istruzione, in particolare altri while, dando
origine (come per l’if) a while annidati.
© Piero Demichelis
36
Istruzione while: esempio
• Leggere un numero intero N da tastiera, e calcolare la
somma S dei primi N numeri interi.
• Pseudocodice:
-Legge N da tastiera;
-inizializza l’accumulatore di risultato S a 0;
-inizializza un contatore indice a 1;
-finché indice <= N;
•aggiungi all’accumulatore S il valore di indice;
•aggiorna indice (ovvero incrementalo di 1);
-visualizza il risultato finale (valore di S).
© Piero Demichelis
37
Istruzione while: esempio
#include <stdio.h>
main()
{
long int N, indice, S;
printf (“\nIntroduci N: ”);
scanf (“%ld”, &N);
indice = 1;
S = 0;
/* inizializzazioni */
while (indice <= N)
{
S += indice;
/* operazione iterativa */
indice++;
/* aggiornamento condizione */
}
printf (“\nSomma = %ld”, S);
/* output */
}
© Piero Demichelis
38
Esempio: calcolo del seno
• Calcolare la funzione seno x mediante lo sviluppo in serie
x3 x5 x 7
sin  x   x 



3! 5! 7!
sino quando i fattori sono > 0.00005.
• Osservando i singoli fattori dello sviluppo si può osservare
che:
x  x
fatt  fatt. prec. 
 N  1   N  2 
• con N che varia a passi di 2.
© Piero Demichelis
39
Esempio: calcolo del seno
• Il primo termine lo conosciamo all’atto della lettura da tastiera del
valore in radianti dell’angolo.
• Tutti gli altri termini possono essere ricavati in successione a partire
dal primo applicando la relazione che abbiamo trovato che lega un
termine al successivo.
• Diagramma di flusso
Start
Legge il valore dell’angolo x
1
© Piero Demichelis
40
Esempio: calcolo del seno
1
Inizializzazioni:
n
termine
senx
termass
1
x
x
|x|
termass > soglia ?
Falso
Visualizza senx
Vero
Calcola nuovo termine e lo
somma a senx.
n
n+2
termass
|termine|
© Piero Demichelis
Visualizza sin(x)
Stop
41
Esempio: calcolo del seno
#include <stdio.h>
#include <math.h>
const double soglia = 0.00005;
main()
{
double x, senx, termine, termass, n;
printf (“\nAngolo in radianti: ");
scanf ("%lf ", &x);
n = 1;
senx = x;
if (x < 0)
termass = - x;
Inizializzazioni
else
termass = x;
termine = x;
© Piero Demichelis
42
Esempio: calcolo del seno
/*
Ad ogni ciclo calcola un nuovo contributo
*/
while (termass > soglia)
{
termine = - termine * x * x / ((n+1) * (n+2)); /* nuovo termine */
senx += termine;
/* accumula in senx */
n += 2;
/* aggiorna n */
if (termine < 0)
/* aggiorna il valore assoluto di termine */
termass = -termine;
else
termass = termine;
}
printf ("\nIl seno di %lf e' %lf\n", x, senx);
printf ("\nValore fornito dalla funzione di libreria: %lf\n", sin(x));
}
© Piero Demichelis
43
Istruzione for
• In altri linguaggi il costrutto for permette di eseguire una
istruzione, semplice o composta, per un numero
prefissato di volte (ciclo a contatore).
• Nel linguaggio C è più generale, al punto da poter essere
assimilata ad una particolare riscrittura del costrutto
while.
• Sintassi:
for (<inizializzazione>; <condizione>; <aggiornamento>)
<istruzione>;
© Piero Demichelis
44
Istruzione for
• <condizione> è un'espressione logica;
• <inizializzazione> e <aggiornamento> sono invece
espressioni di tipo qualsiasi.
• L'istruzione for opera secondo il seguente algoritmo:
- viene calcolata <inizializzazione>;
- finché <condizione> è vera (valore non nullo)
• viene eseguita <istruzione>;
• viene calcolato <aggiornamento>.
© Piero Demichelis
;
45
Istruzione for
Diagramma di flusso:
I
Calcola l’espressione
<inizializzazione>
<condizione>
F
O
V
<istruzione>
Calcola l’espressione
<aggiornamento>
© Piero Demichelis
46
Istruzione for
• Di fatto il costrutto for è del tutto equivalente al seguente
frammento di programma:
<inizializzazione>
while (<condizione>)
{
<istruzione>
<aggiornamento>
}
• Poiché non vi sono restrizioni sulla <istruzione> da
eseguire nel corpo del ciclo, questa può contenere a sua
volta istruzioni for (for annidati ), o altri costrutti di
controllo (if, while, switch, ecc.).
© Piero Demichelis
47
Istruzione for
• Problema: leggere da tastiera un valore intero N e un
carattere carat, e visualizzare una riga di N caratteri carat
- esempio: N = 10, carat = ‘*’
output
**********
- soluzione iterativa: ripeti N volte l’operazione “stampa carat ”
- Programma:
#include <stdio.h>
main() {
int N, indice;
char carat;
printf ("\nIntroduci un carattere e un intero: ");
scanf ("%c%d", &carat, &N);
for (indice=0; indice<N; indice++)
printf ("%c", carat);
/*senza ‘\n’ !!!!*/
printf ("\n");
}
© Piero Demichelis
48
Istruzione for: esercizio
• Leggere da tastiera un numero intero N; successivamente
leggere da tastiera N numeri interi, e calcolarne la media.
Si controlli che ogni numero inserito sia compreso tra 0 e
30; in caso contrario, il numero deve essere ignorato. Al
termine visualizzare la media dei soli valori validi.
• Analisi:
- Problema iterativo
- Media
- Controllo del valore inserito
© Piero Demichelis
49
Istruzione for: soluzione
• Pseudocodice:
Legge N da tastiera;
Inizializza a 0 il totale (totale) ;
Inizializza a 0 un contatore per i validi (cont_validi);
Con un indice ind che va da 1 a N:
• legge un valore num da tastiera;
• Se num è < 0 oppure > 30
segnala che non è un valore valido,
- altrimenti :
accumula num nel totale;
incrementa di 1 cont_validi;
- Calcola la media (totale / cont_validi).
-
© Piero Demichelis
50
Istruzione for: soluzione
#include <stdio.h>
#include <conio.h>
main()
{
int num, ind, N, totale, cont_validi;
clrscr();
totale = 0;
cont_validi = 0;
printf ("\nIntroduci N: ");
scanf ("%d", &N);
© Piero Demichelis
51
Istruzione for: soluzione
for (ind = 1; ind <= N; ind++)
{
/* per ogni valore introdotto */
printf ("\nIntroduci il valore di num %d: ");
scanf ("%d", &num);
if (num < 0 || num > 30)
/* controllo validità
*/
printf ("\nValore non valido");
else
{
totale += num;
/* accumula num nel totale */
cont_validi++;
}
}
printf ("\nLa media è: %lf\n", (float)totale/(float)cont_validi);
}
© Piero Demichelis
52
Esercizio: generazione di un triangolo
Realizzare un programma in grado di generare un
triangolo di "*" sul video, le cui dimensioni (numero di
righe su cui si sviluppa il triangolo) siano fornite da
tastiera.
*
* *
* * *
* * * *
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
* *
* * *
* * * *
Poiché il video è composto da 80 colonne, sia 80 la
dimensione massima.
© Piero Demichelis
53
Generazione di un triangolo: soluzione
• Una possibile organizzazione del programma potrebbe
essere costituito dalla seguente struttura:
- controlla se il numero di colonne (calcolato in base al
numero di righe) è < di 80;
- se nrighe è il numero di righe da stampare, per nrighe
volte esegui:
- scrivi un certo numero di spazi;
- scrivi un certo numero di "*".
© Piero Demichelis
54
Generazione di un triangolo: soluzione
• Per la relazione tra il numero di spazi ed il numero di '*' si consideri
la figura:
a
1
a
2
a
3
a
n
riga
riga
riga
riga
*
* * *
* * * * *
* * * * * * *
o
• N spazi - nell'ultima riga se ne devono stampare 0, nella penultima
1, nella terzultima 2, ecc.: in una generica riga rigacorr saranno:
nrighe - rigacorr;
o
• N asterischi - nella prima riga se ne deve stampare 1, nella seconda
3, nella terza 5, ecc.: nella generica riga rigacorr saranno:
(rigacorr*2) - 1.
© Piero Demichelis
55
Generazione di un triangolo: soluzione
#include <stdio.h>
main()
{
int nrighe, ncolon, rigacorr, coloncorr;
printf ("\nNumero righe triangolo= ");
scanf ("%d", &nrighe);
printf ("\n");
ncolon = nrighe * 2 - 1;
/* calcola il numero di colonne */
if (ncolon >= 80)
printf ("\nErrore: troppe colonne!");
else
{
© Piero Demichelis
56
Generazione di un triangolo: soluzione
for (rigacorr = 1; rigacorr <= nrighe; rigacorr++)
{
for (coloncorr = 1; coloncorr <= (nrighe - rigacorr); coloncorr++)
printf (" ");
/* output degli spazi */
for (coloncorr = 1; coloncorr <= (rigacorr*2)-1; coloncorr++)
printf ("*");
*/
printf ("\n");
/* output degli asterischi
/* output di new line: finita una riga!
*/
}
}
}
© Piero Demichelis
57
Istruzione do ... while
• Sintassi:
do
<istruzione>
while (<condizione>)
I
<istruzione>
• Ripeti <istruzione>,
che può essere semplice
o composta,
finché <condizione>
è vera.
© Piero Demichelis
V
<condizione>
F
O
58
Istruzione do ... while: osservazioni
• L’istruzione do ... while realizza il costrutto repeat - until della
programmazione strutturata.
• <condizione> deve essere di tipo logico ed è calcolata ad ogni
iterazione;
• <istruzione> pertanto è sempre eseguita almeno una volta (anche se
<condizione> è subito falsa);
• se <condizione> non diventa mai falsa non si esce mai dal loop!
• come per gli altri costrutti<istruzione> è una normale istruzione
composta e può contenere qualsiasi tipo di istruzione o costrutto
(altri while, if, switch, ecc.), dando origine a strutture annidate.
© Piero Demichelis
59
Istruzione do ... while: esempio
• Calcolare il valore della serie armonica:
1 1
y n  1  
2 3
1

n
terminando il calcolo quando un fattore contribuisce per
meno di 0.00005.
• La serie armonica si trova in numerose applicazioni quale,
ad esempio, il calcolo degli interessi composti.
© Piero Demichelis
60
Istruzione do ... while: esempio
#include <stdio.h>
const double soglia = 0.00005;
main()
{
double y;
int n;
y = 0.0;
n = 1;
do
{
y += 1.0 / n;
n++;
}
while (1.0 / n > soglia);
printf ("\nIl valore (trovato per n= %d) è: %lf ", (n-1), y);
}
© Piero Demichelis
61