Newsgroup: it.comp.lang.visual-basic
Titolo: Strano errore

Boh, capiteranno tutte a me... perň non capisco perchč questo ciclo non va:
Dim i As Byte
For i = 6 To 1 Step -1 <--- Al primo giro va in overflow
   Debug.Print i
Next i
...mentre questo si:
Dim i As Byte
For i = 1 To 6
   Debug.Print i
Next i
Vi prego, non ditemi che č perchč il tipo di dati Byte non accetta i
negativi, perchč č il solo "step" ad essere impostato cosě, la variabile "i"
va da 6 a 1.
Paolo

 impostato cosě, la variabile "i" va da 6 a 1.
E' proprio cosi' invece :)
i = 6
Do Until i = 1
    Debug.Print i
    i = i - 1
Loop
Lokar 

 E' proprio cosi' invece :)
Lo so che č cosě, ma a me pare un'anomalia. Io credo che dovrebbe andare in
errore qualora "i" passasse in negativo. Lo "step -1" č un'operazione, mica
l'assegnazione di una variabile...
Paolo

 l'assegnazione di una variabile...
Concordo sul fatto che sia "stupido" pero' VB considera il tipo dell'incremento uguale al tipo della 
variabile da decrementare, ed indovina che errore si ottiene eseguendo:
Dim i As Byte
i = -1
Lokar 

 l'assegnazione di una variabile...
TUTTE le operazioni matematiche (e lo step non è altro che la somma del 
valore corrente con lo step stesso), comportano la conversione di TUTTI 
gli operandi nel medesimo tipo. E tale tipo viene scelto secondo una 
serie di regole.
Questo vale per qualunque ambiente di sviluppo (del resto, se si 
vogliono sommare/sottrarre/moltiplicare/dividere due numeri, dovranno 
essere rappresentati binariamente nello stesso modo, altrimenti il 
processore che fa?), non è un discorso di VB.
Quindi, ogni volta che ci sono numeri diversi in una stessa 
espressione, siano essi costanti o variabili, occorre SEMPRE porsi il 
quesito di come funzioni la conversione che implicitamente avverrà.
In questo caso, è una cosa banale, ma pensa solamente a quando si 
utilizzano Double e Long in una stessa espressione, quando si passa 
quindi da una rappresentazione in virgola fissa ad una in virgola 
mobile, con tutte le approssimazioni del caso.
Ciao
Alberto
-- 
A questo punto hanno trovato un muro,
un muro duro, molto molto duro,
che siamo noi.

 serie di regole.
Non sempre. E' questo che fa inca%%are...
  Dim B As Byte
  Dim C As Byte
 
  B = 100
  C = B + (-1)
-- 
State-of-the-practice: What we can do with the money you have.
News 2000 [v 2.06] - 
http://www.akapulce.net/socket2000

   C = B + (-1)
Questo funziona benissimo, ovviamente.
Ripeto:
"TUTTE le operazioni matematiche (e lo step non è altro che la somma 
del
valore corrente con lo step stesso), comportano la conversione di TUTTI 
gli operandi nel medesimo tipo. E tale tipo viene scelto secondo una
serie di regole."
Non che queste regole siano complesse, ma in particolare ne esiste una 
fondamentale, che rappresenta l'ABC della matematica in informatica: il 
tipo 'di destinazione' delle conversioni implicite è sicuramente più 
capiente di tutti gli altri.
Nella tua operazione, hai inserito un -1, che è un INTEGER, e integer è 
più capiente di byte.
Quindi, la tua operazione è (esplicitando):
C = CByte (Cint(B) + (-1) )
Il problema è il solito: la gente non conosce le cose, anche le più 
'fondanti', e se la prende con lo strumento, che non fa altro che fare 
il suo lavoro secondo precise regole.


 il suo lavoro secondo precise regole.
Oh, già. Per fortuna al mondo ci sono *gli imparati* che dall'alto 
delle loro posizioni dispensano la conoscenza. Grazie maestro.
-- 
Your password is pitifully obvious.
News 2002 [v 2.07] / StopDialer / PopDuster - 
http://www.socket2000.com
Akapulce portal: 
http://www.akapulce.net

 delle loro posizioni dispensano la conoscenza. Grazie maestro.
Prego.


 delle loro posizioni dispensano la conoscenza. Grazie maestro.
Vedi...questa è proprio una cosa da NON FARE su un ng tecnico!
Perchè?
Perchè crei un danno a te ed agli altri dopo di te....
Tu hai detto "gli imparati"...beh si è vero!
TU sei lo IGNORANTE
Albe è l'ISTRUITO
se tu prendi per il culo L'istruito....resterai ignorante tutta la
vita!
E questo fondamentalmente non son cazzi di Albe...son cazzi tuoi!
Te capì testina???!

 E questo fondamentalmente non son cazzi di Albe...son cazzi tuoi!
Appunto, sono cazzi miei e so quel che faccio, sono grande e 
vaccinato. Dunque di che t'impicci?
-- 
Is reading in the bathroom considered Multi-Tasking?


mi impiccio anche io, va'.
Ehi, signori. meglio smettere questo codazzo 3d.
Non tutte le persone usano gli stessi toni che un altro si aspetterebbe.
Basta prenderne atto. Gli amici si autoselezionano. Non dovrebbero mai convivere 
forzatamente.
Daniele

 usenet).
zac
ecco un altro com<boooop> del biiiip
che <biiiip> centra la democrazia???
Albe ti ha detto....i compilatori...QUALSIASI compilatore ha delle
convenzioni interne...e NESSUN...nessun compilatore può prevedere
tutte le combinazioni dell'utonto!
Utonto ?...beh si!
Perchè il VB cerca di sforzarsi di capire quello che fai....e in
mancanza di dati dell'utonto cerca di metterci del suo....
Il tuo esempio è un caso limite.....
ti è stato risposto...
IO e Albe cerchiamo di tipizzare il più possibile......tu sei
"democraticamente" padrone di fare come vuoi!..ma non ti aspettare un
compilatore che abbia la palla di cristallo...ci stanno lavorando ma
non è ancora pronto!
Quindi è inutile che prendi per il culo il compilatore di
vb6.....preferisci quello di un qualsiasi C(++) che ti manda un warning
(al limite) e digerisce (anche sbagliando) tutto?
Ma C è roba da guru eh....!!! Di quello "democraticamente" non ti
arrabbi eh?!
Perchè se prendi un qualsiasi libro di programmazione (in generale) e
in C in particolare...ci sono interi capitoli sulla dichiarazione di
variabile e sul cast?
Perchè tutti i libri e tutti i guru si soffermano così tanto sul cast
e sulla dichiarazioni delle variabili?
Son tutti pazzi?
Perchè non si legge la documentazione di un compilatore prima di
sparare su chi lo fa?
Microsoft fa tanti arrosti...è vero....però almeno il 50% son errori
dei "programmatori" che affibbiano a Microsoft per non ammettere di
avere sbagliato la scrittura del codice!
Risposta al tuo quesito te l'ha data Albe...se tipizzi esplicitamente
il tutto...l'errore non salta fuori!...è un problema di cast(ing)
delle variabili...
Cosa altro vuoi....???
Democraticamente parlando ti cito
"...Mando a quel paese tutti se se lo meritano"
Ti hanno risposto esaurientemente...continui a dire "ma ma ma..."
.......continui a dire "fa tutto schifo allora se è così"....
abbi pazienza ma sembra che i fessi siamo noi e tu l'alieno sceso
dall'ufo con la saggezza a dirci che "Microsoft fa schifo ed il suo
compilatore vb6 ancor di più"
quindi....se 2+2 =4
Ti mandi da solo a quel paese?
Ciao!

 Daniele
Eh no!
Non puoi neanche stare sempre zitto...considera che nessuno fa da call
center ne da Knowledge base on line....
E  dare risposte e sentirsi anche attaccati con un ribaltamento per cui
il fesso sei tu e il guru il lamer...abbi pazienza...si sopporta 9
volte...alla 10ima si scatta!

 compilatore vb6 ancor di pi=F9"
Quindi non hai capito una cippa. Andiamo bene. Ti esorto a trovarmi 
queste mie dichiarazioni in merito al VB.
-- 
What Goes Around Comes Around 


Due di Picche ha scritto:
o signur benedetto!
ripartiamo da zero
ESEMPIO 1
Dim i As Byte
For i = 6 To 1 Step -1 <--- Al primo giro va in overflow
   Debug.Print i
Next i
ESEMPIO 2
Dim i As Byte
For i = 1 To 6
   Debug.Print i
Next i
Il primo non va....logicamente....
scritto nei meandri dell'help e trovabilissimo comunque con
sanGoogle...si viene a scoprire che dopo una operazione e prima di una
assegnazione il compilatore valuta se l'assegnamento "ci sta" il quel
tipo di dati!
Ora che tipo di dati USI nell'esempio 1?
Boh!
si sa che i è byte mentre 1 non si sa...si lascia fare a lui!
Ora se lasci fare a lui ...lui adotta CONVENZIONI...che come tutte le
convenzioni sono OPINABILI...ma basta saperlo!
Per saperlo basta leggere...o fare alcune prove....
NON METTERE OPTION EXPLICIT
esegui
Private Sub Command2_Click()
a = 1
b = VarType(a)
Debug.Print b
End Sub
b=2 ossia 1 è un INTEGER!
e va bene!
è il tipo di dato PIU' picccolo come occupazione di memoria che PUO'
AVERE un segno....ed è una convenzione giusta!
infatti lo STEP può essere sia in avanti che indietro ossia sia 1 che
-1
TU COSA USI?
byte...che sfrutta tutti gli 8 bit e NON considera il segno!
C'è scritto byte SOLO numeri positivi
ORA....
ATTIVA
option explicit
e prova
Private Sub Command1_Click()
Dim p As Byte
p = 1
Debug.Print Hex(p)
Stop
p = CByte(-1)
Debug.Print Hex(p)
End Sub
va in overflow sul -1.....
ricorda un pocome funzionano le rappresentazioni di dati in memoria
....per avere un numero negativo si butta via un bit per fargli fare il
bit di segno.
http://a2.pluto.it/a2617.htm
tra le altre cose il bit di segno in genere è anche il più
significativo...tanto che per fare diventare un numero negativo si fa
l'or sul più significativo che equivale ad aggiungere una cifra molto
grande (il quanto dipende da quanti byte usi per rappresentare un
intero)
se io ho 8 bit e nessun bit di segno....perchè mi ci vuoi ficcare
dentro un numero a 16 bit???...è logico che non ci sta!!!
e siccome vb è un compilatore che controlla prima di assegnare
qualcosa...ti da overflow!
quindi io riscriverei il tutto con
Private Sub Command2_Click()
Dim n As Integer
Dim dato As Byte
For n = 7 To 1 Step -1
    dato = CByte(n)
    Debug.Print dato
