unità centrale
• operazioni elementari:
- lettura/scrittura * - aritmetico-logiche **
- modifica memoria **
• operazioni di controllo del flusso ***
(* lucidi precedenti, ** questi lucidi, *** in seguito)
valori: Z R B Ch
Ø Ø Ø Ø
tipi C++: int double bool char float
tipo di dato = insieme di valori +
insieme di operatori
int:
insieme di valori Z = { … , -2, -1, 0, 1, 2, …}
operatori + : Z x Z Æ Z (somma) - : Z x Z Æ Z (sottrazione)
* : Z x Z Æ Z (prodotto)
/ : Z x Z Æ Z (divisione intera)
% : Z x Z Æ Z (resto)
++ : Z Æ Z (incremento di 1) -- : Z Æ Z (decremento di 1)
5/-2 Æ -2 10/3 Æ 3 -5/2 Æ -2 5%-2 Æ 1 12%5 Æ 2 -5%2 Æ -1 esempio: quante ore e minuti in 375 minuti?
375/60 Æ 6 (ore) 375%60 Æ 15 (minuti)
++ e -- si applicano solo a variabili : (++5 Æ errore)
int i, j;
i -7 ++i Æ i - 6
j 6 --j Æ j 5
double (oppure float ):
insieme di valori R
operatori + : R x R Æ R (somma)
- : R x R Æ R (sottrazione)
* : R x R Æ R (prodotto) / : R x R Æ R (divisione) 5.0/2.0 Æ 2.5 5.0/3.0 Æ 1.66…67
(approssimazione! quante cifre?
dipende dalla macchina …)
char :
insieme di valori Ch = { 'a', 'b', 'c', …}
operatori : nessuno …
bool :
insieme di valori B
operatori && : B x B Æ B (and,
congiunzione logica)
|| : B x B Æ B (or,
disgiunzione logica) ! : B Æ B (not,
negazione logica)
bool a, b ;
a b a&&b a b a||b
V V V V V V
V V F V F V
F V F F V V
F F F F F F
a !a
V F
F V
operatori di relazione :
uguaglianza ==
differenza !=
minore <
minore-uguale <=
maggiore >
maggiore-uguale >=
: T x T Æ B
dove T sta per : Z, R, Ch, B
=================================
espressione Æ combinazione di :
operatori operandi chiamate di funzione
Ø Ø Ø
di relazione, valori espliciti non ancora viste associati a nomi di variabili
tipi di dato nomi di costanti
una espressione ha:
• un valore
• un tipo (Œ int, double, char, bool)
esempio:
double x, y ; int i, j ;
char c ;
x 5.34
y 2.0
i 2
j 12
c 'A'
valore tipo
Ø Ø
x/y+3.0 5.67 double
i+j*(i+j) 170 int
i+j*i+j 38 int
regole di precedenza: usuali
% * / precedono + -
i*j+i/2 equivale a (i*j)+(i/2)
si possono anche usare operandi di tipo diverso nella stessa espressione
double x, y ; int i, j ;
char c ; x/i+3
i*j-3.14 'A'+j/i c+j*y
il tipo di queste espressioni è quello “più alto” tra i tipi degli operandi presenti
meno più
bool, char Æ int Æ double
ha senso sommare caratteri e numeri?
la macchina C++ lo fa …
comando di assegnamento (lettura/scrittura:
inizializzano/rendono noto il valore di variabili) come modificare il valore di una variabile?
sintassi nomevar = espressione ; fl
nomevar ¨valore(espress.)
A valA A valB+valC
B valB A = B+C; Æ B valB
C valC C valC
nota: il tipo di una espressione viene convertito nel tipo della variabile destinazione prima di fare l’assegnamento
double x, y ; int i, j ;
char c ;
i = 25; nessuna conversione
x = 0.5; " "
c = 'b'; " "
x = 4; conversione in 4.0
i = 3.2; conversione in 3 (perdita di informazione)
x = 11/5; ? x = 11.0/5; ?
conversione di tipo esplicita : operazione di
“casting”
sintassi:
static_cast<nometipo>(espressione)
vecchia sintassi: nometipo (espressione)
Ø
int, bool, …
(converte la rappresentazione di espressione nella rappresentazione del tipo nometipo)
double x ; int i, j ; i = 1;
j = 3;
x = (i+j)/j; ?
x = static_cast<double>(i+j)/j; ?
x = static_cast<double>((i+j)/(j)); ?
x = 3.7;
i = static_cast<int>(x);
i = static_cast<int>(x+0.5);
errori comuni:
double x, y ; int i, j ;
char c ;
x = x%y; errori sintattici (rilevati dal c = F; compilatore)
i = 5; errore “run time” (segnalato j = 0; dalla macchina durante
x = i/j; l’esecuzione)
x = x*y+1; errore semantico, se si voleva calcolare x(y+1) x = i/j; errore semantico, se si
voleva un risultato reale
gli errori semantici non vengono segnalati !!!
funzioni
in una espressione possono comparire “funzioni”
sintassi: nomefun(argomenti)
semantica: valore ottenuto applicando una
“legge di trasformazione” agli argomenti
per ora usiamo solo funzioni predefinite raccolte in librerie
esempio:
funzioni matematiche nella libreria cmath (tra cui sqrt, fabs, sin, log, …)
double x, y ; x = 3.4 ;
y = log(x) + sqrt(x+2.5)) ; (assegna a y il valore lnx+ x+2.5 )
per usare una funzione predefinita in un programma:
#include <nome libreria>
(esempio: #include <cmath>)
e inoltre dobbiamo conoscere il prototipo della funzione:
tipo nomefun (tipoarg)
Ø
del valore
restituito Ø
nome della
funzione Ø
numero e tipo degli argomenti
esempio:
double sqrt (double)
double pow (double, double)
esempio: conversione da gradi Fahreneit in gradi Celsius
(Celsius = 5(Fahreneit-32)
9 )
input: un reale che indica una temp. in °F output: un reale che indica una temp. in °C
versione “scarna”:
#include <iostream>
using namespace std;
main()
{double tempFah, tempCel;
cin >> tempFah;
tempCel = (5.0*(tempFah-32))/9.0;
cout << tempCel;
return 0 }
versione “ricca”:
/*programma di conversione da
gradi Fahreneit in gradi Celsius*/
#include <iostream>
using namespace std;
main()
{double tempFah, tempCel;
cout<<"scrivere temp. in gradi Fahreneit : ";
cin >> tempFah;
tempCel = (5.0*(tempFah-32))/9.0;
cout<<tempFah<<" gradi Fahreneit
equivalgono a "<<tempCel<<" gradi Celsius \n";
return 0;
}
________________________________
versione scarna:
130
54.4444
________________________________
versione ricca:
scrivere temp. in gradi Fahreneit : 130
130 gradi Fahreneit equivalgono a 54.4444 gradi Celsius
