4   Strutture Condizionali
Upcoming SlideShare
Loading in...5
×
 

4 Strutture Condizionali

on

  • 1,395 views

 

Statistics

Views

Total Views
1,395
Views on SlideShare
1,394
Embed Views
1

Actions

Likes
0
Downloads
24
Comments
0

1 Embed 1

http://www.me2web.net 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

4   Strutture Condizionali 4 Strutture Condizionali Presentation Transcript

  • 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 (in altri linguaggi noto come CASE)
  • 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 .
  • 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.
  • 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 ) { .....
    • se a è un numero dichiarato intero ( int oppure long int) siano assolutamente equivalenti. Infatti qualsiasi valore di a diverso da 0 rende la condizione vera in entrambi i casi.
  • 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 F istruzione I O espressione
  • 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 x);
      • copio y in x (x y);
      • copio provv in y (y provv).
  • Istruzione if: esempio
    • #include <stdio.h>
    • float x, y, provv;
    • main()
    • {
    • printf (“ Introduci due numeri reali: &quot;);
    • scanf (&quot;%f%f&quot;, &x, &y);
    • if (y > x)
    • {
    • provv = x;
    • x = y; /* scambia x e y tra loro */
    • y = provv;
    • }
    • printf (&quot; Il maggiore è %f il minore è %f&quot;, x, y);
    • }
  • 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).
  • 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.
    • Poiché non esistono limitazioni a istruzione , queste possono contenere qualsiasi costrutto, compresi altri if (si parla allora di if annidati ).
  • Istruzione if ... else V F O I istruzione 1 istruzione 2 Diagramma di flusso: espressione
  • Istruzione if ... else: esempio 1
    • Realizzare un programma che richieda da tastiera due numeri interi e visualizzi sul monitor il massimo dei due.
    • Il problema si risolve con un if ... else (non considerando 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.
  • Istruzione if ... else: esempio 1
    • #include <stdio.h>
    • float x, y;
    • main()
    • {
    • printf (“ Introduci due numeri reali: &quot;);
    • scanf (&quot;%f%f &quot;, &x, &y);
    • if (x > y)
    • printf (“ Il maggiore è: %f ”, x);
    • else
    • printf (“ Il maggiore è: %f ”, y);
    • }
  • 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.
  • Istruzione if ... else: esempio 2
    • #include <stdio.h>
    • int n1, n2, quoz, resto;
    • main()
    • {
    • printf (&quot; Introdurre due numeri interi: &quot;);
    • scanf (&quot;%d%d&quot;, &n1, &n2);
    • if ((n1 >= 0) && (n2 > 0))
    • {
    • quoz = n1 / n2;
    • resto = n1 % n2; /* oppure resto = n1 - (quoz * n2); */
    • printf (“ Quoziente= %d, resto= %d &quot;, quoz, resto);
    • }
    • else
    • printf (“ Errore nei dati&quot;);
    • }
  • 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, differenza;
          • printf (“ Introduci i 2 valori (A e B): “);
          • scanf (“%d %d”, &a, &b);
          • if (a >= b)
            • differenza = a - b;
          • else
            • differenza = b - a;
          • printf (“ Valore assoluto: %d”, differenza);
        • }
  • 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.
  • 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
  • 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);
  • 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.).
  • Esempio: equazione di II grado
    • Legge i coefficienti a , b e c
    a = 0? b = 0? c = 0? Equazione indeterminata Equazione impossibile Equazione di I grado: x= -(c / b) delta = b*b – 4*a*c delta = 0? Radice doppia x = -(b / (2 * a)) w = 2*a w1= -(b / w) w2= / w delta < 0? Radice complesse coniugate: x = w 1 ± j w 2 Radice reali: x 1 = w 1 + w 2 x 2 = w 1 - w 2
  • 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 .
  • Istruzione switch O istr. 1 istr. n istr. 2 istr. 3 ................. I Diagramma di flusso: espressione caso 1 caso 2 caso 3 caso n
  • Istruzione switch
    • Sintassi:
      • switch ( espressione )
      • {
        • case <costante 1>:
        • <istruzione 1>
        • break;
        • case <costante 2>:
        • <istruzione 2>
        • break;
        • ...
        • ...
        • default:
        • < istruzione default>
      • }
  • Istruzione switch
      • espressione : espressione a valore numerico di tipo int o char , ma non float o double .
      • <costante1>, <costante1>, ... 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 .
  • 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 .
  • Istruzione switch: esempio
    • main()
    • {
    • int x;
    • printf (“ Introduci un numero intero: “);
    • scanf (“%d”, &x);
    • switch (x) {
      • case 1:
        • printf(“ Hai introdotto 1“);
        • break;
      • case 2:
        • printf(“ Hai introdotto 2“);
        • break;
      • default:
        • printf(“ Hai introdotto un numero diverso da 1 e 2“);
    • }
    • }
  • 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 (“ Introduci un numero intero: “);
    • scanf (“%d”, &x);
    • switch (x) {
      • case 92:
        • printf(“ Hai introdotto 92“);
        • break;
      • case -14:
        • printf(“ Hai introdotto -14“);
        • break;
      • case 36:
        • printf(“ Hai introdotto 36“); }
    • }