Next n
End Sub
Che è esattamente...in altre parole....quello che ti ha detto Albe....
Se ESPLICITI il tipo di dati e SAI (come ogni programmatore
dovrebbe...) come si comportano le rappresentazioni dei dati...NON
incorri in bug concettuali!
Perchè se sei onesto intellettualmente alla fine di tutto quanto
detto...riconosci che il tutto NON E' un bug di Microsoft...ma una
svista...una dimenticanza...una ignoranza personale!
Ed è irragionevole attribuire un mio difetto al lavoro (anche
strapagato) di altri!
Quindi ripeto....
adesso ti ci mandi da solo affanbagno???
p.s.
tra le altre cose se usi un ciclo è dimostarto che un piccolissimo
vantaggio si ha in VB6 usando LONG invece che INTEGER!(in net è
l'opposto proprio per via di quanti byte usano per rappresentare un
numero) 
Saluti!

 adesso ti ci mandi da solo affanbagno???
Mando te, se proprio vuoi sentirtelo dire.
-- 
Make sure comments and code agree.


Mi spiace aver creato con il mio post degli alterchi, non era nelle mie
intenzioni. Vi ringrazio comunque tutti per le spiegazioni dalle quali
trarrò senz'altro profitto.
Paolo

 intenzioni. 
Tranquillo :-) Ci sono e ci saranno sempre persone che fanno pesare la
propria competenza, altre no, ognuno reagisce come crede :-) L'importante è
che nel thread ci siano spunti interessanti, come in questo caso.
Ciao
PaF

PaF ha scritto:

Beh egregio paf il discorso della competenza e del peso è sempre
suscettibile di interpretazione....
Se ti posso dire fuor dai denti cosa penso...
penso sempre le solite cose.....
Che VB6 oramai lo hanno scaricato tutti ....
Che tutti son "programmatori in VB"
Che il NG vien scambiato per un help desk
Che non c'è nessuna gratificazione e tutto si basa sul
volontariato...e a furio di prendere pesciate in faccia si comincia a
restituirle ...o a non postare più...
Che tutti siete buoni a succhiare ma nessuno mette nulla...
Che le critiche son accette quando costruttive ...altrimenti fatele
alle vostre sorelle....
Che il NG è veramente rimbastardito etc etc etc
Tutte cose già sentite.....io dopo parecchio che non postavo....mi son
rimesso a leggere il ng...e a partecipare ...noto che il tasso di
presupponenza è parecchio aumentato!
E lo noto anche nella vita reale....stormi di giovani che credono di
sapere oramai tutto della proogrammazione....e mi entrano in crisi se
gli chiedo di memorizzarmi un file di opzioni su un file!
Non mi considero un padre fondatore....no no no...ma questo NG c'è
stato un periodo in cui viveva con altra gente...altri toni...altre
discussioni....
Con qualche Franco.....ma con tanti Hal Gbc Zanna Fibia...etc
etc(scusate che non nomino)....
Ora io ti dico....non vuole nessuno aperture di credito a
prescindere.....
ma un minimo di rispetto per chi ...probabilmente....quando eravate a
giocare alla playstation...contribuiva a far crescere questo
NG....ebbè....
Cmq...fate come vi pare.....
cosa volete sentir dire
"il compilatore di Vb fa schifo? ...certo...come tutti quelli di
Microsoft..."
fate come vi pare.....però una frecciatina finale ve la tiro!
Poveri clienti vostri!
Sarà meglio che smetta di postare di nuovo...non c'è peggior sordo di
chi non vuol sentire!

 o, perlomeno, della logica usata per compilare il ciclo. L'operazione
zac
mi fai questo esempio ....non hai capito (o non vuoi capire) nulla!
Forse abituato al compilatore C (Compilatore che per scelta concettuale
presuppone SEMPRE che tu sappia quello che stai facendo...e arma di
distruzione di massa in mano a incompetenti)...continui a mischiare
Pere con Bulloni.
evvabbe! è un difetto di comunicazione mio!
Ciao!
....
Fai come ti pare!
:o)

 Next x
zac
Però una ennesima piccola imbeccata te la do...se ne hai voglia la
sviluppi...in proprio però....
NON è una operazione di DECREMENTO NO NO NO
e io continuo a sostenere che sei affetto da un bug tuo concettuale...e
che se non correggi in vb6 ti porterà ad arrosti inimmaginabili!!!!
For n=1 to 10 step 1 per te è un incremento? NO!
perchè lo STEP non è fisso è una istruzione MOLTO più versatile
per capirci non è:
 a++
guarda come riscrivo un for next step:
for n= 1 to 12 step 4
LO STEP è una variabile anch'essa che AGGIUNGI o SOTTRAI
ecco che diventa
n=n+(step)
 NON n++ o n-- nel qual caso avresti ragione!!!
il vb6 NON ha l'operatore di incremento o decremento...(il NET mi
sembra di si)
Il tuo errore concettuale è applicare una convenzione di C o Delphi ad
un linguaggio che non ha questi operatori e quindi non ha queste
convenzioni!
Volevo solo farti riflettere ...se vuoi...su questo!
Ri-Saluti!

 Pere con Bulloni.
Hai ragione tu, contento?
-- 
God made machine language; all the rest is the work of man.


 che se non correggi in vb6 ti porter=E0 ad arrosti inimmaginabili!!!!
