overflow | Michele Maffucci

In realtà l’errore che viene commesso non è di carattere informatico, ma puramente matematico, dimenticando l’ordine con cui vengono eseguite le operazioni matematiche.
L’ordine delle operazioni segue le regole di base: moltiplicazioni e divisioni hanno precedenza massima seguono addizioni e sottrazioni. Se si vuole cambiare l’ordine di precedenza bisogna utilizzare le parentesi. Vediamo alcuni esempi.

`1`	`int` `valore = 1 + 2 * 3 + 4;`

il risultato sarà 11.

1// Prof. Michele Maffucci
2// Data: 08.02.2020
3// Esempio 01: Ordine di esecuzione operazioni matematiche in C
4 
5// per stampare una sola volta il messaggio sulla Serial Monitor  
6bool abilitaMessaggio = 0;
7 
8void setup() {
9  // inizializzazione della comunicazione seriale
10  Serial.begin(9600);
11}
12 
13void loop() {
14  // consente di visualizzare sulla Serial Monitor
15  // una sola stampa delle stringa
16  if (abilitaMessaggio == 0) {
17    // ritardo che evita la doppia stampa del messaggio 
18    delay(200);
19    Serial.println("Calcolo:");
20    Serial.println("valore = 1 + 2 * 3 + 4");
21    int valore = 1 + 2 * 3 + 4;
22    Serial.print("valore = ");
23    Serial.println(valore);
24    abilitaMessaggio = 1;
25  }
26}

Per rendere più evidente la sequenza di esecuzione del calcolo possiamo usare le parentesi, pertanto otterremo:

`1`	`int` `valore = 1 + (2 * 3) + 4;`

Che fornisce sempre il valore 11.

1// Prof. Michele Maffucci
2// Data: 08.02.2020
3// Esempio 02: Ordine di esecuzione operazioni matematiche in C
4 
5// per stampare una sola volta il messaggio sulla Serial Monitor  
6bool abilitaMessaggio = 0;
7 
8void setup() {
9  // inizializzazione della comunicazione seriale
10  Serial.begin(9600);
11}
12 
13void loop() {
14  // consente di visualizzare sulla Serial Monitor
15  // una sola stampa delle stringa
16  if (abilitaMessaggio == 0) {
17    // ritardo che evita la doppia stampa del messaggio 
18    delay(200);
19    Serial.println("Calcolo:");
20    Serial.println("valore = 1 + (2 * 3) + 4");
21    int valore = 1 + (2 * 3) + 4;
22    Serial.print("valore = ");
23    Serial.println(valore);
24    abilitaMessaggio = 1;
25  }
26}

Per modificare la precedenza utilizziamo le parentesi:

`1`	`int` `valore = ((1 + 2) * 3) + 4;`

il risultato sarà 13. Viene eseguito prima il calcolo della parentesi più interna (1+2), poi si passa alla parentesi immediatamente successiva, quindi (3 * 3) e poi il risultato viene sommato a 4.

1// Prof. Michele Maffucci
2// Data: 08.02.2020
3// Esempio 03: Ordine di esecuzione operazioni matematiche in C
4 
5// per stampare una sola volta il messaggio sulla Serial Monitor  
6bool abilitaMessaggio = 0;
7 
8void setup() {
9  // inizializzazione della comunicazione seriale
10  Serial.begin(9600);
11}
12 
13void loop() {
14  // consente di visualizzare sulla Serial Monitor
15  // una sola stampa delle stringa
16  if (abilitaMessaggio == 0) {
17    // ritardo che evita la doppia stampa del messaggio 
18    delay(200);
19    Serial.println("Calcolo:");
20    Serial.println("valore = ((1 + 2) * 3) + 4");
21    int valore = ((1 + 2) * 3) + 4;
22    Serial.print("valore = ");
23    Serial.println(valore);
24    abilitaMessaggio = 1;
25  }
26}

Ovviamente, come già spiegato precedentemente, bisognerà sempre fare attenzione che il risultato faccia parte del tipo di dati giusto, ad esempio quando effettuate una divisione tra interi il cui risultato è un numero decimale, o ancora se superate il valore massimo del tipo di dato che state utilizzando. In entrambi i casi il compilatore non vi segnalerà nessun errore.

Vediamo un esempio:

`1`	`// 60 secondi in un minuto, 60 minuti in un'ora, 24 ore in un giorno`

`2`	`long` `secondi_in_un_giorno = 60 * 60 * 24;`

In teoria, poiché il risultato è 86.400, questo valore potrà essere contenuto in un tipo long.
Ma in realtà il valore realmente memorizzato in “secondi_in_un_giorno” è 20.864.
86.400 supera più di due volte la dimensione di un intero, il calcolo fatto dal compilatore sarà il seguente:
86.400 – 32.768 * 2 = 20.864

1// Prof. Michele Maffucci
2// Data: 08.02.2020
3// Esempio 04: Ordine di esecuzione operazioni matematiche in C
4//             errore di calcolo dovute al tipo del dato (dimensione massima).
5 
6// per stampare una sola volta il messaggio sulla Serial Monitor  
7bool abilitaMessaggio = 0;
8 
9void setup() {
10  // inizializzazione della comunicazione seriale
11  Serial.begin(9600);
12}
13 
14void loop() {
15  // consente di visualizzare sulla Serial Monitor
16  // una sola stampa delle stringa
17  if (abilitaMessaggio == 0) {
18    // ritardo che evita la doppia stampa del messaggio 
19    delay(200);
20    Serial.println("Calcolo (errato) numero di secondi in un giorno:");
21    Serial.println("secondi_in_un_giorno = 60 * 60 * 24");
22    long secondi_in_un_giorno = 60 * 60 * 24;
23    Serial.print("Secondi in un giorno = ");
24    Serial.println(secondi_in_un_giorno);
25    Serial.println("Errore! Il valore doveva essere: 86.400");
26    Serial.println("L'errore si verifica perchè il compilatore considera i numeri di tipo int.");
27    abilitaMessaggio = 1;
28  }
29}

