Introduzione alle variabili, alle strutture di controllo e alle librerie

1 Struttura di un programma semplice

Il seguente programma, una volta compilato e eseguito, stampa a video il messaggio Hello world!!.

1 // my first c++ program

2 #include<iostream>
3
4 int main(){
5 std::cout << "Hello world!!";
6 return 0;
7 }

Vediamo in dettaglio gli elementi del programma.

Le righe che cominciano con // sono commenti e vengono ignorati dal compilatore. La prima riga del programma
precedente quindi è un commento.
Il nucleo del linguaggio C++ in se è piuttosto minimalista. Viene però distribuito con le librerie standard che sono
una raccolta di funzioni che forniscono una vasta gamma di operazioni comuni (come l’input/output, le funzioni
matematiche, l’elaborazione delle stringhe). La seconda riga ordina al compilatore di includere la libreria iostream
che rende semplici le operazioni input/output.
Ogni programma C++ deve avere un modulo main che indica dove comincia l’esecuzione del programma. Il modulo
main inizia nella riga 4. La parola chiave int indica che il modulo main restituirà un numero intero. Le parentesi
vuote indicano che il modulo main non prende parametri (argomenti). Il contenuto del modulo main è racchiuso fra
la parentesi graffa della riga 4 e la parentesi graffa della riga 7.
La prima istruzione del modulo main si trova nella riga 5. In questa riga std::cout indica lo standard output, cioè
il video del computer sul quale il programma viene eseguito. L’operatore << manda la stringa Hello world!!
sullo standard output. Quindi l’effetto della riga 5 è che sullo schermo viene stampato Hello world!!.
La riga 6 con la parola chiave return restituisce 0 (che, per convenzione, indica l’esecuzione corretta del programma)
e termina l’esecuzione del main e di conseguenza l’esecuzione del programma. (Il valore restituito dal modulo main
può avere significato nel caso in cui il programma p1 fa partire il programma p2 e il programma p2 deve comunicare
il risultato della propria esecuzione al programma p1 .)

Il seguente programma stampa a video

Hello
world!!

1 // my second c++ program

2 #include<iostream>
3 using namespace std;
4
5 int main(){
6 cout << "Hello" << endl << "world!!";
7 return 0;
8 }

1
 Aggiungendo using namespace std; (riga 3) ci permette di scrivere cout invece di std::cout per riferire
al standard output e endl invece di std::endl per andare a capo. In generale permette di omettere std::.

2 Variabili
Le variabili servono per memorizzare dati di ogni genere. Il C++ è un cosiddetto linguaggio tipato, il che vuole dire
che il programmatore deve specificare il tipo di ogni variabile. Inoltre ogni variabile ha un nome, occupa una certa
dimensione (espressa in termini di numero di byte) e rappresenta un valore in qualunque istante dell’esecuzione del
programma.
Il seguente programma chiede all’utente di inserire le coordinate di due punti su un piano cartesiano e calcola la loro
distanza. Le coordinate devono essere numeri interi.
1 // distanza su piano cartesiano
2 #include<iostream>
3 #include<cmath>
4 using namespace std;
5
6 int main(){
7 double x1,y1,x2,y2;
8 cout << "x1: ";
9 cin >> x1;
10 cout << "y1: ";
11 cin >> y1;
12 cout << "x2: ";
13 cin >> x2;
14 cout << "y2: ";
15 cin >> y2;
16 cout << "La distanza: ";
17 cout << sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
18 return 0;
19 }

Nella riga 2 si include la libreria matematica per poter calcolare la radice quadrata di un numero.
Nella riga 7 si dichiarano 4 variabili di tipo double per rappresentare numeri reali con nomi x1, y1, x2 e y2.
Nella riga 9 il programma si ferma e aspetta che l’utente inserisca un numero intero utilizzando lo standard input, cioè
la tastiera. Per fare riferimento allo standard input si utilizza std::cin, abbreviato a cin grazie alla riga 4. Il valore
inserito dall’utente viene assegnato alla variabile x1 utilizzando l’operatore >>. Le righe 11, 13 e 15 fanno lo stesso
lavoro con le variabili y1, x2 e y2.
L’istruzione nella riga 17 calcola la distanza e la stampa a video. La funzione sqrt restituisce la radice quadrata del
parametro in ingresso.

2.1 Dichiarazione di variabili