ciccio, sono almeno 20 anni che mi balocco con i linguaggi di 
programmazione e non mi risulta abbia arrostito nessuno. Se permetti 
qualche cosa avrò imparato. E quando dico che l'implementazione sul 
VB è ERRATA CONCETTUALMENTE E LOGICAMENTE ho le mie ragioni. Poi io 
non voglio convincere nessuno. Se hai la pazienza di andare a 
ripercorrerti i thread lo noterai e noterai come non sia IO ad 
attaccare e a dare dell'ignorante agli altri, ma l'amico che stai 
supportando. E risparmiati le banalità tipo "non ci sono più le mezze
stagione" o "ai miei tempi queste cose non succedevano..."
-- 
IBM: It's Become Monolithic


 agli altri, ma l'amico che stai supportando.
Giusto una precisazione: quando ho detto "la gente non conosce le 
cose", mi riferivo all'OP (che, avendo posto il quesito, è ovvio che 
non conoscesse le cose di cui si parlava).
Ma il fatto che tu, nel post successivo, te la sia presa come un fatto 
personale, mi fa capire tante cose.
Concludo, immaginando che Wodka non stia 'supportando' me (auspico che 
il Wodka, che neppure conosco, abbia di meglio da fare che difendere 
uno sconosciuto dalle vacue escandescenze di un altro sconosciuto).
Ciao


 chi non vuol sentire!
Wodka, francamente, ma chi ti credi di essere ?
Scendi un attimo dal piedistallo e torna con i piedi per terra.
Bah ! 
PaF

 Bah ! 
Io son io....tu chi sei?

 Alberto
Beh Albe...a me fa specie che una persona come Albe...che in passato
quando ho avuto bisogno è sempre stata disponibile...
Che ha argomentato a livelli tecnici medio-alti...
che insomma...non è il primo bischero che passa per  strada....
si ritrovi ad argomentare con il "fiore" della categoria dei
programmatori....ossia con quelli che hanno SEMPRE ragione COMUNQUE
sbaglino!
E francamente complice il fatto che non tutti i giorni ci si sveglia
compassati seri e disponibili....mi ha un po fatto girare!
Poi convengo che è inutile continuare....il NG è definitivamente
affondato se ci si trova argomentazioni politiche(lei non sa chi sono
io...e via andare) e non tecniche
Un piccolo inciso:
Il mondo del lavoro non è carino! Anzi!
Se i signori rispondessero così a molti miei clienti (o anche a me)
...o argomentassero con frasi del tipo
"Ciccio ho 20 anni di lavoro alle spalle...fidati ho ragione"
prenderebbero come risposta:
"Nanni la vedi quella porta?...ecco aprila e vedi d'andà
affncu<biiip>"
Io ho imparato a turarmi il naso e prendere il buono (quello che mi
serve) da chi sà più di me (poi dentro di me lo mando a quel paese 20
volte)!
Si chiama umiltà...serve per crescere professionalmente...anche dopo
20 anni di lavoro!
Ma tu ed io Albe lo sappiamo!

 Ed è corretto che sia così!
zac
downto mi sa tanto di  x--
ma
non so nulla di delphi....chissà come si scriverebbe un decremento da
12 a 0 a step di 4 !!!
Chi lo sa me lo scrive per favore?

 n=n+(step)
Esatto, lo step č una somma.
Dall'MSDN:
"After all statements in the loop have executed, step is added to counter. At
this point, either the statements in the loop execute again (based on the same
test that caused the loop to execute initially), or the loop is exited and
execution continues with the statement following the Next statement."
Allora questi due cicli dovrebbero essere equivalenti:
Dim x As Byte
Dim z As Integer
z = -1
For x = 10 To 1 Step z
    Print x
Next x
z = -1
x = 10
Do While x >= 1
    Print x
    x = x + z
Loop
Ma in realtŕ non lo sono, in quanto il primo va in errore, e lo fa *subito*, sul
For e non sul Next, mentre stando alle specifiche, l'operazione di incremento
del contatore (l'unica che in teoria puň potenzialmente generare overflow)
avviene *dopo* aver eseguito un'iterazione.
In 
VB.NET
 succede la stessa identica cosa, ma in questo caso l'MSDN dice
qualcosina in piů:
"step Optional. Expression. The amount by which counter is incremented each time
through the loop. The step expression usually evaluates to type Integer but can
evaluate to any data type that widens to the type of counter. If not specified,
step defaults to 1. "
Sostanzialmente la prima azione che viene fatta, senza nemmeno entrare nel loop,
č la conversione dello step nello stesso tipo del contatore, solo che questo non
viene detto da nessuna parte, mentre ci si aspetterebbe che la conversione
avvenisse sul Next.
Mi sono riletto tutto il thread: il problema che 2dipicche secondo me voleva
mettere in evidenza (IMHO a ragione) č che la regola che si evince da tutto ciň
č contraddittoria rispetto a quella adottata nella valutazione delle espressioni
comuni e, cosa un po' seccante, non documentata a sufficienza in VB6.
La sua intenzione č stata invece scambiata (IMHO a torto) per uno "sputare nel
piatto dove si mangia" da parte di un lamer e cosě gli animi si sono
surriscaldati.
Resta il fatto che seguendo il consiglio di Albe di convertire sempre
esplicitamente, si previene ogni casino.
Bye
Raf
P.S. A volte ci vorrebbe un bel for i=1 to 10 prima di dar dell'ignorante o
rispondere malamente a qualcuno...

 20 anni di lavoro!
Tu predichi l'umiltà, ma leggendo le tue risposte non traspare in modo così
evidente.
Ho riletto il thread, il tutto è nato da questa frase di Albe:
"Il problema è il solito: la gente non conosce le cose, anche le più 
'fondanti', e se la prende con lo strumento, che non fa altro che fare 
il suo lavoro secondo precise regole."
Ora si può disquisire del colore del pelo ma personalmente questa frase la
interpreto come un giudizio su "Due di picche", anche se non esplicito, che
poteva essere tranquillamente evitato.
Peccato che nel thread "Due di picche" ha dimostrato di non essere uno che
non conosce il proprio strumento e nonostante questo sei entrato tu a gamba
tesa come paladino dei "vecchi" con tutta la relativa filippica.
Interessante il post di Rafunk con il quale concordo al 100%, soprattutto
la frase finale.
PaF

 esplicitamente, si previene ogni casino.
Quoto.
Bye, G. 

 e basta.
Alla fine siamo giunti alla stessa conclusione! ;-)
Ciao
Raf

 il suo lavoro secondo precise regole."
