Newsgroup: it.comp.lang.visual-basic
Titolo: [Errata Corrige]Re: ?overflow perchè??

nel mio messaggio di ieri, intitolato "Re: ?overflow perchè??" ho detto una
boiata.
Ho asserito che VB valuta le espressioni da destra verso sinistra a parità
di parentesi.
Ringrazio Fabrizio Parrella che mi ha indotto ad una ricerca, di cui riporto
la documentazione M$.
A parte questo errore il resto del messaggio è comunque corretto, e
l'overflow in
((230 * 10) + 125) + (((230 * 10) + 125) * 20 / 100)
si verificava non perchè VB l'incontrasse eseguendo prima il blocco
(((230 * 10) + 125) * 20 / 100)
ma perchè VB l'incontra nelle parentesi più interne.
(230 * 10) + 125) * 20
Ciao a tutti. (sembra strano ma a volte sbaglio anch'io... :) )
P.s.: incredibile quanta roba interessante si trova durante quste
ricerche...
------------------------------------------------------
Precedenza tra gli operatori
Quando un'espressione contiene varie operazioni, ciascuna parte viene
valutata e risolta secondo un ordine prestabilito, definito "precedenza tra
gli operatori".
Se le espressioni includono operatori di diverso tipo, gli operatori
aritmetici vengono valutati per primi, seguiti daglioperatori di confronto e
infine dagli operatori logici. Per gli operatori di confronto non esiste un
ordine di precedenza, ovvero vengono semplicemente valutati da sinistra a
destra nell'ordine in cui compaiono. Gli operatori aritmetici e gli
operatori logici vengono valutati in base all'ordine di precedenza indicato
nella seguente tabella:
Aritmetici Di confronto Logici
Elevazione a potenza (^) Uguaglianza (=) Not
Negazione (–) Disuguaglianza (<>) And
Moltiplicazione e divisione (*, /) Minore di (<) Or
Divisione tra interi (\) Maggiore di (>) Xor
Modulo aritmetico (Mod) Minore o uguale a (<=) Eqv
Addizione e sottrazione (+, –) Maggiore o uguale a (>=) Imp
Concatenamento di stringhe (&) Like
Is
Quando in un'espressione compaiono una moltiplicazione e una divisione, ogni
operazione viene valutata nell'ordine in cui è visualizzata, da sinistra a
destra. Lo stesso vale per un'addizione e una sottrazione all'interno di una
stessa espressione. Utilizzando le parentesi tonde, è possibile ignorare
l'ordine di precedenza e far in modo che alcune parti di un'espressione
vengano valutate prima di altre. Le operazioni tra parentesi tonde hanno
sempre la precedenza rispetto alle altre. All'interno delle parentesi tonde,
tuttavia, viene rispettata la normale precedenza tra gli operatori.
L'operatore di concatenamento di stringhe (&) non è un vero e proprio
operatore aritmetico. Per quanto riguarda la precedenza, segue tutti gli
operatori aritmetici e precede tutti gli operatori di confronto.
L'operatore Like, pur avendo precedenza uguale a tutti gli operatori di
confronto è di fatto un operatore per il confronto fra criteri di ricerca.
L'operatore Is viene utilizzato per il confronto del riferimento degli
oggetti. Non confronta infatti gli oggetti e i loro valori ma verifica
soltanto se due riferimenti di oggetto sono relativi allo stesso oggetto.

(230 * 10) + 125) * 20
Allora: (230 * 10) + 125) * 20 = 48500
Dato che VB assume che le costanti sono Integer,  48500 e' troppo grande
(integer -32768:32767).
Soluzione:
Basta dirgli che deve lavorare con i LONG, es:
    X = ((230& * 10) + 125) + (((230& * 10) + 125) * 20 / 100)
Ciao
By -MES-   Maronese Ettore
http://ilmes.freeweb.org
(con OCX per stampare i recordset)
Sito Comune di programmatori Visual Basic
http://www.murialdo.it/it_lang_vb




una cosa non è detta nell'articolo...
se scrivo 10*5/2=    ?
in Ansi C e VB
(10*5)/2
perchè prima si calcolano le moltiplicazioni poi le divisioni, prima le
addizioni poi le sottrazioni....
se si ha: 10*5*2
in Ansi C
10*(5*2)
in VB non ne sono sicuro ma dovrebbe essere uguale..... ma credo che sia
poco importante sapere l'esatto ordine di due moltiplicazioni (...credo!!),
comunque vedendo le precedenze degli operatori di VB che sono uguali a
quelle in C, anche l'ordine di valutazione di un'espressione dovrebbe essere
uguale.... no?
mi fa piacere essere stato d'aiuto a qualcuno... mi avete aiutato
tante(issime) volte a me!!