La forma generale per dichiarare una o più variabili dello stesso tipo è
tipo nome_1,nome_2,...,nome_n;
Si può inizializzare la variabile subito con
tipo nome_1=v_1,nome_2=v_2,...,nome_n=v_n;
Il valore di una variabile non inizializzata è da ritenere casuale. Per esempio, il frammento di codice
int x;
cout << x;
può stampare a video 1422. Di conseguenza, prima di utilizzare il valore di una variabile, bisogna dare un valore
sensato alla variabile.

2
2.2 Operazioni con variabili
Il risultato di un operazione su una o più variabili dipende dal tipo delle variabili coinvolte perché ogni tipo ha delle
limitazioni per quanto riguarda l’insieme di valori che può rappresentare.
Per esempio, un int che rappresenta interi e occupa 4 byte (32 bit) può rappresentare 232 valori diversi che formano
l’insieme {−231 , −231 + 1, ..., −2, −1, 0, 1, 2, ..., 231 − 1}. Il frammento di codice
int x=3000000000;
cout << x;
stampa a video -1294967296 perché 231 − 1 < 3000000000.
Inoltre, naturalmente un int può rappresentare solo interi. Quando si cerca di assegnare un valore non intero ad una
variabile int, il computer fa una conversione per ottenere un valore che una variabile int è in grado di rappresentare.
Il frammento di codice
int x=3.14;
cout << x;
stampa a video 3 perché avviene un arrotondamento per difetto.
Le conversioni, come quelle dei due esempi, non vengono segnalate esplicitamente come errori ne dal compilatore
durante la compilazione ne dal computer durante l’esecuzione del programma.
L’operazione più tipica è assegnare un valore ad una variabile utilizzando l’operatore =. La forma generale è
nome_variabile=espressione;
e fa si che il computer valuti l’espressione e assegna il risultato ottenuto alla variabile denominata nome_variabile.
L’espressione deve essere sulla destra del = e può coinvolgere variabili e calcoli. Sulla sinistra del = deve esserci
una variabile alla quale è possibile assegnare il valore ottenuto valutando l’espressione.
Esempi:
int a=3,b; // due interi, uno inizializzato
double x=1.3,y; // due reali, uno inizializzato
b=a; // assegna il valore a a b
cout << b << endl; //stampa 3
a=x+1; // assegna ad a 2 (valore arrot. per dif. di x+1)
cout << a << endl; //stampa 2
cin >> y; // l’utente deve inserire un numero reale
cout << y << endl; // il numero inserito viene stampato
y=2*x*x+1; // assegna 4.38 ad y
cout << y << endl; // stampa 4.38
x=13/5; // assegna 2 ad x
cout << x << endl; // stampa 2
x=13./5.; // assegna 2.6 ad x
cout << x << endl; // stampa 2.6
x=(double)b/a; // converte il valore di b in numero reale, poi divide
cout << x << endl; // stampa 1.5

N.B. L’operatore = non è una dichiarazione ma è un assegnazione. Scrivere a=b; non implica che a sarà uguale a
b nel programma in generale. Invece fa si che quando l’esecuzione arriva ad effettuare a=b;, il computer assegna il
valore di b ad a; dopo di che il valore di a non è legato al valore di b.
Le operazioni di base con i tipi numerici sono somma +, sottrazione -, prodotto * e divisione /. Con % si ottiene il
resto di una divisione intera (per esempio, 25%7 restituisce 4).
Con == si può verificare se due quantità o due variabili sono uguali o meno. Per esempio, 3+a==12 restituisce true
se a è uguale a 9 e false altrimenti. Con != si può verificare se due quantità differiscono. Per esempio, x!=y+1
restituisce true se x non è uguale a y+1. In maniera simile, con <, >, <=, >= si possono verificare minore, maggiore,
minore o uguale e maggiore o uguale.

3
 N.B. scrivere = al posto di == in una condizione non è un errore dal punto di vista sintattico: per esempio, scrivere
if(x=0) fa si che il computer assegna il valore 0 alla variabile x e poi restituisce 0 che viene interpretato come
false e quindi il corpo del if non sarà eseguito anche se x era uguale a 0 prima di arrivare alla riga che contiene
l’if.
L’operatori && e || forniscono congiunzione e disgionzione logica. Per esempio, a>10 && a<15 restituisce true
se a è maggiore di 10 ed è minore di 15. L’operatore ! effettua la negazione logica.

2.3 Tipi primitivi in C++

Interi: short int con almeno 2 byte, int con almeno 2 byte, long int con almeno 4 byte, long long int
con almeno 8 byte. Ognuno può essere utilizzato per rappresentare solo numeri positivi aggiungendo la parola chiave
unsigned.
Numeri reali: float con 4 byte, double con 8 byte, long double tipicamente con 10 byte ma può essere solo
8.
Variabile booleana: bool che può assumere il valore true oppure il valore false.
Il seguente programma illustra come si ottiene, dato un tipo di variabile, la sua dimensione in byte e i valori minimi e
massimi che è un grado di rappresentare.