Esatto. Probabilmente anche il fatto che in un precedente thread si 
procedesse sullo stesso eahm.. *binario* mi ha fatto prendere la cosa
forse un po' troppo sul serio. 
-- 
IBM: Insidious Byzantine Mentality


 comuni e, cosa un po' seccante, non documentata a sufficienza in VB6.
Hai centrato il nocciolo della mia discussione che, a quanto pare, 
tanto velato non doveva essere.
-- 
Don't diddle code to make it faster; find a better algorithm.


 rispondere malamente a qualcuno...
Giusto giustissimo...non sempre però la mattina ci si sveglia uguali!
E comunque vada io resto della idea che al di la di quello che dice
il signore ha scambiato un for n=10 to 0 step -1
in 10 operazioni di n-- !!! scusami sarò un villano ...ma continuo a
pensarlo!...basta vedere cosa ha postato come equivalente in delphi
(che non conosco).
E anche ammettendo che io sia un malfidato e un maligno...non capisco
perchè non dica "VB è fuorviante...ma Albe a ragione a fare come dice
lui tutto si sistema!"
Perchè al di la dei modi...la sostanza non cambia....a fare come dice
Albe tutto funziona....e in questo (FINALMENTE) interessane 3ad...piano
piano si dirà anche perchè!
O no?
;o)

 Chi lo sa me lo scrive per favore?
Var
  x: byte;
begin
  x:=12;
  while x>0 do x:=x-4;
end;
-- 
Why is the alphabet in that order? Because of that song? 


 piano si dir=E0 anche perch=E8!
Grazie. Ma la sostanza di cui parlavo non era questa.
-- 
Random access is the optimum of the mass storages.


 ;o)
Ciao Wodka.
Raf

 **********
zac
uff...pelo nell'uovo.....bastava fare alcune prove....come abbiamo
fatto no?
L'errore sta nel "INCREMENTATO" mentre è giusto SOMMATO...ma reputa
anche che vb non è un linguaggio di basso livello!
Il guaio è che tu (giustamente...che ne sai!) lo hai usato per operare
su un tipo di dato che è più basso di integer fidando nella
differenza fra "incremento di una variabile contatore" e "Somma di
variabile intera ad una variabile usata come contatore".
L'help si è dimenticato di dire che la variabile step è almeno un
intero e di default se non si dice nulla è quello....non ho l'help
sottomano...forse lo dice da qualche altra parte!
Io però dico che...basta fare un po di prove...e si capisce il
tutto....
Dico anche che il tipo byte è abbastanza inefficiente in VB6 e si usa
"normalmente" poco ...molto poco....
Che se voglio operare sui byte è possibilissimo in vb6 basta avere
alcune accortezze
Che purtroppo in vb6 non ho accesso a incrementi e decrementi di
variabili
e devo scrivermi a=a+1
Che gli help non sono "oro colato" e se una cosa non funziona un po di
prove sono d'uopo!
Non credo che anche l'help di delphi non abbia una pecca...
Conclusione:
L'help non è tecnicamente preciso....
con un minimo di prove si ha una soluzione se a tutti i costi si vuole
fare un inefficente decremento in un for su un tipo Byte
che tipizzando il più possibile e lasciando il meno possibile il
default (regola IMHO valida per qualsiasi linguaggio...a parte essere
guru e programmare in c e sfruttare il casting implicito per arditi
spippolamenti) si ha meno casini...al costo minimo di una maggiore
ginnastica delle dita!
Che Vb non fa schifo...fa onestamente quello per cui è stato
fatto...un ambiente RAD per lo sviluppo di gestionali all-purpose...per
altre cose...mi guardo intorno!
e adesso Io l'abbozzo qui....altrimenti non si finisce più!
:o)


-- 
Don't compare floating point numbers solely for equality.


 etc. etc.
zac
...perfetto....grazie della spiegazione...molto interessante tutto il
3ad!
Saluti
:o)

 su queste cose del VB sia lacunosa.
Una precisazione, anche se l'ho già detti in altro post: non è
l'implementazione del VB ad essere lacunosa: il linguaggio
basic funziona così da sempre. E' l'help ad essere fuorviante.
Bye, G. 

 basic funziona così da sempre. E' l'help ad essere fuorviante.
Che funzioni così da sempre non significa perfezione no?
Per esempio, puoi fare:
Dim x as byte
for x=1 to 2 step .01
next x
e non esci più dal ciclo... Perchè? Perchè lo step viene convertito 
in byte e diventa 0...
Beh, preferirei mi avvisasse in compilazione, non in esecuzione.
-- 
Dreams are free, but you get soaked on the connect time.


 end;
