Argomento di Programmazione 1. Fatto a lezione a settembre, seconda parte del deck 2.2: slide 57-76. Le slide 64-65 (sintassi dell’assegnazione, assegnazione a catena) sono spiegate in Il Linguaggio C. Prima: Il Linguaggio C (fino all’assegnazione). Dopo: Algebra di Boole.
Il filo del deck:
espressione costanti, variabili e operatori che producono un valore
|
albero sintattico la forma la decidono priorità, parentesi e associatività
|
valutazione dal basso verso l'alto; && e || si fermano appena sanno (lazy)
|
assegnazione è un operatore anche lei: ha un valore e associa a destra
|
forme corte x += a, x++, ++x: stesso effetto su x, valore diverso
|
costanti letterali (5, 'a', "marco") e variabili const: non cambiano
|
caratteri 'a' è un numero (ASCII 97), "a" è una stringa; UTF-8 per il resto
1Definizioni
Espressione. Una combinazione di costanti, variabili e operatori che produce un valore (slide 57): y * (x + 3) * 2. Gli operatori aritmetici seguono “le regole a noi già note” della matematica: prima moltiplicazioni e divisioni, poi somme e sottrazioni. Anche l’assegnazione è un’espressione, e il suo valore è quello assegnato (visto in Il Linguaggio C).
Albero sintattico. Il modo in cui il compilatore legge un’espressione (slide 58). L’idea: un’espressione scritta su una riga è ambigua finché non si decide chi si applica a cosa, e l’albero è la risposta scritta. Le foglie sono variabili e costanti, i nodi interni sono operatori, e ogni operatore si applica ai valori dei suoi figli. La forma la decidono le priorità degli operatori, le parentesi e l’associatività. Si valuta dal basso verso l’alto: un nodo si calcola solo quando i suoi figli hanno già un valore.
Per x = y * (x + 3) * 2; i passi sono quattro, quelli della slide, con e all’inizio:
passo 1 x + 3 2 + 3 = 5 la parentesi per prima
passo 2 y * (x + 3) 5 * 5 = 25 * associa da sinistra: il primo * prima del secondo
passo 3 ... * 2 25 * 2 = 50
passo 4 x = ... x diventa 50 l'assegnazione ha la priorità più bassa
La a destra vale ancora quando viene letta: si scrive solo al passo 4.
Operatori. Caratteri speciali, o loro combinazioni, che denotano un’operazione (slide 59-60). La slide li elenca tutti insieme; per ora servono questi gruppi:
| Gruppo | Operatori | Esempio |
|---|---|---|
| aritmetici | + - * / % | 7 % 3 vale 1 |
| relazionali | < <= > >= | x < 10 |
| uguaglianza | == e != | x != 0 |
| logici | ! && || | x > 0 && x < 10 |
| assegnazione | =, += -= *= /= %= | x += 2 |
| incremento | ++ -- | i++ |
| condizionale | ? : | Istruzioni condizionali |
Gli altri della lista (^ & | ~ << >> sui bit, -> . :: ->* su struct e classi C++, [] sugli array, la virgola) arriveranno più avanti.
Precedenza (o priorità). Quale operatore si applica per primo quando non ci sono parentesi (slide 63). Un gruppo più in alto nella tabella lega più forte, cioè prende i suoi operandi prima degli altri. Esempio: 2 + 3 * 4 vale , perché * sta sopra + e l’albero è 2 + (3 * 4). Controesempio: chi legge da sinistra a destra come su una calcolatrice semplice ottiene , che è il valore di (2 + 3) * 4. Le parentesi servono proprio a cambiare l’albero.
Associatività. Il verso in cui si raggruppano operatori dello stesso gruppo, quando la precedenza non basta a decidere. Gli additivi associano da sinistra: 10 - 4 - 3 si legge (10 - 4) - 3, che vale ; letto 10 - (4 - 3) darebbe , ed è sbagliato. Anche 100 / 10 / 5 si legge (100 / 10) / 5 e vale , non . L’assegnazione e gli unari associano da destra: a = b = 5 si legge a = (b = 5), e !!x si legge !(!x).
Tabella delle precedenze della slide, dall’alto (lega di più) al basso:
gruppo operatori associatività
postfissi ( ) [ ] . -> da sinistra a destra
unari ! ++ -- * & sizeof - (tipo) da destra a sinistra
moltiplicativi * / % da sinistra a destra
additivi + - da sinistra a destra
shift << >> da sinistra a destra
relazionali < <= > >= da sinistra a destra
uguaglianza == != da sinistra a destra
AND logico && da sinistra a destra
OR logico || da sinistra a destra
condizionale ? : da destra a sinistra
assegnazione = += -= *= /= %= da destra a sinistra
Come ricordarla: prima si calcola (aritmetica), poi si confronta (relazionali e uguaglianza), poi si combina (&& prima di ||), per ultimo si assegna. Nella riga degli unari * e & sono gli operatori sui puntatori e - è il meno unario (-x), non la moltiplicazione e la sottrazione. La tabella della slide è semplificata: mancano gli operatori sui bit & ^ | (fra uguaglianza e &&) e la virgola (sotto l’assegnazione); il prof chiama “notazione infissa” la prima riga.
Esempi verificati, dal più semplice:
#include <stdio.h>
int main(void)
{
int x = 4;
printf("%d\n", 2 + 3 * 4);
printf("%d\n", (2 + 3) * 4);
printf("%d\n", 100 / 10 / 5);
printf("%d\n", 100 / (10 / 5));
printf("%d\n", x > 0 && x < 10);
printf("%d\n", !!x);
printf("%d\n", -x * 2 + 1);
printf("%d\n", 20 - x - 2 * 3 % 4);
return 0;
}
Output, una riga per valore: 14, 20, 2, 50, 1, 1, -7, 14. Le ultime quattro passo per passo:
x > 0 && x < 10 relazionali prima di &&: (4 > 0) && (4 < 10) = 1 && 1 = 1
!!x unari da destra: !(!4) = !0 = 1
-x * 2 + 1 meno unario prima di *: ((-4) * 2) + 1 = -8 + 1 = -7
20 - x - 2 * 3 % 4 * e % da sinistra: (2 * 3) % 4 = 6 % 4 = 2
poi - da sinistra: (20 - 4) - 2 = 14
!!x è un trucco che si vede: trasforma qualunque valore in 0 o 1.
Lazy evaluation (slide 62). Il valore di un’espressione a volte si conosce senza valutare tutto l’albero, e il C in quei casi si ferma, “sempre ottenendo un risultato corretto”. Succede con && e ||, valutati da sinistra:
- in
A && B, seAè falso il risultato è falso qualunque siaB, quindiBnon viene valutato; - in
A || B, seAè vero il risultato è vero, eBnon viene valutato.
Si chiama anche valutazione cortocircuitata (short-circuit). Serve a scrivere condizioni che proteggono se stesse: in x != 0 && 10 / x > 1 la divisione non avviene mai quando è zero. Il rovescio: se B contiene un ++ e non viene valutato, l’incremento non avviene. Gli operatori aritmetici non hanno niente di simile: in 0 * f il secondo operando si valuta comunque.
Assegnazioni composte (slide 66, slide 70). Le istruzioni del tipo x = x + a si chiamano autoassegnamenti e sono così frequenti che hanno una forma corta:
| Forma compatta | Forma estesa |
|---|---|
x += a | x = x + a |
x -= a | x = x - a |
x *= a | x = x * a |
x /= a | x = x / a |
x %= a | x = x % a |
x++ | x = x + 1 |
x-- | x = x - 1 |
La parte a destra si calcola tutta prima, perché l’assegnazione ha la precedenza più bassa di tutte. Quindi la forma estesa giusta ha le parentesi: x op= espr vuol dire x = x op (espr).
x *= y + 1 è x = x * (y + 1) non x = x * y + 1
x -= y - 1 è x = x - (y - 1) non x = x - y - 1
x /= 2 * 2 è x = x / (2 * 2) non x = x / 2 * 2
Con , : x -= y - 1 dà (la lettura sbagliata dà ). Con : x /= 2 * 2 dà (la lettura sbagliata dà ). Verificato:
#include <stdio.h>
int main(void)
{
int x = 10;
int y = 4;
x -= y - 1;
printf("%d\n", x);
x = 20;
x /= 2 * 2;
printf("%d\n", x);
return 0;
}
Output: 7 e 5, una riga ciascuno.
Incremento e decremento (slide 68). Entrambe le forme cambiano la variabile di uno. Cambia il valore dell’espressione, cioè il numero che finisce in mezzo al conto:
| Espressione | Valore dell’espressione | Effetto su x |
|---|---|---|
x++ (post-incremento) | il valore di x prima | x aumenta di 1 |
++x (pre-incremento) | il valore di x dopo | x aumenta di 1 |
x-- (post-decremento) | il valore di x prima | x cala di 1 |
--x (pre-decremento) | il valore di x dopo | x cala di 1 |
Per ricordarlo si legge da sinistra. In x++ si incontra prima x (si usa il valore) e poi ++ (si incrementa); in ++x il contrario.
Da soli, come istruzione (i++; oppure ++i;), fanno la stessa cosa: il valore dell’espressione si butta via. La differenza si vede solo quando il valore viene usato. Due esempi verificati, il secondo con due variabili:
#include <stdio.h>
int main(void)
{
int x = 3;
int y;
int z;
y = x++ * 2;
printf("x = %d, y = %d\n", x, y);
z = ++x * 2;
printf("x = %d, z = %d\n", x, z);
return 0;
}
| istruzione | x | y | z | perché |
|---|---|---|---|---|
| iniziale | 3 | ? | ? | |
y = x++ * 2; | 4 | 6 | ? | x++ vale 3, , poi x sale a 4 |
z = ++x * 2; | 5 | 6 | 10 | x sale a 5, ++x vale 5, |
Output: x = 4, y = 6 e x = 5, z = 10.
#include <stdio.h>
int main(void)
{
int i = 1;
int j = 10;
int k;
k = j-- - ++i;
printf("%d %d %d\n", i, j, k);
k += i++ * --j;
printf("%d %d %d\n", i, j, k);
return 0;
}
| istruzione | i | j | k | conto |
|---|---|---|---|---|
| iniziale | 1 | 10 | ? | |
k = j-- - ++i; | 2 | 9 | 8 | j-- vale 10, ++i vale 2, |
k += i++ * --j; | 3 | 8 | 24 | i++ vale 2, --j vale 8, |
Output: 2 9 8 e 3 8 24. Gli spazi in j-- - ++i non sono decorazione: servono a chi legge per vedere dove finisce un operatore e comincia l’altro.
Controesempio: la stessa variabile incrementata due volte nella stessa espressione, oppure incrementata e letta. i = i++; e y = x++ + x++; sono comportamento indefinito: lo standard non dice in che ordine avvengono le scritture, e compilatori diversi danno risultati diversi. gcc con -Wall avvisa: warning: operation on 'i' may be undefined [-Wsequence-point] (verificato). All’esame non escono; nel codice non si scrivono.
Costante (slide 71). Un valore che non cambia durante il programma. Come le variabili, una costante con nome ha nome, tipo, l-value e r-value. Esempi della slide:
- numeriche:
5,2.4,0xFF(esadecimale, vale 255),3E10(),-4.5E-9(). Il punto o laEfanno una costantedouble, senza è unint:5e5.0non sono la stessa costante (lo si vede in7 / 2contro7 / 2.0); - stringhe:
"marco","\tstudenti info\n"(\tè una tabulazione,\nun a capo); - predefinite:
NULL, il puntatore nullo, definito instdio.he in altri header standard (servirà con i puntatori); - booleane:
trueefalse. In C11 non esistono da sole: servono#include <stdbool.h>(dal C99) oppure il C23, dove sono diventate parole chiave. Senza, gcc con-std=c11dàerror: 'true' undeclared. Il C tradizionale usa gli interi:0è falso, qualunque altro valore è vero, e gli operatori relazionali e logici restituiscono1o0.
#include <stdio.h>
#include <stdbool.h>
int main(void)
{
bool b = true;
printf("%d %d\n", 0xFF, 0x10);
printf("%.0f\n", 3E10);
printf("%d %d\n", b, false);
printf("%d %d %d\n", 3 > 2, 7 && 0, !0);
return 0;
}
Output:
255 16
30000000000
1 0
1 0 1
true stampato con %d è 1: sotto è un intero. 7 && 0 vale 0 perché il secondo operando è falso; !0 vale 1.
Variabile costante (slide 72).
const tipo identificatore = espressione;
Il valore (r-value) della variabile non si può più modificare: un’assegnazione successiva è un errore di compilazione. Il valore va dato subito, nella dichiarazione, perché dopo non si potrà più. Perché esiste: un numero fisso scritto una volta con un nome (kilo, NumCarte) si legge meglio di un 1024 sparso nel codice, e se per sbaglio lo si modifica se ne accorge il compilatore, non l’utente.
const int kilo = 1024;
const double pi = 3.14159;
const int mille = kilo - 24;
Controesempi, con il messaggio vero di gcc:
const int kilo = 1024;
kilo = 2048; error: assignment of read-only variable 'kilo'
kilo++; error: increment of read-only variable 'kilo'
const int m; compila senza warning, ma m non avrà mai un valore
La slide scrive pi = 3.141519: le cifre sono scambiate, La slide dice anche che l’espressione deve essere calcolabile in fase di compilazione. Per le costanti locali in C non è obbligatorio: const int doppio = 2 * n; con n letto da tastiera compila (provato con gcc). Il vincolo vale per le costanti globali e in C++ per quelle usate come dimensione di un array.
Carattere e stringa (slide 74).
- Un carattere si scrive fra apici singoli:
'a'è il carattere a, di tipochar, e vale il suo codice ASCII (97). - Una stringa si scrive fra apici doppi:
"a"è una stringa di un carattere,"alfa"una di quattro. - Senza apici,
aealfasono identificatori di variabili.
La slide dice che i caratteri vanno “tra apici doppi”: è sbagliato. 'a' e "a" sono oggetti diversi, e in printf("%c", ...) va il primo. Controesempio: char c = "z"; con gcc 16 è un errore (initialization of 'char' from 'char *' makes integer from pointer without a cast), perché "z" non è un carattere ma una stringa. La stringa è una sequenza di caratteri trattata come un oggetto unico: printf("alfa") equivale a stampare a, l, f, a uno dopo l’altro. Come la memorizza il C si vede in Stringhe.
Con printf:
printf("a")stampa il carattere a;printf("a=%d", a)stampaa=seguito dal valore della variabilea;printf(a)conaintero non compila: il primo argomento diprintfdeve essere una stringa (gcc:passing argument 1 of 'printf' makes pointer from integer without a cast). La slide scrive “stampa il valore di a ?” e aggiunge che non stampa il carattere a: nel C vero non stampa niente, perché non compila.
ASCII (slide 75). American Standard Code for Information Interchange, dal 1963. Associa a ogni carattere un numero da 0 a 127, cioè 7 bit. Il calcolatore memorizza solo numeri: una lettera, per lui, è il suo codice. I codici da ricordare:
| Carattere | Codice | Nota |
|---|---|---|
'\0' | 0 | NUL, non stampabile |
'\n' | 10 | a capo |
' ' | 32 | spazio |
'0' … '9' | 48 … 57 | cifre, consecutive |
'A' … 'Z' | 65 … 90 | maiuscole, consecutive |
'a' … 'z' | 97 … 122 | minuscole, consecutive |
Dato che un char è un numero, ci si fa aritmetica. Le formule che servono sempre si basano tutte sul fatto che cifre, maiuscole e minuscole sono consecutive:
- valore di una cifra:
c - '0'(da'7', codice 55, si ottiene ); - minuscola in maiuscola:
c - 'a' + 'A'(c - 'a'è la posizione nell’alfabeto contando da 0); - distanza fra minuscole e maiuscole:
'a' - 'A'vale 32; - “c è una cifra”:
c >= '0' && c <= '9'vale 1 o 0.
Il codice si stampa con %d, il carattere con %c. Controesempio classico: '7' + 1 non è 8, è il carattere '8' (codice 56); il numero 7 si ottiene solo togliendo '0'.
UTF-8 (slide 76). ASCII copre solo l’inglese. Unicode assegna un numero a ogni carattere di ogni lingua, e UTF-8 è il modo più usato di scriverlo in byte: “codifica variabile fino a 4 byte”, e i caratteri ASCII restano identici su un byte. Dal 2008 circa è la codifica più usata sul web (grafico della slide). Conseguenza pratica: "è" occupa due byte, non uno, e in un char non ci sta.
2Concetti
2.1Divisione intera e resto
L’idea: fra due interi / risponde a “quante volte ci sta” e % a “quanto avanza”. 17 caramelle a 5 bambini: 3 a testa, ne avanzano 2. Quindi 17 / 5 vale e 17 % 5 vale .
La regola:
- se tutti e due gli operandi sono interi,
/è la divisione intera: tronca la parte decimale verso zero; - basta un operando
double(una costante col punto, come2.0) perché la divisione sia decimale; %esiste solo fra interi:7.5 % 2è un errore di compilazione (invalid operands to binary %);- vale sempre
(a / b) * b + a % buguale ada: è la definizione del resto. Dal C99 la divisione tronca verso zero, quindi il resto ha il segno dia; - dividere per zero (
/ 0o% 0) è comportamento indefinito; con la costante 0 gcc avvisa (division by zero).
#include <stdio.h>
int main(void)
{
double m;
double q;
printf("%d %d\n", 17 / 5, 17 % 5);
printf("%d %d\n", 2 / 5, 2 % 5);
printf("%d %d\n", -17 / 5, -17 % 5);
printf("%d %d\n", 17 / -5, 17 % -5);
printf("%.1f %.1f\n", 17 / 5.0, 17.0 / 5);
m = 7 / 2;
q = 7 / 2.0;
printf("%.1f %.1f\n", m, q);
return 0;
}
Output:
3 2
0 2
-3 -2
-3 2
3.4 3.4
3.0 3.5
Riga per riga:
2 / 5vale 0 (il 5 nel 2 ci sta zero volte) e2 % 5vale 2: quandoa < bil resto èastesso;-17 / 5è troncato verso zero, cioè ; il resto si ricava dall’identità: ;17 / -5vale , resto : il segno del resto è quello del dividendo;- l’ultima riga è la trappola:
m = 7 / 2calcola prima la divisione fra interi () e solo dopo la mette in undouble(). Chemsiadoublenon cambia il conto a destra.
2.2Cifre di un numero
n % 10 è l’ultima cifra (il resto della divisione per 10), n / 10 toglie l’ultima cifra. In generale la cifra in posizione (unità , decine , …) è n / 10^k % 10, dove si scrive a mano (100, 1000): in C ^ non è la potenza.
Con : n % 10 è 7, n / 10 % 10 è , n / 100 è 2. Con una matricola a sei cifre, :
#include <stdio.h>
int main(void)
{
int n = 238471;
printf("%d\n", n % 10);
printf("%d\n", n / 10 % 10);
printf("%d\n", n / 100 % 10);
printf("%d\n", n / 1000 % 10);
printf("%d\n", n / 1000);
printf("%d\n", n % 1000);
return 0;
}
Output: 1, 7, 4, 8, 238, 471, una riga ciascuno. / e % hanno la stessa precedenza e associano da sinistra, quindi n / 100 % 10 è (n / 100) % 10 senza parentesi. Le ultime due righe tagliano il numero in due: n / 1000 tiene le prime tre cifre, n % 1000 le ultime tre. È il trucco di quasi tutti i tracing con la matricola.
2.3Aritmetica sui caratteri, verificata
#include <stdio.h>
int main(void)
{
char c = '7';
printf("%d %d\n", c, c - '0');
printf("%c %d\n", c + 1, c + 1);
printf("%d\n", c >= '0' && c <= '9');
printf("%c\n", 'q' - 32);
printf("%c\n", 'a' + 25);
return 0;
}
Output:
55 7
8 56
1
Q
z
ccon%dstampa il codice di'7', 55;c - '0'è , il valore della cifra;c + 1è 56: con%cè il carattere8, con%dil numero 56. Stesso valore, due modi di stamparlo;'q' - 32è la maiuscola, perché maiuscole e minuscole distano 32;'a' + 25è la ventiseiesima lettera, z (la a è la posizione 0).
3Metodo
Riconoscere l’esercizio. “Scrivi l’output esatto” con poche variabili int, ++, +=, / e %: è un tracing. Non si “capisce il programma”, si esegue a mano riga per riga.
Valutare un’espressione a mano.
- Metti le parentesi implicite seguendo la tabella: prima unari (
!,-,++,--), poi* / %, poi+ -, poi i confronti, poi&&,||,?:, assegnazione. - A parità di gruppo, raggruppa secondo l’associatività (quasi sempre da sinistra, tranne unari,
?:e assegnazioni). - Calcola dal basso dell’albero. Con due interi,
/è divisione intera (tronca verso zero) e%è il resto. - Con
&&e||fermati appena il risultato è deciso, e ricordati che la parte non valutata non esegue i suoi++. - Per ogni
x++scrivi due cose: il valore che entra nel conto (il vecchio) e il nuovo valore dix. Per++xil valore che entra è già il nuovo.
Tracciare un frammento.
- Tabella con una colonna per variabile e una riga per istruzione; la prima riga sono i valori iniziali (
?se non inizializzata). - Ogni assegnazione composta va riscritta prima in forma estesa con le parentesi:
x op= esprdiventax = x op (espr). - Calcola la parte destra con i valori della riga sopra, poi aggiorna la riga.
- Alla
printfcopia il formato carattere per carattere: spazi, virgole,\n.%cstampa un carattere,%dun numero,%.1fun decimale con una cifra. - Controllo finale: rileggi le variabili
const(non devono essere cambiate) e ogni divisione (era fra interi?).
4Esempi svolti a lezione
4.1Albero sintattico
(slide 58) Il calcolo dei quattro passi è nella definizione sopra. Verificato:
#include <stdio.h>
int main(void)
{
int x = 2;
int y = 5;
x = y * (x + 3) * 2;
printf("x = %d\n", x);
return 0;
}
Output: x = 50.
4.2Esercizio NumCarte
(slide 73) Il programma della slide, così com’è:
#include <stdio.h>
/* Dichiarazioni di variabili costanti */
int main(int argc, char *argv[])
{
const int NumCarte=40;
int NumGiocatori=4;
int i=NumCarte/NumGiocatori;
printf("Numero Carte = %d \n",NumCarte); //Stampa Num Carte
/* Leggi num giocatori */
printf("Numero Giocatori ? \n");
scanf("%d",&NumGiocatori);
printf("Numero Giocatori = %d \n",NumGiocatori);
printf("Numero Carte/Giocatore = %d\n",NumCarte/NumGiocatori);
NumGiocatori=NumGiocatori+1;
/*
NumCarte = NumCarte-1; //Error */
}
La domanda del fumetto: “Esecuzione di questo assegnamento genererebbe un errore. Perché?”. Perché NumCarte è dichiarata const: il suo r-value non si può cambiare. Togliendo il commento gcc si ferma con error: assignment of read-only variable 'NumCarte'. L’errore esce in compilazione: il programma non parte nemmeno, quindi più che di esecuzione si tratta di compilazione. NumGiocatori = NumGiocatori + 1 invece compila, perché NumGiocatori è una variabile normale.
Con -Wall -Wextra il programma della slide dà anche tre warning: i non è mai usata, argc e argv nemmeno. Versione compilabile senza warning, con i stampata:
#include <stdio.h>
int main(void)
{
const int NumCarte = 40;
int NumGiocatori = 4;
int i = NumCarte / NumGiocatori;
printf("Numero Carte = %d\n", NumCarte);
printf("Numero Giocatori ?\n");
scanf("%d", &NumGiocatori);
printf("Numero Giocatori = %d\n", NumGiocatori);
printf("Numero Carte/Giocatore = %d\n", NumCarte / NumGiocatori);
printf("i = %d\n", i);
NumGiocatori = NumGiocatori + 1;
printf("Ora i giocatori sono %d\n", NumGiocatori);
return 0;
}
Con input 3:
Numero Carte = 40
Numero Giocatori ?
Numero Giocatori = 3
Numero Carte/Giocatore = 13
i = 10
Ora i giocatori sono 4
Due cose da vedere:
- è una divisione intera: 13, e il resto 1 si perde;
ivale 10, non 13. È stata calcolata alla dichiarazione, quandoNumGiocatorivaleva ancora 4. Un’assegnazione copia un valore in quel momento, non è una formula che si aggiorna quando cambiano le variabili.
Il valore di ritorno di scanf qui non si controlla, come nella slide: lo si farà con l’if in Istruzioni condizionali.
4.3Stampa di caratteri
(slide 74) Le stampe della slide, più l’aritmetica ASCII:
#include <stdio.h>
int main(void)
{
int a = 5;
char c = 'a';
printf("a");
printf("\n");
printf("a=%d\n", a);
printf("%c\n", c);
printf("%c %d\n", 'A', 'A');
printf("%c\n", c + 1);
printf("%d\n", '7' - '0');
printf("%c\n", 'g' - 'a' + 'A');
printf("%d\n", 'a' - 'A');
return 0;
}
Output:
a
a=5
a
A 65
b
7
G
32
printf("a") stampa la lettera, printf("a=%d\n", a) il valore della variabile a. %c stampa il carattere che ha quel codice, %d stampa il codice: 'A' con %d dà 65. 'g' - 'a' è 6 (la g è la settima lettera, posizione 6), più 'A' dà la G.
4.4Incrementi
(slide 68) Le quattro forme della slide, una dopo l’altra:
#include <stdio.h>
int main(void)
{
int x = 5;
int y;
int z;
y = x++;
printf("x = %d, y = %d\n", x, y);
z = ++x;
printf("x = %d, z = %d\n", x, z);
y = x--;
printf("x = %d, y = %d\n", x, y);
z = --x;
printf("x = %d, z = %d\n", x, z);
return 0;
}
| istruzione | x | y | z | perché |
|---|---|---|---|---|
| iniziale | 5 | ? | ? | |
y = x++; | 6 | 5 | ? | y prende il valore prima (5), poi x sale |
z = ++x; | 7 | 5 | 7 | x sale a 7, z prende il valore dopo |
y = x--; | 6 | 7 | 7 | y prende il valore prima (7), poi x scende |
z = --x; | 5 | 7 | 5 | x scende a 5, z prende il valore dopo |
Output:
x = 6, y = 5
x = 7, z = 7
x = 6, y = 7
x = 5, z = 5
4.5Assegnazioni composte
(slide 66)
#include <stdio.h>
int main(void)
{
int x = 10;
int y = 3;
x += y;
printf("%d\n", x);
x -= 4;
printf("%d\n", x);
x *= y + 1;
printf("%d\n", x);
x /= 5;
printf("%d\n", x);
x %= 4;
printf("%d\n", x);
return 0;
}
| istruzione | forma estesa | x |
|---|---|---|
| iniziale | 10 | |
x += y; | x = x + y | |
x -= 4; | x = x - 4 | |
x *= y + 1; | x = x * (y + 1) | |
x /= 5; | x = x / 5 | (divisione intera) |
x %= 4; | x = x % 4 |
Output, una riga per valore: 13, 9, 36, 7, 3. Il terzo non è .
4.6Lazy evaluation
(slide 62; la slide rimanda l’applicazione a più avanti, questo esempio è mio)
#include <stdio.h>
int main(void)
{
int x = 0;
int b = 7;
int ok;
ok = x != 0 && 10 / x > 1;
printf("ok = %d\n", ok);
ok = x == 0 || b++ > 0;
printf("ok = %d, b = %d\n", ok, b);
ok = x != 0 || b++ > 0;
printf("ok = %d, b = %d\n", ok, b);
return 0;
}
| istruzione | a sinistra | si valuta la destra? | ok | b |
|---|---|---|---|---|
| iniziale | ? | 7 | ||
ok = x != 0 && 10 / x > 1; | 0 != 0 è 0 | no: && con sinistra falsa | 0 | 7 |
ok = x <mark> 0 || b++ > 0; | 0 </mark> 0 è 1 | no: || con sinistra vera | 1 | 7 |
ok = x != 0 || b++ > 0; | 0 != 0 è 0 | sì: 7 > 0 è 1, poi b sale | 1 | 8 |
Output:
ok = 0
ok = 1, b = 7
ok = 1, b = 8
La divisione per zero non avviene mai, e il b++ della seconda riga non viene eseguito. Nella terza la sinistra è falsa, quindi || deve guardare la destra, e il b++ avviene. La precedenza decide anche qui: x != 0 && 10 / x > 1 si legge (x != 0) && ((10 / x) > 1), e ok = ... si fa per ultimo.
5Esercizi tipo esame
In una pagina a parte, dal più facile al livello del 30: Espressioni, operatori e costanti (esercizi).
6Errori tipici
- Credere che
x *= y + 1siax = x * y + 1. La destra si calcola tutta prima. - Scrivere
i = i++;oy = x++ + x++;: la stessa variabile modificata due volte nella stessa espressione è comportamento indefinito. gcc con-Wallavvisa (-Wsequence-point). - Confondere
'a'(carattere, apici singoli) con"a"(stringa, apici doppi), come fa la slide 74.char c = "z";con gcc 16 non compila. - Scrivere
7 / 2aspettandosi 3.5: fra interi la divisione è intera. - Scrivere
double m = 7 / 2;e aspettarsi 3.5: la divisione avviene fra interi prima di arrivare neldouble, emvale 3.0. - Usare
%con undouble: non compila. - Leggere
3 < x < 10come in matematica: vale sempre 1, perché3 < xdà 0 o 1, che è sempre minore di 10. Si scrive3 < x && x < 10. - Usare
trueefalsesenza#include <stdbool.h>in C11. - Contare su un
++scritto nella parte destra di&&o||: con la lazy evaluation può non essere eseguito. - Pensare che
'7' + 1sia 8: è il carattere'8', codice 56. Il valore della cifra è'7' - '0'. - Usare
^per la potenza (10^3): in C è un operatore sui bit, non l’elevamento. - Usare = al posto di == in un confronto:
if (x = 0)assegna 0 e la condizione è sempre falsa. gcc con-Wallavvisa. - Credere che una variabile calcolata da altre si aggiorni da sola: in
NumCartelairesta 10 anche dopo cheNumGiocatoricambia.
7Domande
-
Cos’è l’albero sintattico di un’espressione e cosa ne determina la forma?
-
In che ordine si valuta
x = y * (x + 3) * 2;? -
Che differenza c’è fra precedenza e associatività?
-
Quanto vale
10 - 4 - 3e perché? -
Cos’è la lazy evaluation e con quali operatori interviene?
-
A cosa equivale
x *= y + 1? -
Che differenza c’è fra
x++e++x? -
Con
xche vale 5, quanto valgonoxeydopoy = x++;? E dopoy = ++x;partendo da 5? -
Cosa succede se si assegna un nuovo valore a una variabile dichiarata
const? -
Quanto valgono
7 / 2,7 % 2e7 / 2.0? -
Che differenza c’è fra
'a'e"a"? -
Come si ottiene il valore numerico di un carattere cifra
c? -
Quanto vale
'a' - 'A'e a cosa serve? -
Cosa sono ASCII e UTF-8?
-
In C11 si possono usare
trueefalsesenza include? -
Con
ache vale 0 ebche vale 5, quanto valebdopo aver valutato(a > 0) && (b++ > 0)? -
Quanto vale
mdopodouble m = 7 / 2;, e perché? -
Perché
3 < x < 10non controlla chexsia fra 3 e 10, e come si scrive? -
Perché
i = i++;non va scritto? -
Come si ottiene la cifra delle decine di un intero
n? -
Quanto valgono
-7 / 2e-7 % 2in C, e quale regola lo decide? -
Una variabile
constdeve essere inizializzata nella dichiarazione? Perché?