1 #include <iostream>
2 #include <limits>
3 #include <iomanip>
4
5 using namespace std;
6
7 int main()
8 {
9 int w = 20;
10
11 cout << setw(w) << "TIPO"
12 << setw(w) << "BYTES"
13 << setw(w) << "MIN"
14 << setw(w) << "MAX" << endl;
15 cout << setw(w) << "int"
16 << setw(w) << sizeof(int)
17 << setw(w) << numeric_limits<int>::min()
18 << setw(w) << numeric_limits<int>::max() << endl;
19 cout << setw(w) << "float"
20 << setw(w) << sizeof(float)
21 << setw(w) << numeric_limits<float>::min()
22 << setw(w) << numeric_limits<float>::max() << endl;
23 cout << setw(w) << "double"
24 << setw(w) << sizeof(double)
25 << setw(w) << numeric_limits<double>::min()
26 << setw(w) << numeric_limits<double>::max() << endl;
27
28 return 0;
29 }

Su un portatile Dell con Windows a 64 bit il programma genera il seguente output.

TIPO BYTES MIN MAX
int 4 -2147483648 2147483647
float 4 1.17549e-038 3.40282e+038
double 8 2.22507e-308 1.79769e+308

4
 Per capire cosa fa setw (e altri elementi del linguaggio non spiegati in dettaglio negli appunti) si può guardare il sito
http://www.cplusplus.com. Per setw: http://www.cplusplus.com/reference/iomanip/setw/.

3 Strutture di controllo
I programmi visti finora eseguono le istruzioni in sequenza una dopo l’altra. Per risolvere maggior parte dei problemi
computazionali è necessario ripetere un’istruzione o un gruppo di istruzioni più volte e poter decidere se effettuare
un’istruzione o un gruppo di istruzioni sulla base di un condizione.

3.1 Selezione
La struttura di selezione if permette di eseguire un’istruzione o un blocco di istruzioni soltanto se si verifica una
determinata condizione.
La sua forma è
if(condizione)
istruzione
dove istruzione può essere una singola istruzione oppure un blocco di istruzioni racchiuse fra parentesi graffe.
Per esempio, il frammento di codice
24 if(x<0)
25 cout << "la radice quadrata di x non e’ un numero reale";
stampa il messaggio della riga 25 soltanto se il valore di x è negativo. Il cosiddetto corpo del if, cioè ciò che viene
eseguito se la condizione si verifica, contiene una singola istruzione.
Il frammento di codice
27 if(x>=0){
28 cout << "x e’ maggiore uguale a zero" << endl;
29 cout << "la sua radice quadrata e’:" << sqrt(x) << endl;
30 }
esegue le righe 28 e 29 soltanto se il valore di x è maggiore uguale a 0. Il corpo del if è un blocco di istruzioni.
La struttura if si può estendere con la parola chiave else per avere un’istruzione oppure un blocco di istruzioni che
viene eseguito soltanto se la condizione non si verifica.
Per esempio:
32 if(x<0)
33 cout << "x e’ minore di zero";
34 else{
35 cout << "x e’ maggiore uguale a zero" << endl;
36 cout << "la sua radice quadrata e’:" << sqrt(x) << endl;
37 }
esegue la riga 33 se x è minore di 0, altrimenti esegue il blocco composto dalle righe 35 e 36.

3.2 Ciclo
I cicli permettono di ripetere più volte la stessa istruzione oppure lo stesso blocco di codice senza riscriverlo nel
programma. Il C++ fornisce tre tipi di cicli: il ciclo while, il ciclo do-while e il ciclo for.
Forma del ciclo while:
while(condizione)
istruzione

5
 dove istruzione può essere una singola istruzione oppure un blocco di istruzioni racchiuse fra parentesi graffe. Il
suo effetto è il seguente:
si valuta la condizione e se si verifica si esegue l’istruzione, altrimenti si va oltre il ciclo,
si rivaluta la condizione e se si verifica si esegue l’istruzione, altrimenti si va oltre il ciclo,
si rivaluta la condizione e se si verifica si esegue l’istruzione, altrimenti si va oltre il ciclo ...
La prima volta che la condizione non si verifica il ciclo viene abbandonato. Quindi è possibile che il corpo del
ciclo non viene eseguito neanche una volta. Se la condizione si valuta sempre a true allora il ciclo non si abbandona
mai e il programma rimane intrappolato nel ciclo.
Per esempio, il frammento
39 int i,s=0;
40 cin >> i;
41 while(i>0){
42 s=s+i;
43 i=i-1;
44 }
45 cout << s << endl;
stampa a video la somma dei primi i interi positivi prendendo il valore di i dalla tastiera. Il corpo del while viene
eseguito i volte se i è maggiore di 0, altrimenti non viene eseguito.
Il ciclo do-while è simile ma controlla la condizione dopo l’esecuzione del corpo del ciclo. Quindi il corpo del
ciclo viene eseguito almeno una volta. La sua forma è
do istruzione
while(condizione);
Per esempio, il frammento
47 int j;
48 do{
49 cout << "Inserire un intero positivo: ";
50 cin >> j;
51 } while(j<0);
continua a chiedere di inserire un intero positivo fino al momento in cui l’utente inserisce un intero positivo.
Il ciclo for ha la forma
for(init;cond;update)
istruzione
e la sua esecuzione è la seguente:
effettua init,
valuta cond e se si verifica effettua istruzione altrimenti abbandona il ciclo,
effettua update,
valuta cond e se si verifica effettua istruzione altrimenti abbandona il ciclo,
effettua update,
valuta cond e se si verifica effettua istruzione altrimenti abbandona il ciclo,
effettua update,...
L’istruzione init si usa per inizializzare le variabili che controllano il ciclo. La condizione per decidere se effettuare
l’istruzione o abbandonare il ciclo è data da cond. Dopo ogni esecuzione del corpo del ciclo, si usa update
per aggiornare delle variabili.
Il seguente frammento stampa a video il quadrato dei primi 10 numeri interi.
53 int k;
54 for(k=1;k<=10;k=k+1)
55 cout << k*k << endl;

6
 L’inizializzazione e l’aggiornamento possono contenere più di un’operazione che devono essere separate con delle ,
(virgole).
Il seguente frammento calcola 10! in modo piuttosto particolare e lo stampa a video.
57 int m,n,p=1;
58 for(m=10,n=1;m>n;m=m-1,n=n+1)
59 p=p*m*n;
60 cout << p << endl;

Le strutture dati si possono annidare. Il seguente frammento stampa a video tutti i numeri pari fra 1 e 100.
62 for(int i=1;i<=100;i=i+1)
63 if(i%2==0)
64 cout << i << endl;

Con due cicli annidati si può stampare la tabella pitagorica come segue.
66 int p1,p2;
67 for(p1=1;p1<=10;p1=p1+1){
68 p2=1;
69 while(p2<=10){
70 cout << setw(4) << p1*p2;
71 p2=p2+1;
72 }
73 cout << endl;
74 }
Il mecanismo precedente si può realizzare con qualunque tipo di ciclo come ciclo esterno (while, do-while o for)
e con qualunque tipo di ciclo come ciclo interno. In generale qualunque tipo di ciclo si può realizzare con qualunque
altro tipo di ciclo. Si cerca di scegliere il tipo di ciclo che rende il codice meno complicato e quindi più leggibile.

4 Librerie
Le librerie si includono all’inizio del programma con la parola chiave #include.
La libreria iostream fornisce funzionalità per operazioni input/output. Si usano soprattutto std::cin (input),
std::cout (output) e std::endl (per andare a capo).
La libreria matematica cmath contiene funzioni matematiche e definisce costanti. L’elenco si trova all’indirizzo
http://www.cplusplus.com/reference/cmath/. N.B. la potenza non si ottiene con ^ ma con la funzione pow di cmath.
La libreria iomanip si usa prima di tutto per dare un formato all’output. Con setw si può indicare che un numero
deve essere stampato a video in un campo con un numero minimo di caratteri. Con setprecision si indica con
che precisione viene stampato un numero reale. Come formato si può scegliere fra fixed e scientific.
Il seguente frammento
77 cout << setprecision(2) << acos(-1) << endl;
78 cout << setprecision(4) << acos(-1) << endl;
79 cout << setprecision(6) << acos(-1) << endl;
80 cout << setprecision(8) << acos(-1) << endl;
81 cout << scientific;
82 cout << setprecision(2) << 100*acos(-1) << endl;
83 cout << setprecision(4) << 10000*acos(-1) << endl;
84 cout << fixed;
85 cout << setprecision(10) << acos(-1) << endl;
86 cout << setprecision(12) << acos(-1) << endl;

7
produce l’output:
3.1
3.142
3.14159
3.1415927
3.14e+002
3.1416e+004
3.1415926536
3.141592653590