Differences

This shows you the differences between two versions of the page.

Link to this comparison view

appunti3s:operazioni_su_int [2018/04/25 07:55] (current)
Line 1: Line 1:
 +====== Operazioni su int ======
 +Le classiche operazioni aritmetiche hanno un preciso ordine di precedenza. In questo elenco quelle più in in alto hanno precedenza maggiore, mentre quelle che si trovano sulla stessa riga hanno lo stesso ordine di precedenza:
 +
 +  * negazione, incremento e decremento: <​code>​ ! ++ -- </​code>​
 +  * aritmetici <​code>​ / * % </​code>​
 +  * aritmetici <​code>​ + - </​code>​
 +  * confronto <​code>​ > < == <= >= != </​code>​
 +  * logici <​code>​ && </​code>​
 +  * logici <​code>​ || </​code>​
 +  * assegnazione <​code>​ = += *= -= /=  </​code>​
 +
 +===== Incremento =====
 +L'​operatore incremento di uno (//++//), esiste in due versioni che hanno effetti leggermente diversi a seconda che l'​operatore preceda (//++x//) oppure segua (//x++//) l'​identificatore della variabile. Si veda il seguente esempio:
 +
 +<code cpp incremento.cpp>​
 +#include <​iostream>​
 +int main()
 +{
 +   int a=0, b=0, x=100;
 +   a = ++x; // prima incrementa x, poi esegue l'​assegnazione
 +            // x vale 101, a vale 101
 +   ​std::​cout << "​valori di x, a: "<<​ x << ' ' << a << std::endl; // stampa 101 e 101
 +   
 +   b = x++; // prima esegue l'​assegnazione,​ poi incrementa x
 +            // x vale 102, b vale 101
 +   ​std::​cout << "​valori di x, b: "<<​ x << ' ' << b << std::endl; // stampa 102 e 101
 +   ​return 0;
 +}
 +</​code>​
 +
 +Questi effetti "​collaterali"​ si hanno solo quando l'​operatore incremento (o decremento) sono usati nelle assegnazioni. In una istruzione per incrementare un contatore questo effetto è quasi indifferente,​ perché il valore restituito non viene usato e viene scartato. Ad esempio in:
 +<​code>​ i++; </​code>​
 +
 +==== La verità ====
 +In realtà, anche se i commenti nel precedente programma sembrano spiegare correttamente il risultato che si ottiene ​ output, essi __non sono corretti__.
 +
 +Per sapere cosa accade veramente bisogna conoscere il significato di //valore restituito//​. ​
 +Anche l'​operatore //x++// incrementa immediatamente la //x// a 102 (ancor prima di eseguire l'​assegnazione). L'​operatore //x++// però, __restituisce__ come valore il __vecchio__ valore di //​x//​. ​
 +
 +Quando si dice che l'​operatore restituisce il vecchio valore (101), si deve immaginare che prima venga eseguita l'​espressione a destra del segno di uguale, intende che accade la seguente sequenza di operazioni:
 +  - <​code>​b = x++; // x vale 102</​code>​
 +    - x++ viene valutato
 +    - dentro x viene memorizzato 102
 +    - x++ restituisce 101, come se fosse sostituito da 101...
 +  - <​code>​b = 101; // 101 è il valore restituito dopo il calcolo su x</​code>​
 +
 +Viceversa l'​operatore //++x// dopo aver effettuato l'​incremento,​ restituisce il __nuovo__ valore di x.
 +
  
  • appunti3s/operazioni_su_int.txt
  • Last modified: 2018/04/25 07:55
  • (external edit)