Che in VB equivale a:
Dim X As Byte
X = 12
Do While X > 0
    X = X - 4
Loop
e che FUNZIONA in VB.
La questione e' semplice ed Albe l'ha gia' sintetizzata perfettamente. Ma visto che tutti stanno 
puntualizzando... piatto ricco, mi ci ficco 8)
In VB quando si valuta un'espressione si convertono tutti gli operandi nel tipo dell'operando piu' 
"grande" dell'espressione.
Questo e' un dato di fatto.
Infatti se X e' Long e scriviamo:
X = 32000 + 32000
scatta un bell'overflow, perche' VB usa Integer come tipo (il tipo piu' piccolo necessario a 
contenere l'operando piu' grande), e cerca di memorizzare all'interno di un Integer il valore.
Se tipizziamo uno degli operandi con:
X = 65000& + 65000
l'overflow non scatta piu', perche' l'operando piu' grande (e ne basta uno) e' Long.
Veniamo al ciclo For.
For X = 8 To 1 Step -1
Next X
Il meccanismo, sebben mal documentato, e' cosi' da sempre, come sottolinea Paperino.
Nel ciclo For se la variabile e' di un tipo, tutti i valori vengono convertiti in quel tipo (incluso 
lo step) PRIMA di avviare il ciclo. Se lo step non puo' essere contenuto nella variabile, parte un 
overflow (prima ancora che inizi il ciclo).
Nella fattispecie equivale a scrivere:
Dim X As Byte
For X = CByte(8) To CByte(1) Step CByte(-1)
Next X
Da notare come anche in un ciclo:
Dim X As Integer
For X = 1 To 1000000 Step 100000
Next X
l'overflow scatti, non alla seconda iterazione, ma alla prima, in virtu' di quanto suddetto (tutti i 
valori sono convertiti immediatamente nel tipo Integer).
Poiche' questo e' un comportamento _noto_ e _comprensibile_, cascare dalle nuvole indica il non 
avere alcuna familiarita' con l'argomento ed e' quindi indice di una bassa preparazione su nozioni 
di carattere, invece, fondamentale. Da qui l'exploit di Alberto che (per chi segue il newsgroup da 
tempo) sa essere invece molto ferrato in materia e lasco di spiegazioni con la pletora di 
neoprogrammatori VB privi-o-quasi di basi.
Che VB, infine, non "avvisi" come probabilmente dovrebbe (dato che lo fanno tanti altri bei 
compilatori) e' il pegno da pagare per un linguaggio piu' "amichevole" e "versatile", in particolar 
modo permette all'utente meno smaliziato di usufruire delle conversioni implicite, dalle quali 
invece bisognerebbe ben guardarsi, a meno di sapere ESATTAMENTE quello che si sta facendo e che 
NESSUN ALTRO COMPILATORE consente con la stessa "agilita'".
Just My 2 Eurocent,
Lokar

 neoprogrammatori VB privi-o-quasi di basi.
....a me invece non mi cita mai nessuno....uffa!
Sono come il fante in prima linea eh!...vai avanti tu che poi passiamo
noi!
Uffa! :o)
LOL

 next x
...che fai si ricomincia?????
NON ESISTE il compilatore perfetto!
Ognuno ha le sue idiosincrasie...e se spulci tra i meandri delle rete
trovi tanti pezzetti di codice che mettono più o meno in crisi...tutti
i compilatori esistenti!
La tua/mia perizia tecnica come ha detto benissimo lokar....è sapere
quello che fa "il coso" che abbiamo installato nel nostro hard
disk....tutto il resto son chiacchere fatto per sfizio cerebrale
(accettabilissime per carità)!
es.(posto solo quelli vecchi....e risolti con qualche SP o workaround)
C
http://www.pierotofy.it/pages/appunti/Sicurezza_e_OS/Format_String_Bug/
Delphi.....pur non conoscendolo...ho trovato una pagina UFFICIALE
http://qc.borland.com/wc/qcmain.aspx?d=28022
e fra questi ad esempio:
http://qc.borland.com/wc/qcmain.aspx?d=28022
etc etc

 Beh, preferirei mi avvisasse in compilazione, non in esecuzione.
Di cosa ti dovrebbe avvisare ? Che tipo di avviso ti aspetti ?
E' un errore nella semantica di un programma, cos'altro dovrebbe
o potrebbe fare ?
Non penso che potrebbe dirti: "guarda che forse stai facendo una
cazzata, almeno secondo me".
Bye, G. 

 Di cosa ti dovrebbe avvisare ? Che tipo di avviso ti aspetti ?
mai sentito parlare dei warnings?
-- 
One if by LAN, two if by C.  - Paul Revere, as told by John Karwoski


 mai sentito parlare dei warnings?
Sě. Ma la tua non č una risposta, quindi riciclo la domanda:
"Che tipo di warning ti aspetti ? Che testo ci vorresti scritto ?"
Bye, G. 

 "Che tipo di warning ti aspetti ? Che testo ci vorresti scritto ?"
"Lo step del ciclo č di un tipo diverso dalla variabile contatore e 
potrebbe dare luogo ad effetti imprevisti."
-- 
The number of UNIX installations has grown to 10, with more expected.  (6/72)


 potrebbe dare luogo ad effetti imprevisti."
...si prega di spegnere(o spengere per lo slang toscano) la macchinetta
del caffè, allacciare le cinture di sicurezza e non fumare.
<blink>Fasten seat belt</blink> 
ma rotfl!

 ma rotfl!
Lo sai vero dove abbonda il riso?
-- 
IBM: Interesting But Mundane


 Lo sai vero dove abbonda il riso?