Ciò accade perché il compilatore C dell’IDE di Arduino vede un’espressione aritmetica composta da soli numeri interi e quindi considera il risultato come tipo int. Per evitare questo problema bisogna dire al compilatore che deve trattare l’intera espressione come un long aggiungendo L al primo valore che viene valutato nell’espressione:

`1`	`long` `secondi_in_un_giorno = 60L * 60 * 24;`

1// Prof. Michele Maffucci
2// Data: 08.02.2020
3// Esempio 05: Ordine di esecuzione operazioni matematiche in C
4//             Uso corretto del tipo long.
5 
6// per stampare una sola volta il messaggio sulla Serial Monitor  
7bool abilitaMessaggio = 0;
8 
9void setup() {
10  // inizializzazione della comunicazione seriale
11  Serial.begin(9600);
12}
13 
14void loop() {
15  // consente di visualizzare sulla Serial Monitor
16  // una sola stampa delle stringa
17  if (abilitaMessaggio == 0) {
18    // ritardo che evita la doppia stampa del messaggio 
19    delay(200);
20    Serial.println("Calcolo corretto del numero di secondi in un giorno:");
21    Serial.println("secondi_in_un_giorno = 60L * 60 * 24");
22    long secondi_in_un_giorno = 60L * 60 * 24;
23    Serial.print("Secondi in un giorno = ");
24    Serial.println(secondi_in_un_giorno);
25    Serial.println("Giusto! Abbiamo detto con la L che l'intera espressione è da trattate come un long.");
26    Serial.println("");
27    abilitaMessaggio = 1;
28  }
29}

Attenzione sempre alle parentesi!
Se le utilizzate ad esempio come nell’esempio che segue farà andare in overflow il risultato:

`1`	`long` `secondi_in_un_giorno_piu_uno = 1L + 60 * (60 * 24);`

1// Prof. Michele Maffucci
2// Data: 08.02.2020
3// Esempio 06: Ordine di esecuzione operazioni matematiche in C
4//             L'uso non corretto delle parentesi fa andare in overflow il risultato.
5 
6// per stampare una sola volta il messaggio sulla Serial Monitor  
7bool abilitaMessaggio = 0;
8 
9void setup() {
10  // inizializzazione della comunicazione seriale
11  Serial.begin(9600);
12}
13 
14void loop() {
15  // consente di visualizzare sulla Serial Monitor
16  // una sola stampa delle stringa
17  if (abilitaMessaggio == 0) {
18    // ritardo che evita la doppia stampa del messaggio 
19    delay(200);
20    Serial.println("Calcolo errato somma 1 al numero di secondi in un giorno");
21    Serial.println("secondi_in_un_giorno_piu_uno = 1L + 60 * (60 * 24)");
22    long secondi_in_un_giorno_piu_uno = 1L + 60 * (60 * 24);
23    Serial.print("Secondi in un giorno + 1 = ");
24    Serial.println(secondi_in_un_giorno_piu_uno);
25    Serial.println("Sbagliato! Attenzione sempre alle parentesi!");
26    Serial.println("Se le utilizzate ad esempio come indicato farà andare in overflow il risultato");
27    abilitaMessaggio = 1;
28  }
29}

mentre la seguente espressione non farà andare in overflow il calcolo:

`1`	`long` `secondi_in_un_giorno_piu_uno = 1 + 60 * (60L * 24);`

1// Prof. Michele Maffucci
2// Data: 08.02.2020
3// Esempio 07: Ordine di esecuzione operazioni matematiche in C
4//             L'ordine del calcolo viene stabilito dalle parentesi, in questo modo
5//             il calcolo non farà andare in overflow il risultato.
6 
7// per stampare una sola volta il messaggio sulla Serial Monitor  
8bool abilitaMessaggio = 0;
9 
10void setup() {
11  // inizializzazione della comunicazione seriale
12  Serial.begin(9600);
13}
14 
15void loop() {
16  // consente di visualizzare sulla Serial Monitor
17  // una sola stampa delle stringa
18  if (abilitaMessaggio == 0) {
19    // ritardo che evita la doppia stampa del messaggio 
20    delay(200);
21    Serial.println("Calcolo errato somma 1 al numero di secondi in un giorno");
22    Serial.println("secondi_in_un_giorno_piu_uno = 1 + 60 * (60L * 24)");
23    long secondi_in_un_giorno_piu_uno = 1 + 60 * (60L * 24);
24    Serial.print("Secondi in un giorno + 1 = ");
25    Serial.println(secondi_in_un_giorno_piu_uno);
26    Serial.println("Corretto! Il calcolo inizierà dalle parentesi tonde.");
27    Serial.println("E' stata aggiunta la L al primo operando tra le parentesi tonde.");
28    abilitaMessaggio = 1;
29  }
30}

Buon Coding a tutti

Michele Maffucci

… my stories, life and work

Archivi tag: overflow

Errori comuni nell’uso di Arduino – ordine esecuzione operazioni matematiche e overflow nei calcoli

Condividi:

Articoli correlati: