Introduzione:

In questa guida affronteremo le basi della Programmazione: vedremo

come interloquire e come interfacciarsi con la nostra macchina per creare
programmi con nozioni semplici e veloci.
-------------------------------------------------------------------------------------------------
“Il computer non è una macchina intelligente che aiuta le persone stupide,
anzi è una macchina stupida che funziona solo nelle mani delle persone
intelligenti.” -Umberto Eco
-------------------------------------------------------------------------------------------------
Per parlare con una macchina dovremo prima di tutto apprendere le
regole del “Linguaggio di Programmazione”:

Un Linguaggio di Programmazione è composto da regole rigide che non

lasciano spazio ad errori (proprio come la grammatica per le lingue).
Infatti se vogliamo pensarla a linee generali imparare un linguaggio di
programmazione non è differente dall'imparare una lingua straniera.
-------------------------------------------------------------------------------------------------
“I computer sono incredibilmente veloci, accurati e stupidi. Gli uomini
sono incredibilmente lenti, inaccurati e intelligenti. L'insieme dei due
costituisce una forza incalcolabile.” -Albert Einstein
-------------------------------------------------------------------------------------------------
Quando vi interfaccerete con un computer tramite un compilatore ed un
Linguaggio di Programmazione, non potrete dare per scontato NULLA,
poiché non appena ometterete qualcosa, il computer non perderà
l'occasione di deludervi e pugnalarvi alle spalle. :)

LINGUAGGIO C & C++

Esistono una infinità di Linguaggi di Programmazione,
spesso varianti o derivati da Linguaggi già esistenti. Se in
futuro avrete modo di vedere altri “Codici di Pro-
grammazione” riuscirete infatti a constatare voi stessi che
per quanto possa cambiare di poco la loro “grammatica” o i
“nomi” di alcune funzioni, la logica alla base di ogni Linguaggio è spesso
simile, se non addirittura la stessa.
 - Indice -
Variabili ….................................................................................. p. 3
Input e Output ….................................................................................. p. 5
Commenti ….................................................................................. p. 8
Condizioni ….................................................................................. p. 9
Selettore IF ….................................................................................. p. 10
Connettivi Logici ….................................................................................. p. 12
Selettore Switch ….................................................................................. p. 13
Iterazione While ….................................................................................. p. 14
Iterazione DoWhile ….................................................................................. p. 15
Iterazione For ….................................................................................. p. 16
ESEMPIO COMPLETO ….................................................................................. p. 18
Funzioni (wip) ….................................................................................. p. 19
Parte 1: “Da dove si inizia a scrivere il codice?”
Alla base di tutta la programmazione in C, C++, JAVA o qualsivoglia, ci sarà sempre un metodo
main(). Questo metodo sarà lo “strumento” che ci permetterà di collaudare i nostri programmi
permettendoci di scrivere ed eseguire le istruzioni che abbiamo messo al suo interno.