In Cina :-)
Bye, G. 

 potrebbe dare luogo ad effetti imprevisti."
Se uno è un programmatore coglione e usa delle variabili
a cazzo di cane, perché mai dovrebbe esser il compilatore
a dirglielo ?
Voglio dire, da un'altro linguaggio potrei anche aspettarmelo e/o
perfino pretenderlo, ma il VB è un BASIC, e fra le sue caratteristiche
c'è proprio il fatto di tentare [quanto questo sia un bene o un male
è un altro discorso] di semplificarti la vita fecendo* delle conversioni
automatiche. Se non ti stanno bene, o non te ne fidi (come faccio
io) fai dei casting espliciti, che è quello che diceva Albe V°.
Ma, e di qui non si scappa, _devi_ usare dei tipi corretti per le cose
che vuoi fare.
E se tu deliberatamente mischi lamponi e salmone affumicato
e ti aspetti che il frullatore ti avvisi che probabilmente farà schifo,
non ti passa più.
* Sì ;-)
Bye, G. 

 non ti passa più.
Ma noi non stiamo parlando di questo caso. Il ciclo for viene 
spiegato come una somma dello step al contatore, cosa che poi in 
realtà non è vera. A questo punto è chiaro che:
1) Il compilatore è stato implementato male
2) Il manuale non spiega correttamente la procedura
In ogni caso NON PUOI dare dello stupido al programmatore ma semmai a
chi ha realizzato il compilatore. Perchè mi aspetto che una variabile
byte - 1 dia luogo ad un risultato corretto (fintantochè non diventa 
negativa).
-- 
RAM DISK is not an installation procedure!


Cribbio, al 23esimo livello di repost siamo. dovrò ridurre la proprietà 
Indentation di thunderbird!
Daniele

 negativa).
Poichè come detto lo step è una somma e il tipo più piccolo che usa
lo step NON E' byte ma integer...
DI FATTO (come anche ti han fatto vedere tramite disassembler)
cerchi di mettere un Integer DENTRO un byte.....
e GIUSTAMENTE segnala overflow.
Ora a te non sta bene così...mi dispiace!
Ma è SEMPRE stato così....
chi programma in VB lo sa!
Certo chi si avvicina da altri linguaggi potrebbe non saperlo!
Però....
siccome non è bello sputare dove si mangia...ne tantomeno in casa di
altri...
prima di affermare che VB fa schifo....
mi permetterei di farti notare che nessuno di noi ha mai detto che tu
sei una chiavica di programmatore!
Prima di affermare che quello che tutto noi usiamo normalmente fa
schifo è illogico etc etc...di fatto dando a tutti noi di...che cosa?
Imbecilli perchè usiamo una cosa sbagliata?
Lameroni perchè non si fidano dei cast impliciti?
Prima di affermare tutto ciò...stai manzo!
Vacci piano!
Un po di umiltà.....servirebbe.....
Come consiglio!...poi fa te!
So benissimo che vorrai replicare ad iosa sostendo che stiamo
sbagliando tutti e tu hai ed avrai sempre ragione.....
quindi mi cheto!
Ciao!
Peace! Yo!


 come uscirne senza darci ragione?
Avrei potuto benissimo mandare te  e l'altro a quel paese al secondo 
messaggio in effetti. E mi dolgo ora di aver continuato.
-- 
Stack Overflow:  Too many pancakes...


 next x
E siccome byte è (e deve rimanere, ovviamente) un intero, 1.1
viene per forza arrotondato a 1.
Stai facendo [variabile byte] + [variabile con tipo di default per numeri
con decimali, quindi double, contenente 0.1].
(Se non ci credi prova un "Debug.Print TypeName(0.1)" e vedrai
che stamperà "Double").
Il primo operando, byte, viene convertito in double, poi gli viene
sommato 0.1, ed ecco il tuo 1.1... ma poi deve venir riconvertito
in byte, perché il risultato deve essere assegnato ad x che è un
byte, quindi numericamente un intero, e quindi arrotondato a 1.
Se non è chiaro così, dimmelo che ti faccio un disegnino (cit.).
Bye, G. 

 Se non è chiaro così, dimmelo che ti faccio un disegnino (cit.).
trovo fuori luogo questa tua ironia visto che hai dimostrato di non 
sapere proprio un accidente di quanto si sta discutendo.
-- 
Computers are unreliable, but humans are even more unreliable.  - Gilb


 sapere proprio un accidente di quanto si sta discutendo.
Va bene buana, io adesso barlare gosě e sberare ghe du gapire.
Noi sdare disgudendo di variabili giusde per uso giusdo.
Du non bodere misghiare variabili a gagghio e sberare ghe loro
gabire da sole gosa dovere fare.
Du non bodere meddere -1 in un Byde, e non bodere fare galgoli
gon Byde e valori negadivi.
Bye, G. 

 qui Integer e Byte a cacchio, usando valori negativi.
In VB 2005 con Option Strict On non si compila neppure (Option Strict On 
disallows implicit conversions from 'Integer' to 'Byte')
-- 
news://it-alt.comp.software.openoffice : Il newsgroup dedicato a
OpenOffice.org, la suite open source di applicazioni per ufficio.
Saluti, VITRIOL

 disallows implicit conversions from 'Integer' to 'Byte')
Oho! Finalmente...
Quindi non sono io il PIRLA quando chiedevo che il compilatore mi 
avvisasse! Ora ci sono arrivati anche in MS...
Adesso che l'ha fatto la MS, immagino, andrà bene per tutti... ;-)
-- 
The program is absolutely right; therefore the computer must be wrong.


 gon Byde e valori negadivi.
