Note Ingegneria Informatica · UniTN
Programmazione 1
Esercizi
Lezione
set, giorno?
in corso

Espressioni, operatori e costanti

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 x=2x = 2 e y=5y = 5 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 xx a destra vale ancora 22 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:

GruppoOperatoriEsempio
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 1414, perché * sta sopra + e l’albero è 2 + (3 * 4). Controesempio: chi legge da sinistra a destra come su una calcolatrice semplice ottiene 5⋅4=205 \cdot 4 = 20, 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 33; letto 10 - (4 - 3) darebbe 99, ed è sbagliato. Anche 100 / 10 / 5 si legge (100 / 10) / 5 e vale 22, non 5050. 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:

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 xx è 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 compattaForma estesa
x += ax = x + a
x -= ax = x - a
x *= ax = x * a
x /= ax = x / a
x %= ax = 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=10x = 10, y=4y = 4: x -= y - 1 dà 10−3=710 - 3 = 7 (la lettura sbagliata dà 55). Con x=20x = 20: x /= 2 * 2 dà 20/4=520 / 4 = 5 (la lettura sbagliata dà 2020). 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:

EspressioneValore dell’espressioneEffetto su x
x++ (post-incremento)il valore di x primax aumenta di 1
++x (pre-incremento)il valore di x dopox aumenta di 1
x-- (post-decremento)il valore di x primax cala di 1
--x (pre-decremento)il valore di x dopox 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;
}
istruzionexyzperché
iniziale3??
y = x++ * 2;46?x++ vale 3, 3⋅2=63 \cdot 2 = 6, poi x sale a 4
z = ++x * 2;5610x sale a 5, ++x vale 5, 5⋅2=105 \cdot 2 = 10

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;
}
istruzioneijkconto
iniziale110?
k = j-- - ++i;298j-- vale 10, ++i vale 2, 10−2=810 - 2 = 8
k += i++ * --j;3824i++ vale 2, --j vale 8, 8+2⋅8=248 + 2 \cdot 8 = 24

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:

#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, π=3,14159…\pi = 3{,}14159\ldots 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).

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:

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:

CarattereCodiceNota
'\0'0NUL, non stampabile
'\n'10a capo
' '32spazio
'0' … '9'48 … 57cifre, consecutive
'A' … 'Z'65 … 90maiuscole, consecutive
'a' … 'z'97 … 122minuscole, 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:

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 33 e 17 % 5 vale 22.

La regola:

#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.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 kk (unità k=0k = 0, decine k=1k = 1, …) è n / 10^k % 10, dove 10k10^k si scrive a mano (100, 1000): in C ^ non è la potenza.

Con n=247n = 247: n % 10 è 7, n / 10 % 10 è 24%10=424 \% 10 = 4, n / 100 è 2. Con una matricola a sei cifre, n=238471n = 238471:

#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 =2384%10=4= 2384 \% 10 = 4 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

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.

  1. Metti le parentesi implicite seguendo la tabella: prima unari (!, -, ++, --), poi * / %, poi + -, poi i confronti, poi &&, ||, ?:, assegnazione.
  2. A parità di gruppo, raggruppa secondo l’associatività (quasi sempre da sinistra, tranne unari, ?: e assegnazioni).
  3. Calcola dal basso dell’albero. Con due interi, / è divisione intera (tronca verso zero) e % è il resto.
  4. Con && e || fermati appena il risultato è deciso, e ricordati che la parte non valutata non esegue i suoi ++.
  5. Per ogni x++ scrivi due cose: il valore che entra nel conto (il vecchio) e il nuovo valore di x. Per ++x il valore che entra è già il nuovo.

Tracciare un frammento.

  1. Tabella con una colonna per variabile e una riga per istruzione; la prima riga sono i valori iniziali (? se non inizializzata).
  2. Ogni assegnazione composta va riscritta prima in forma estesa con le parentesi: x op= espr diventa x = x op (espr).
  3. Calcola la parte destra con i valori della riga sopra, poi aggiorna la riga.
  4. Alla printf copia il formato carattere per carattere: spazi, virgole, \n. %c stampa un carattere, %d un numero, %.1f un decimale con una cifra.
  5. 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:

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;
}
istruzionexyzperché
iniziale5??
y = x++;65?y prende il valore prima (5), poi x sale
z = ++x;757x sale a 7, z prende il valore dopo
y = x--;677y prende il valore prima (7), poi x scende
z = --x;575x 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;
}
istruzioneforma estesax
iniziale10
x += y;x = x + y10+3=1310 + 3 = 13
x -= 4;x = x - 413−4=913 - 4 = 9
x *= y + 1;x = x * (y + 1)9⋅4=369 \cdot 4 = 36
x /= 5;x = x / 536/5=736 / 5 = 7 (divisione intera)
x %= 4;x = x % 47%4=37 \% 4 = 3

Output, una riga per valore: 13, 9, 36, 7, 3. Il terzo non è 9⋅3+1=289 \cdot 3 + 1 = 28.

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;
}
istruzionea sinistrasi valuta la destra?okb
iniziale?7
ok = x != 0 && 10 / x > 1;0 != 0 è 0no: && con sinistra falsa07
ok = x <mark> 0 || b++ > 0;0 </mark> 0 è 1no: || con sinistra vera17
ok = x != 0 || b++ > 0;0 != 0 è 0sì: 7 > 0 è 1, poi b sale18

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

7Domande