La sua dichiarazione avviene tramite la dicitura int main() , seguita da delle parentesi graffe:
Queste contengono il corpo del nostro programma (quindi “contengono il nostro blocco
d'istruzioni”).

Sopra il nostro int main(), avremo degli header contenenti le varie librerie (#include <libreria>)
utilizzate da programma ed il namespace. Le librerie sono una raccolta di funzioni e programmi
“già scritti” richiamati per permetterci di svolgere operazioni semplici. Il namespace std (dove
“STD” significa “STANDARD”) contiene invece le funzioni e le variabili standard del C ++ (è quindi
utile quando si usano spesso le funzioni standard del C ++).

Variabili & Costanti

All'inizio della programmazione, all'interno del nostro main, lavoreremo su due tipi di dati
principalmente utilizzando metodi e funzioni:
• Variabili
• Costanti
Come suggeriscono i loro stessi nomi, la differenza sta tutta nel fatto che i primi sono valori che
possono cambiare nel corso dell'elaborazione del programma (e quindi variare) mentre i secondi
rappresentano un valore fisso che, a prescindere di tutto, non verrà cambiato (e quindi costanti).

Sia Variabili che Costanti sono caratterizzate in primo luogo da un TIPO di valore che ne definirà il
contenuto; questi potranno essere dunque di:

Tipo In C / C++ Contenente:

Intero int NOME_VARIABILE; Interi positivi e negativi (es: 9, oppure -2)
Reale float NOME_VARIABILE; Decimali positivi e negativi (es: -13.44)
Alfanumerico char NOME_VARIABILE; es: ABC, abc, 123, @£$, :!?, (ASCII) ... etc, etc
Logico bool NOME_VARIABILE; TRUE oppure FALSE
La seconda ed ultima cosa che distingue una variabile è infine il suo NOME_VARIABILE; che avrà la
funzione di IDENTIFICATORE (ovvero di identificare quella specifica variabile). Dare nomi
significativi alle variabili non solo aiuterà il lettore a capire immediatamente a che tipo di dato
stiamo facendo riferimento, ma anche a ricordarsene più facilmente.

Esempio di una Variabile e di una Costante:

Se volessi creare una variabile che nel tempo varierà, come ad esempio la mia età corrente,
dichiarerò una variabile INTERA dandole un nome SIGNIFICATIVO che mi aiuti a ricordare il
contenuto dei suoi dati; in programmazione, un esempio di dichiarazione potrebbe essere:

int anni;

Una costante invece ha un valore fisso: se ad esempio si volesse fare un controllo per verificare
che la mia età rientri nella cerchia dei “maggiorenni”, basterà verificare se il numero
precedentemente contenuto nella variabile anni sia maggiore o uguale di 18, dove 18 è un valore
costante.

( anni > 18 )

RICORDIAMO che il nome di una variabile NON può iniziare con un numero o contenere spazi o
caratteri speciali (comprese le lettere accentate), se volessimo avvalorarci di una parola
composta, come ad esempio “valore medio”, potremo al più usare una underscore
(valore_medio), sintetizzarlo utilizzando le sue iniziali (VM) oppure scriverlo banalmente senza
spazio (ValoreMedio).
_______________________________________________________________________________

NOTA BENE: Quando si dichiara una o più variabili dello stesso tipo (int, float, char, bool), è
possibile farlo separatamente tramite dichiarazioni uniche oppure in successione nella stessa riga
della prima dichiarazione utilizzando una virgola per distinguere una variabile dall'altra.
È inoltre possibile dare fin dall'inizio un valore ad una variabile nel momento stesso in cui questa
viene dichiarata.

Esempio di Dichiarazione di Più Variabili & Preassegnamento:

Si supponga di voler inizializzare TRE variabili di tipo INTERO che andranno a contenere le
informazioni relative ad un determinato giorno, mese, anno. Ci è consentito fare:

int gg, mm, aaaa;

Dove:
• int indica il TIPO delle nostre variabili;
• gg, mm, aaaa rappresentano il NOME delle nostre variabili;
• la virgola ha il compito di dividere una variabile dall'altra;
• il punto e virgola conclude l'istruzione di dichiarazione.

Possiamo inoltre dichiarare fin da subito il valore iniziale di una variabile, ovvero:

int anno = 2022;

Comunicazione INPUT (cin) & OUTPUT(cout) con una macchina:
Con il termine “Dare in Input” si intende dare in ingresso dei dati che consentiranno al nostro
programma di elaborare informazioni e risultati (solitamente, nei nostri primi programmi c, gli
input saranno principalmente tutti da tastiera).

Con il termine “Ricevere in Output” invece si intende la visualizzazione dei dati in uscita offerti dal
programma all'utente: non sono necessariamente i risultati dei calcoli, ma possono essere anche
variabili stesse o “stringhe” contenenti parole e frasi.

L'input è quindi ciò che noi diamo alla nostra macchina, mentre output è ciò che la nostra
macchina ci “restituisce e comunica”.

• In Programmazione C, la funzione di INPUT è:

cin >> nome_variabile;

• In Programmazione C, la funzione di OUTPUT è:

cout << nome_variabile;

Dove in entrambi, gli operatori “<<” e “>>” indicano il “flusso dei dati”, che saranno in ingresso o
in uscita, ovviamente. ENDL invece è una costante che sostituisce i caratteri di fine riga.

• Con la prima istruzione (INPUT) avremo un inserimento da tastiera, dove prenderemo la variabile
intera nome_variabile e la valorizzeremo con dei valori appropriati. Nel momento in cui inseriremo
un valore che non è consono alla nostra variabile, il nostro programma interromperà la
compilazione (Come se il nostro programma si aspettasse un valore numerico intero, ma noi invece
digitiamo un valore alfanumerico) .

• Con la seconda istruzione (OUTPUT) invece avremo una visualizzazione su schermo del
contenuto della nostra variabile e quindi, se ad esempio in fase di inserimento (input / cin)
avessimo valorizzato la nostra nome_variabile (ipoteticamente presa come intero) con il valore
“2022”, avremmo avuto in visualizzazione (o “lettura”) tale valore.
INOLTRE:
Il cout può contenere anche solamente del testo, oppure, del testo + la nostra variabile.
Infatti, in un ipotetico inserimento da tastiera del valore anno, sarebbe consono ed opportuno
procedere seguendo la seguente sintassi:

Quello che vedremo su schermo alla fine sarà:

Se notiamo i due cout della riga 18 e 19 però, la presenza della variabile “anno” in output non è
l'unica differenza. Aggiungere un “<<endl” dopo il testo del nostro cout prima del punto e virgola è
solo una implicazione che sta a significare “End Line”: Quello che succede se si aggiunge “<<endl”
al termine della nostra visualizzazione cout è l'implicazione che la nostra prossima linea di codice
verrà svolta nella riga sotto (cout o cin che sia).

Se infatti il primo cout fosse stato scritto come cout<<''Inserisci anno corrente: ''<<endl; dove
endl non era presente nel nostro caso preso in esempio in precedenza, avremmo avuto in output:

CON << ENDL SENZA << ENDL;

L'inserimento del numero 2022 è avvenuto L'inserimento del numero 2022 è avvenuto
nella riga successiva. nella stessa riga.
Endl però non è l'unico modo per “andare a capo alla riga dopo”. Nei “testi” all'interno dei cout
infatti sarà possibile utilizzare dei caratteri speciali che svolgeranno particolari compiti all'interno
del nostro codice in visualizzazione, nel dettaglio, con:

\n Mando la riga a capo.

\t Spazia il testo verso destra.
\f Salta la pagina.
\'' Permette di avere un “ all'interno del nostro testo,
(altrimenti verrebbe considerato come chiusura
stringa).
\\ Introduce la barra “\” nel nostro cout.

Conclusione della prima parte introduttiva:

Se dovessimo infine fare un esercizio che sintetizzasse quel poco che abbiamo visto fino ad ora
della programmazione C, potremmo scrivere un codice di un programma che, avuto in ingresso
l'altezza e la base di un rettangolo, restituisca in uscita la sua area.
EXTRA:
Ricordiamoci inoltre l'importanza dei commenti!

“Cosa sono i commenti nella programmazione?”

I commenti in C rappresentano note, appunti, pensieri o spiegazioni che sintetizzano nella riga di
codice corrente quello che sta succedendo.

Prendendo come esempio l'esercizio svolto nella pagina precedente, potremmo ipoteticamente
aggiungere dei commenti che spieghino il significato del nostro codice:

Ci basterà guardare le righe di codice: 7-8, 11, 17 e 20 per capire di cosa stiamo parlando.
Possiamo notare fin da subito che esistono sostanzialmente DUE tipi di forme di “commento”
possibile col quale possiamo “commentare” il programma:

• Quello identificato con // commento :

(Esempio Riga 11 e 17): È un commento solitamente breve, non appena andiamo alla
riga successiva, non saremo più sotto la condizione di commento, e quello che scriveremo
avrà di nuovo validità. Come mostrato nella riga 20, inoltre, possiamo anteporlo dopo il
codice: il codice non sarà visto come commento, ma quello che verrà scritto dopo le // lo
sarà, fino al rinnovo della riga successiva.
• Quello identificato come /* commento */ :
(Esempio riga 7-8): È un commento solitamente molto lungo, che prende più righe di
codice. Con questo formato si inserisce un /* all'inizio, senza aver bisogno per ogni riga di
specificare che è un commento: fin tanto che non inseriamo */ , il nostro commento
continuerà ad estendersi riga per riga.
Parte 2: “Nel vivo della programmazione!”
Quasi tutta la programmazione si muove sotto delle condizioni logiche (o ”test”), che avranno
come risultato in output “VERO” oppure “FALSO”. Nel nostro codice quindi ci troveremo spesso
davanti a confronti i quali implicheranno una condizione dove “se “Condizione” è verificata
(Quindi se Condizione == TRUE), allora svolgi una determinata azione, altrimenti fai quest'altra”.

Mediante gli Operatori Relazionali è possibile effettuare un confronto tra due variabili ed ottenere
di conseguenza un risultato TRUE oppure un risultato FALSE.

Gli Operatori Relazionali, come in Matematica, sono:

Nome Operatore Operatore Esempio
Maggiore > (Num1 > Num2)
Minore < (Num1 < Num2)
Maggiore Uguale >= (Num1 >= Num2)
Minore Uguale <= (Num1 <= Num2)
Uguale == (Num1 == Num2)
Diverso != (Num1 != Num2)

Una volta assegnati a Num1 e Num2 due valori, non sarà difficile capire quindi in che situazione si
ottenga in output il risultato VERO ed il risultato FALSO.

Esempi di Operatori Relazionali:

Supponiamo di avere:
int Num1 = 3;
int Num2 = 8;
Ipoteticamente, quello che otterremo da questi vari confronti sarà:
(Num1 > Num2) // FALSE, Num1 non è maggiore di Num2!
(Num1 < Num2) // TRUE, Num1 è minore di Num2!
(Num1 >= Num2) // FALSE, Num1 non è maggiore\uguale di Num2!
(Num1 <= Num2) // TRUE, Num1 è minore\uguale di Num2!
(Num1 = = Num2) // FALSE, Num1 non è UGUALE a Num2!
(Num1 ! = Num2) // TRUE, Num1 è DIVERSO da Num2!

E se adesso ci chiedessimo: “Come e Dove utilizzo queste condizioni ed in che modo?”

Un'applicazione consona di questi test potrebbe essere quindi utilizzata negli argomenti dei
Selettori (if, switch) o nei Cicli di Iterazione (while, do-while e for).

Attenzione: è un errore molto frequente agli inizi della programmazione quello di utilizzare
l'operatore di “uguaglianza” con un singolo “=” anziché utilizzare il doppio uguale ( = = ).

• L'uguale viene usato per valorizzare una variabile: ( int a = 5; ) ;

• Il doppio uguale viene utilizzato per confrontarla con un altro valore: (a == 5) >> TRUE !
Selettori IF

”IF”, dall'inglese letteralmente “SE”: Il suo utilizzo è letteralmente lo stesso di quello che
potremmo avere nel parlato: tant'è che quando scriveremo del codice ci ritroveremo davanti ad un

SE <CONDIZIONE> è verificata → Allora svolgi <BLOCCO DI ISTRUZIONI>

La sua implementazione del codice è strettamente collegata con la pagina precedente di questo
documento e viene riportata in C/C++ tramite la seguente scrittura:
if (condizione) // Dove Condizione è una condizone Logica TRUE o FALSE;
{
<blocco di istruzioni> // Contiene il nostro codice in C/C++;
}

Il blocco di selezione IF può inoltre avvalersi di una seconda funzione, denominata “ELSE”,
dall'inglese “ALTRIMENTI”: La sua implementazione non è obbligatoria ma ci consente di scegliere
tra due differenti blocchi da eseguire in base all'esito della nostra condizione.

if (condizione) //”Se questo è vero”

{
<blocco di istruzioni 1> // Contiene le istruzioni nel caso in cui (condizione) == TRUE;
}
else // “Altrimenti”
{
<blocco di istruzioni 2> // Contiene le istruzioni nel caso in cui (condizione) == FALSE;
}

Esempio di un Selettore IF:

Si vuole ricevere in ingresso (input) gli anni di uno studente e verificare se questo ha raggiunto la
maggiore età. In uscita output avremo dunque che:

• SE la condizione è verificata che età sia maggiore\uguale di 18,

• ALLORA “lo studente è maggiorenne”
• ALTRIMENTI “lo studente non è maggiorenne.”;

la sua implementazione è quindi:

int anni;
cin>>anni;
if (anni > = 18) // SE (condizione == true) ALLORA:
{
cout<<''Lo studente è maggiorenne!'';
}
else // ALTRIMENTI
{
cout<<''Lo studente è minorenne!'';
}
Selettori IF (annidati)

Con “IF ANNIDATO” si intende un << un if dentro ad un altro if >>, questa pratica è comunemente
utilizzata quando dobbiamo svolgere più controlli all'interno del nostro programma.

Esempio IF nidificato:

“Si vuole ricevere in ingresso la base e l'altezza di due rettangoli, calcolarne la rispettiva area per
poi mandare in output l'informazione di quale dei due rettangoli abbia l'area maggiore”

ATTENZIONE: Gli output finali non saranno banalmente due, ma ben sì tre, perché non
possiamo escludere che il primo ed il secondo rettangolo abbiano la stessa area.
Un PESSIMO UTILIZZO dei nostri strumenti ci potrebbe spingere ad utilizzare TRE VOLTE if, facendo
quindi TRE CONFRONTI dove verifichiamo che SE (A1 > A2) allora avrò un output, SE (A1 < A2)
allora avrò un altro output e SE ( A1 = = A2 ) avrò un altro output differente ancora.
Un OTTIMO UTILIZZO dei nostri strumenti invece ci porterà ad avere solamente DUE CONFRONTI
if, poiché ci basterà verificare che: SE (A1 > A2) allora avrò un output, ALTRIMENTI, SE (A1 < A2)
allora avrò un altro output ALTRIMENTI avrò un altro output differente ancora.
int main() {
int b1, h1, b2, h2;
// Inserimento Rettangolo 1;
cout<<''Inserisci la base del primo Rettangolo: '';
cin>>b1;
cout<<''Inserisci l'altezza del primo Rettangolo: '';
cin>>h1;
// Inserimento Rettangolo 2;
cout<<''Inserisci la base del secondo Rettangolo: '';
cin>>b2;
cout<<''Inserisci l'altezza del secondo Rettangolo: '';
cin>>h2;
//Calcolo delle varie Aree;
int A1 = b1*h1;
int A2 = b2*h2;
//Inizio dei controlli IF:
if (A1>A2) // “SE (A1 E' MAGGIORE) ALLORA...”
{cout<<''Il primo Rettangolo ha l'area maggiore'';}
else if (A2>A1) // (← if nidificato) “...ALTRIMENTI, SE (A2 E' MAGGIORE), ALLORA...”
{cout<<''Il secono Rettangolo ha l'area maggiore'';}
else //”...ALTRIMENTI...”
{cout<<''I due rettangoli hanno la stessa Area.'';}

return 0;
}

L'if che segue l'else è un “if nidificato”: In questo caso è un “if nidificato di secondo grado.”
Il grado sta ad indicare quanto “nidificato” è il nostro if: più è nidificato, più alto sarà il suo grado.
Connettivi Logici
La Condizione Logica è un'istruzione che come risultato ha due possibili output: VERO o FALSO.
I Connettivi Logici hanno il compito di lavorare i risultati della “Condizione Logica”, mettendoli a
confronto diretto: negandoli (!), congiungendoli (&&) o eventualmente disgiungendoli (OR).

<< Questi Connettivi Logici sono NOT (!), AND (&&), OR (||) >>
• NOT: Come nella lingua parlata, anteporre il connettivo “NON” ribalta il senso della frase.
Supponiamo di avere una variabile booleana “A”, visualizziamo la ipotetica “Tabella della Verità”.
A !A
TRUE FALSE
FALSE TRUE

• AND: La “Congiunzione” tra DUE variabili booleane “A” e “B” ha come risultato il valore VERO
solo se ENTRAMBE le variabili hanno valore VERO. Visualizziamo la “Tabella della Verità”.
A B A && B
TRUE TRUE TRUE
TRUE FALSE FALSE
FALSE TRUE FALSE
FALSE FALSE FALSE

• OR: La “Disgiunzione” tra DUE variabili booleane “A” e “B” ha come risltato il valore VERO solo
se ALMENO UNA delle DUE variabili ha VERO come valore. Visualizziamo la “Tabella della Verità”.
A B A || B
TRUE TRUE TRUE
TRUE FALSE TRUE
FALSE TRUE TRUE
FALSE FALSE FALSE

Esempi di Connettivi Logici all'interno degli if

Dichiariamo due variabili bool cond1=TRUE, cond2=FALSE; e studiamone il comportamento:

if (!cond2) → NOT ribalta il valore di cond2, che di base sarebbe FALSO, quindi
if viene eseguito, poiché “Se cond2 è falso, allora avremo...”

if (cond1 && cond2) → AND vuole che sia cond1 che cond2 siano VERE, quindi l'if non
viene eseguito. “Se cond1 e cond2 sono entrambe vere, allora...”

if (cond1 && !cond2) → AND vuole che sia cond1 che cond2 siano VERE, NOT ribalta il
valore di cond2, quindi l'if viene eseguito! “Se cond1 è vera
e cond2 è falsa, allora...”

if (cond1 || cond2) → OR vuole che ALMENO UNA tra le due condizioni sia VERA, quindi
“se cond1 è vera oppure cond2 è vera, allora...”
Selettori Multipli (Switch)

Alcune situazioni però prevedono più di due alternative: In questi casi è necessario utilizzare una
variante della selezione che prevede di intraprendere un percorso alternativo NON in base al
VERO o FALSO, ma in base al valore di una variabile.

Questa variante di Selezione prende il nome di Selezione Multipla (o “Istruzione Case”).

Dopo aver dichiarato una variabile ed averle assegnato un valore ci basterà mettere dentro una
funzione di selezione switch la stessa variabile: Sarà adesso compito dello switch, in base al valore
sulla nostra variabile, indirizzare il nostro programma verso un determinato <blocco di istruzioni>

Avremo quindi qualcosa del genere:

switch (variabile) // Dove “variabile” si suppone sia stata inserita in precedenza;
{
case valore1: // Nel caso in cui ''variabile'' corrisponda a valore1;
<blocco di istruzioni> // Contiene il nostro primo blocco di istruzioni;
break;

case valore2: // Nel caso in cui ''variabile'' corrisponda a valore2;

<blocco di istruzioni> // Contiene il nostro secondo blocco di istruzioni;
break;

… ← Implicazione che i case possano essere molti di più;

case valoreN: // Nel caso in cui ''variabile'' corrisponda a valoreN;

<blocco di istruzioni> // Contiene il nostro N°esimo blocco di istruzioni;
break;

default: // Nel caso in cui ''variabile'' non corrisponda a nessun case.

<blocco di istruzioni>
}

Dove i case sono un numero indefinito di blocco di istruzioni che eseguono differenti operazioni.

Come già si può intuire visivamente, siamo davanti ad un “Menù di Selezione”; in base al valore
che noi daremo alla nostra variabile entreremo dentro dei differenti ”case” che ci faranno svolgere
differenti <blocchi di istruzioni>.

L'utilizzo del break indica la fine del <blocco di istruzioni>, senza di esso, una volta completata
l'esecuzione di case valoreN verrà eseguito automaticamente anche il case di valoreN+1.

Infine default sarà il <blocco di istruzioni> eseguito automaticamente nel caso in cui la nostra
variabile venga avvalorata di un valore non presente all'interno del nostro switch in nessun case.

Con le Iterazioni (o cicli, che vedremo nella prossima pagina) sarà possibile fare interessanti
utilizzi del selettore Switch: una volta eseguito un <blocco di istruzioni> dentro un determinato
case sarà possibile effettuare un'altra iterazione (“un altro giro”) selezionando un case differente.
Cicli a condizione Iniziale: While

Ci sono delle operazioni, anche nella quotidianità, che vanno ripetute più volte, fino al
soddisfacimento di un determinato obbiettivo, per esempio:

• “Versa l'acqua nel bicchiere finché non è pieno”;

• “Somma tutti i numeri che leggi fin tanto che la loro somma è minore di 100”;
• “Tira una moneta finché non esce testa”;
• “Leggi i preziosi appunti scritti dal tuo insegnante finché non li avrai imparati a memoria”.

In programmazione questa funzione viene chiamata While e seppur la sua presentazione sia molti
simile a quella di un if semplice, la differenza è sostanziale. Nella sua forma più generica scritta:
while (condizione)
{
<blocco istruzioni>
}
Avremo un <blocco istruzioni> che continuerà ad essere ripetuto SE e FINTANTO CHE la nostra
condizione affiancata al while risulta essere TRUE.

Esempio di Iterazione Semplice (While)

“Inizializziamo una variabile intera n a 0, man mano la incrementeremo di 1 fino ad arrivare a 10.
Quando arriviamo a 10, interrompiamo il nostro programma.”

int n = 0;

while (n <= 10)

{
n ++; //Scrivere n++ è equivalente a dire: n = n + 1;
}

while verifica che la Condizione (n<=10) sia verificata, entra nel <blocco istruzioni>, dove n viene
incrementata di 1 e poi torna nuovamente a verificare se la Condizione è ancora vera.

ATTENZIONE PERÒ:
La condizione del ciclo deve essere ben definita, altrimenti:
• Il ciclo potrebbe non essere mai eseguito se la condizione non si verificasse mai;
• Il ciclo potrebbe essere infinito (quindi un loop) se la condizione risultasse sempre vera.

Molti degli errori più comuni e delle difficoltà che vengono

riscontrate maggiormente all'inizio dell'applicazione di codice
in termini di programmazione avvengono proprio a causa dei
while: Bisogna SEMPRE evitare di finire dentro i loop.
Cicli a condizione Finale: Do-While

Ci sono anche delle volte però in cui le operazioni dovranno essere eseguite almeno una volta
prima di poter controllare la condizione di iterazione. Questi casi (noti come “Do-While”) sono
chiamati anche iterazioni ”Post-Condizionate” in quanto: PRIMA effettueremo il nostro <blocco
istruzioni> e solo DOPO verificheremo se ripetere l'iterazione in base alla nostra condizione.
do
{
<blocco istruzioni>

} while (condizione)
Questa volta avremo un <blocco istruzioni> che sarà eseguito ALMENO una volta a prescindere da
tutto e che continuerà ad essere ripetuto SE e FINTANTO CHE la nostra condizione affiancata al
while risulterà essere TRUE.

Potremmo vedere il Do-While come:

“FAI” → { OPERAZIONI }
“FINTANTO CHE” → (CONDIZIONE == TRUE)

Esempio di Iterazione Post-Condizionata (Do-While)

“Si vuole realizzare un programma che continui a ricevere in ingresso un inserimento da tastiera di
numeri interi fintanto che il nuovo numero inserito è uguale o maggiore del numero precedente.”

int nuovo, precedente; //Creo variabili di inserimento;

cout << ''Inserisci il primo valore: '';

cin >> nuovo; //Inserisco il primo valore;

do {
precedente = nuovo; //Il valore inserito all'inizio diventerà quello precedente;
cout << ''Inserisci nuovo valore: '';
cin >> nuovo; //Il nuovo valore viene salvato

}while (nuovo >= precedente) //Controllo che ''nuovo'' sia maggiore di ''precedente'';
All'inizio della nostra iterazione non ci sarebbe stato possibile fare il controllo della condizione
posta come: nuovo >= precedente; perché dopo aver inserito il primo valore prima dello while
bisognerà, a prescindere di tutto, effettuare almeno un inserimento per verificare che la
condizione sia VERA oppure FALSA.
IMPORTANTE: In generale, nei cicli WHILE e DO-WHILE ci si può avvalere di variabili intere
denominate come “VARIABILI CONTATORE”. Queste variabili hanno il ruolo di “Contare” il
numero di ripetizioni, incrementando di “+1” ogni volta che viene iterato il <blocco istruzioni>.

Per fare ciò basterà dichiarare una generica variabile INT “N” e mettere al termine del while un
“N++” (oppure “N = N + 1”) incrementando così il nostro conteggio ad ogni giro.
Il prossimo metodo di iterazione, nonché l'ultimo, utilizzerà proprio i contatori come meccanica
principale di iterazione: il suo nome sarà “CICLO FOR” oppure “CICLO A CONTEGGIO”.
Cicli a Conteggio (For)
Fin'ora abbiamo visto casi di while dove la durata dei nostri cicli non era nota a priori; infatti anche
nei casi che abbiamo affrontato negli esempi ci siamo ritrovati in casistiche dove bisognava
“eseguire una determinata azione fino a quando la condizione non è più verificata come vera”.

Esiste tuttavia un insieme di problemi caratterizzati dal fatto di avere come dato iniziale proprio il
numero di volte che un compito deve essere eseguito (esempio: Per 10 volte scrivi “Ciao”).
→ Queste iterazioni sono note come Cicli a Conteggio (oppure Cicli For).

Questi si presentano in modo differente dai due cicli che avevamo visto in precedenza, infatti:
For ( < Inizializzazione > ; < Condizione > ; < Aggiornamento > )
{
< Blocco Istruzioni >
}
Possiamo notare fin da subito una struttura di iterazione molto più elaborata che non
necessariamente implichi che sia dunque più complessa. Il suo funzionamento infatti è semplice:

• Blocco Istruzioni : Al suo interno avremo le regolari operazioni, come in ogni ciclo;

• Inizializzazione : In questo primo blocco dichiareremo ed inizializzeremo la variabile

che ci farà da “contatore” per la nostra Condizione;

• Condizione : Non è diversa da quella che abbiamo visto anche negli altri cicli;

• Aggiornamento : Al termine della nostra iterazione, dovremo aggiornare il nostro

contatore; in fondo alla pagina precedente abbiamo detto che, se si volesse usare un
contatore nei WHILE e DO-WHILE sarebbe necessario aggiungere in fondo al Blocco
Istruzioni l'incremento di +1 alla nostra variabile; nel FOR invece avremo questa apposita
zona di Aggiornamento dove potremmo scrivere l'eventuale “contatore++”.

Esempio di Iterazione a Conteggio (FOR)

“Si vuole realizzare un programma che prenda in ingresso 10 numeri interi
e poi infine dia in uscita il valore medio basato sui valori inseriti.”

RICORDIAMO che per calcolare la media di “N” numeri è sufficiente sommare tutti i numeri in
unica variabile per poi dividerla per N: Il risultato di tale operazione sarà la media dei valori.
int numero;
int somma=0;

for (int cont=0; cont < 10; cont++) //creo contatore, creo la condizione, creo l'aggiornamento
{
cout << ''Inserisci numero: '';
cin >> numero;
somma = somma + numero;
}
cout << ''La media dei 10 numeri inseriti è: ''<< somma/10;
EXTRA:
Cicli a Conteggio DINAMICO

In tutti gli esempi visti fin'ora, abbiamo avuto dichiarazioni di while statiche, dove siamo stati noi
da tastiera ad inserire quanto lunga sarebbe stata arbitrariamente la nostra iterazione. Ma se, per
esempio, riprendessimo l'esercizio di pagina precedente e lo ricompilassimo in maniera tale che
invece di dover effettuare 10 INSERIMENTI ne dovessimo effettuare N, dove N è un numero
dinamico (e quindi scelto dopo il lancio del programma)? L'esecuzione in realtà è molto semplice!

“Si vuole realizzare un programma che prenda in ingresso N numeri interi

e poi infine dia in uscita il valore medio basato sui valori inseriti.”

Per questioni di completezza e di spazi quello che scriverò questa volta non sarà soltanto una
“frazione di codice”, ma l'intero main: Quindi un vero e proprio programma eseguibile!
#include <iostream>
using namespace std;
int main()
{
int numero, iterazioni;
int somma=0;
cout << ''Quanti numeri vogliamo inserire, capo? '';
cin >> iterazioni;

// Notare come adesso la condizione sia cambiata da cont<10 a cont<iterazioni

for (int cont=0; cont < iterazioni; cont++)
{
cout << ''Inserisci numero: '';
cin >> numero;
somma = somma + numero;
}
// Notare come anche il cout finale sia stato aggiornato di conseguenza
cout << ''La media dei ''<<iterazione<<'' numeri inseriti e': ''<< somma/iterazioni;

system(''PAUSE''); // Fine del Programma

}
Il nostro output finale su compilatore, dopo aver lanciato questo codice, sarà:

Utilizzate gli spazi prima e dopo le variabili durante i cout, per una visualizzazione più “carina”.
Esempio Impaginazione di un Programma in C
/* I commenti sono, in quanto tali, ovviamente superflui *
/***********************************************

Far inserire una serie numerica di interi fermandosi quando

viene inserito due volte consecutive lo stesso numero.

***********************************************/
#include <iostream> //Header di Librerie e NameSpace
using namespace std;
//Dichiarazione del main, contenente il nostro {codice}
int main()
{
//Dichiarazione delle variabili
int nVecchio;
int nNuovo;
//Valorizzazione dei primi valori
cout << "Inserisci un numero: ";
cin >> nNuovo;
//Nell'esempio useremo l'iterazione Do-While
do{
nVecchio = nNuovo;
cout << "Inserisci un nuovo numero: ";
cin >> nNuovo;
}while(nVecchio != nNuovo);
//Output per avvertire la chiusura del software
cout << "hai inserito due volte " << nVecchio;
return 0; //Chiusura del Programma
}