Du non gabire gazzo. Du dire che non bodere fare galgoli gon byde e 
valori negadivi ma du dire gazzate (e guindi sosbeddo ghe du mai 
usado visual basig) berghè questo funziona:
dim x as byte
dim y as byte
y = x + (-1)
oppure
y= x -1
-- 
There are never any bugs you haven't found yet.


 y= x -1
O usi un VB diverso dal mio, oppure mi stai prendendo per il culo.
Qui da me va in overflow su entrambe le operazioni. :-)
(Orientativamente, hai commesso lo stesso errore mio di due post
fa: ti sei fidato della tua logica, invece di usare la logica di VB)
Indovina perché ? Perché secondo la tua logica, e non avendo
assegnato un valore >0 ad X, il risultato dovrebbe essere negativo,
ma un valore negativo in un Byte non ci può stare, e... BUM !
Questo è un *tipico*, *perfetto* esempio del perché mischiare tipi
diversi, e non adeguati, nelle operazioni matematiche, fidandosi
del casting di VB, è sbagliato.
O perlomeno va fatto con estrema attenzione e sapendo perché
e percome possono capitare degli errori.
Bye, G. 

Paperino ha scritto:
abbi pazienza Paperino....
gli avevo già risposto...
anzi...
il primo Albe...poi Io ...poi Rafunk...e poi tu
Rafunk addirittura se leggi ha disassemblato l'exe...e a dimostrato
come sia un errore di pere mischiato a bulloni
Di come si voglia ficcare un integer (quanto meno) in un byte
Di come il signor 2diPicche...faccia un errore
concettuale...trasportando la sua esperienza di un mondo Delphi in un
mondo VB
e di come abbia scambiato un
for n=10 to 1 step -1
in un loop di decrementi di un contatore
Gli abbiamo dimostrato che non è una serie di cont-- (non esistendo
nemmeno in VB6 var++ e var--)...ma una vera e propria somma ad una
variabile di un altra variabile e di come QUINDI la somma tra 2 var
debba esser fatta con opportune cautele se ci si affida al cast
implicito...e di come si debba sapere come si comporta il compilatore
in situazioni del genere!...e di come questa conoscenza sia a cura mia!
Ciò nonostante continua imperterrito nella sua strada....
e quindi la discussione è soltanto sterile ed ha esaurito tutto quello
che tecnicamente doveva dire!
A questo punto continuare è soltanto per pura voglia di flammare e
trollare in libertà!
P.s.
VB2005 usa un altro compilatore...ed è un altro tipo di prodotto...
si chiama compilatore ma quello che produce non è codice macchina!
Comunque anche qui...non si possono mischiare pere e bulloni!
Quello che fa VB6 è diverso da quello che fa VB2005!

Ora dimmi in quale punto ti si inchioda.
Dunque il for non si comporta COME una operazione di somma / 
sottrazione che normalmente opera il VB. E proprio su questo si 
discute. Il problema è concettuale. Il VB abitua a mischiare i tipi 
nelle operazioni senza preoccuparsi troppo (ovvio, basta sapere quel 
che si fa) ma sul for t'inchiap..tta anche se l'operazione di 
sottrarre una unità da un byte sarebbe lecita.
Dunque abbiamo risolto che:
Quando io ho scritto che sarebbe meglio avere un warning sono stato 
preso per i fondelli, salvo poi scoprire che in .net finalmente MS ha
deciso di *operare* in tal senso...
Siccome non uso .net non sapevo di questa nuova feature che però cade
a fagiolo...
-- 
Design: The activity of preparing for a design review.


 Quello che fa VB6 =E8 diverso da quello che fa VB2005!
Tu vai pure avanti ad accettare i dogmi imposti dall'alto subendoli. 
Se fosse per la gente come te non ci sarebbe mai una versione 
*successiva* di qualsiasi prodotto. La riprova è nel citato vb2005...
Se ne sono accorti finalmente.
Come ho già detto fin dall'inizio del thread la cosa era di semplice 
soluzione, bastava rispondermi:
"In effetti il VB trae in inganno, anche a causa della documentazione
lacunosa, sulla conversione dei tipi del ciclo for, d'altronde è 
stato implementato in questo modo e non c'è molto da fare per 
ovviare"
Invece è stato per te e per altri meglio gridare "Asinaccio!" eh?
-- 
Terminal glare:  A look that kills...


 io) fai dei casting espliciti, che è quello che diceva Albe V°.
************************
A questo punto, visto che mi pare si sia d'accordo tutti
che non c'è molto altro da dire direi di chiuderla qui.
Bye, G. 

 [STOP, GNAAFACCIO]
No, non ce la facci piů IO... Mi avete smarronato i cog...
Il thread finisce, andatevela a pigliare dove piů vi piace. Ognuno 
per sč e dio per tutti.
-- 
Revolutionary: The disk drives go round and round.


 per sè e dio per tutti.
MA VAFFANCULO TE E LA TRO(T)A DI TO MA!
AAAAAAHHHHHHHHHHHHHHHHH
.....ho sgravato....
quando ce! vò ce vò!

 MA VAFFANCULO TE E LA TRO(T)A DI TO MA!
Questo è sufficiente a catalogarti, piccolo mentecatto.
-- 
"Politics is a pendulum whose swings between anarchy and tyranny are fueled by perpetually rejuvenated illusions." -- Einstein 
