-
n1md4.
User deleted
Altre Istruzioni di controllo del programma
L'istruzione "switch"
"Switch" è un'istruzione molto efficiente dal punto di vista condizionale, perché permette un rapido confronto tra più alternative. Il seguente programma illustra il suo utilizzo e la sua sintassi:
CODICE:SPOILER (click to view)//Costrutto "switch"
#include <iostream>
using namespace std;
void main()
{
int num;
printf("Inserire un numero tra 1 e 3: ");
cin >> num;
switch(num)
{
case 1:
printf("nInserito 1!");
break;
case 2:
printf("nInserito 2!");
break;
case 3:
printf("nInserito 3!");
break;
default:
printf("nSai contare fino a 3?");
}
}
Possiamo osservare già come funziona. La sintassi è infatti la seguente:
CODICE:SPOILER (click to view)switch (variabile o espressione)
{
case costante1:
sequenza di istruzioni 1
break;
case costante2:
sequenza di istruzioni 2
break;
.
.
.
default:
sequenza di istruzioni predefinita
}
Passando una variabile o una espressione al costrutto switch, otteniamo più "case", ognuno di essi specifica tramite lo spazio "costante n " il valore della variabile o dell'espressione per eseguire quella specifica serie di istruzioni. L'ultimo caso, il caso "default", si verifica quando nessun "case" precedente è eseguito. Nel proogramma precedente, infatti, il numero da inserire doveva essere compreso da 1 a 3, se io avessi inserito 8, avrei ottenuto
L'istruzione "break" ci indica che abbiamo terminato la sequenza di istruzioni. Come per il costrutto "if", se avessimo scritto
case 1: printf("Ciao paolo");
case 2: printf("Ciao stupido");
...
non ci sarebbe stato bisogno di istruzioni "break", perché non abbiamo utilizzato più di una riga per istruzione. Se invece, come nel programma fatto, avessimo utilizzato più di una riga, benché con un'unica istruzione, avremmo dovuto mettere il "break".
Casi particolari dell'istruzione "for"
Abbiamo già visto come lavora il ciclo "for". Ci sono comunque casi particolari che sono degni di nota. Innanzitutto il ciclo "for" può difettare di elementi, come nel seguente esempio:
CODICE:SPOILER (click to view)#include <iostream>
using namespace std;
void main()
{
int x;
for(x=0; x!=123; ) //Qui manca l'espressione di Incremento !
{
printf("nInserire un numero: ");
cin >> x;
}
}
Questo ciclo è un caso particolare nel quale manca l'espressione di incremento della variabile 'x'. Cosa accade allora? Il ciclo inizia normalmente con x = 0 e chiede un numero, a 'x' viene assegnato un altro valore: quello letto da tastiera e dunque il ciclo ricomincia. Se il numero è diverso da 123, il ciclo riparte, altrimenti, il programma termina.
Un altro esempio riguarda se avessimo inizializzato la variabile 'x' prima del ciclo, in codice:
CODICE:SPOILER (click to view)x = 0;
for(; x<123; )
{
printf("n%d", x);
++x;
}
Qui il ciclo difetta di 2 espressioni: l'espressione di partenza per la variabile 'x' e l'espressione di incremento. Questo programma funziona comunque senza errori e genera il seguente output (tagliato per motivi di spazio):
Altro caso che divertirà parecchio le persone ritardate e che godono nel vedere il proprio computer "grippato" è quello del ciclo infinito. Il programma seguente scrive a video sempre la stessa cosa e non si ferma mai.
CODICE:SPOILER (click to view)#include <iostream>
void main()
{
for(;
{
printf("omg !!");
}
}
Non vi ci divertite troppo.. Di solito i cicli di questo tipo utilizzati da persone con cognizione di causa, sono realizzati nei casi come il lavoro dei processori di messaggi o dei comandi di sistemi. Comunque spesso questi cicli sono fatti in modo da terminare quando hanno svolto il loro lavoro. Si terminano da soli con l'istruzione "break".
Ultimo caso è quello del ciclo senza corpo:
CODICE:SPOILER (click to view)int sum = 0;
for(int i = 0; i <= 10; sum += i++)
printf("La somma e': %d", sum);
Questo ciclo non ha istruzionida eseguire, si limita a incrementare una variabile più volte: ad ogni ciclo, alla variabile "sum" tramite la scrittura "sum += i++" viene aggiunto il valore di 'i' aumentato di una unità. La scrittura "sum += valore" equivale a scrivere "sum = sum + valore", ma è più elegante e molti programmatori la adottano. Fate un pò voi..
Il ciclo "while"
La sintassi del ciclo "while" è la seguente:
while (espressione) istruzione;
funziona così: finché "espressione" risulta un valore valido o "true", il ciclo va avanti. Altrimenti si ferma. Ecco un esempio che stampa a video tutti i caratteri stampabili incluso (se esiste), il set di caratteri esteso:
CODICE:SPOILER (click to view)#include <iostream>
void main()
{
unsigned char ch;
ch = 32;
while(ch)
{
printf("%c", ch);
ch++;
}
}
L'output prodotto da questo programma è una serie di segnacci e lettere in successione.
Ultimo esempio: un ciclo che genera numeri casuali e che non si ferma finché il numero casuale è uguale a 100:
while (rand() != 100) ;
la funzione "rand()" non accetta argomenti e genera numeri casuali. Di solito è abbastanza veloce comunque.
Il ciclo "do-while"
E' un ciclo poco usato in confronto a "for" e "while", ma può essere utile saperne la sintassi:
CODICE:SPOILER (click to view)#include <iostream>
using namespace std;
void main()
{
int num;
do
{
printf("nInserire un numero: ");
cin >> num;
}while (num != 100);
}
Questo è il solito programma che non termina se non si inserisce il numero 100. Notare che il ciclo "do-while", poiché l'espressione di controllo è alla fine dopo il "while", viene sempre eseguito almeno una volta.
Istruzione "break" e istruzione "continue"
Come abbiamo detto, "break" interrompe un qualsiasi ciclo, invece "continue" fa in modo di saltare tutte le istruzioni dopo di esso e di ricominciare subito il ciclo con l'iterazione successiva. Ecco un esempio di entrambi e poi non parliamone più:
CODICE:SPOILER (click to view)#include <iostream>
void main()
{
int x;
for(x = 0; x <= 1000; x++)
{
if(x == 600)
break;
if(x%2) continue;
printf("%dt", x);
}
}
C'é un ciclo, va da 0 a 1000, nel primo "if", se x è uguale a 600, esce dal ciclo, altrimenti non fa nulla. Nel secondo "if", se il resto di x / 2 è 0, allora non salta all'iterazione successiva con continue, ma visualizza il numero (che è pari). Altrimenti se è un numero dispari, il resto della divisione per 2 sarà qualcosa diverso dallo 0, dunque if(x%2) sarà vera e salterà all'iterazione successiva saltando il printf del numero. L'output è la tabellina del 2 fino a 598. (600 no per il primo "if").
Istruzione "goto"
Questa istruzione può risultare utile molte volte. Vediamo un esempio:
CODICE:SPOILER (click to view)#include <iostream>
void main()
{
int x;
x = 1;
loop1:
printf("n %d ", x);
x++;
if(x < 100) goto loop1;
}
Il programma inizia.. Da ad 'x' il valore 1 e mette un'etichetta con nome "loop1" come punto di riferimento. Scrive a video il valore di 'x', la prima volta sarà dunque 1. Incrementa di 1 'x' che passerà a 2... Se 'x' è minore di 100, ritorna all'etichetta "loop1", e riparti con la visualizzazione del valore (che questa volta sarà 2), poi con l'incremento (diventerà 3), poi con il controllo, 3 è minore di 100 ? Sì, allora vai ancora a "loop1"....ecc....
L'output saranno i numeri da 1 a 99 (Se avessimo voluto i numeri da 1 a 100, avremmo dovuto mettere come condizione "if" if(x <= 100) goto loop1; )
Ok, dopo questo approfondimento, la prossima volta vedremo qualcosa di più complesso: gli array dimensionali e i puntatori.
fonte: AlexMark
.
[C++]Guida teoricaparte 5 |
