shodan ha scritto:
ma quell'espressione è univoca (22/11*2=4)
Se la leggi come (22/11) * 2 (come il 99% della gente) si, ma c'è anche chi la legge come 22 / (11 *2) dato che moltiplicazione e divisione hanno pari priorità.
Ho visto flame assurdi su giochini ambigui come questo. Volevo semplicemente rimarcare che se non esistono regole di precedenza (tipo gli operatori) o l'ordine di apparizione (si opera da sx a dx), sia 4 sia 1 sono risultati validi. Nell'espressione dell'OP la x va valutata prima o dopo la chiamata alla funzione? VC++ la valuta dopo (e qui concordo con oregon dato che la chiamata a funzione ha precedenza più alta di moltiplicazione o divisione anche se l'intera espressione può essere valutata a compile time); gcc la valuta prima (e può essere un bug).
In ogni caso due compilatori danno due valori diversi e solo perché l'espressione dell'OP è ambigua.
La morale è: evitare espressioni ambigue.
Sul fatto che adottare norme di buona programmazione ci consente di evitare rogne del genere siamo tutti d'accordo, ma qui la questione è definire precisamente quali sono i confini dell'ambiguità.
Riguardo all'espressione 22/11*2 il risultato in C/C++ è solo 4, visto che qui intervengono esclusivamente le regole di precedenza e associatività degli operatori (che sono ben definite dal linguaggio) e nulla conta l'ordine di valutazione degli operandi (che al contrario non è definito dallo standard).
Riguardo invece alla maggiore affidabilità di VC sottolineata da te e @oregon ho qualche dubbio, nel senso che non sono tanto sicuro che il concetto di precedenza applicato alla chiamata a funzione sia quello da voi ipotizzato. Consideriamo per esempio il seguente codice:
#include <stdio.h>
int fun(int x)
{
printf("fun(%d)\n", x);
return x;
}
int main()
{
int a = 3;
int b = 3;
int c = ++a + fun(a);
printf("c=%d\n\n", c);
int d = fun(b) + ++b;
printf("d=%d\n\n", d);
return 0;
}
Io con gcc ottengo il seguente output:
fun(4)
c=8
fun(3)
d=7
Process returned 0 (0x0) execution time : 0.019 s
Press any key to continue.
Stando al vostro ragionamento la chiamata a funzione ha la priorità sull'incremento prefisso e quindi con VC dovrebbe risultare c=d, giusto?
Io invece prevedo che otterrete un output simile al mio, ma invertito, in quanto qui non entra in gioco la precedenza degli operatori, ma solo l'ordine di valutazione degli operandi che come tu stesso hai detto risulta essere da sinistra a destra in gcc e da destra a sinistra in VC.
Fatemi sapere.