Newsgroup: it.comp.lang.visual-basic
Titolo: passare un Decimal ad un Int64

Ciao a tutti ancora una volta :-)
Per un progettino,devo includere una dll che, tra le altre cose, per una
particolare funzione, si aspetta un Int64.
Ora, considerato che in VB6 non posso mandare niente di simile, e visto
che l'unica variabile che riesce a contenere un numero cosi' grande e' il
decimal, cosa succederebbe se "spedissi" alla DLL il mio numerino in
Decimal?
Lo so cosa state pensando....: e perche' non provi?
Perche' prima di poter mandare quel numerino, devo capire come costruirlo,
e studiarci un po' su... poi magari e' una cosa che concettualmente non
sta in piedi, ed ecco che molte delle mie *preziosissime* (sigh) energie,
sono state *sprecate* :-) :-)
Ciao ciao... Maurizio  
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 sono state *sprecate* :-) :-)
E io ti *imparo* un trucco :)
Metti che hai una Declare tipo Pippo(ByVal x As Long), tu puoi imbrogliare 
facendo Pippo(ByVal x As integer, byval y as integer).
Quindi con un Pippo(ByVal x As Int64) puoi fare Pippo(ByVal x As Long, ByVal 
y As Long).
Il currency è lo stesso, l'importante è che il numero di byte passati sia 
coerente.
Il currency è di 8 byte (o ricordo male?) quindi puoi dichiarare Pippo(ByVal 
x As Decimal), ricordandoti che un currency è un intero scalare, cioè un 
intero a cui piantano la virgola al 4° decimale, quindi devi passare x / 
10000.
Con il decimal non saprei... non esiste la dichiarazione per VB6 (Decimal è 
proprio un Int64)... potresti provare con un Pippo(ByVal x As Any) ma 
secondo me scoppia tutto... magari facendo Pippo(ByRef x As Long) e 
passandogli l'indirizzo del dato contenuto nel Variant, ma qui inizi con gli 
esperimenti.
Ciao 

sono state *sprecate* :-) :-)
Per passare un 64bit alla QueryPerformanceCounter o QueryPerformanceFrequency si
usa un Large integer che assomiglia molto ad un INT64.
'Il numero è rappresentato come HighPart*2^32 + LowPart.
Private Type LARGE_INTEGER
    LowPart As Long
    HighPart As Long
End Type
Vedi se ti può servire.
--
ciao
  Stefano

Vedi se ti può servire.
Qui trovi tutto il sorgente:
http://www.vbaccelerator.com/home/VB/Code/Libraries/HiResTimer/VB6_HiResTimer_Full_Source_Code.asp
--
ciao
  Stefano

 usa un Large integer che assomiglia molto ad un INT64.
...
Si, questo lo avevo preso in considerazione, e tra l'altro tieni presente
che nella dll che dovrei utilizzare, c'e' una funzione analoga a quella
che sto cercando di capire io, che pero' vuole due Long e poi ci pensa
lui... Tutto fatto dirai, il problema e' che lui vuole un Unsigned Long
(in C mi vuole un DWord), e quindi per numeri molto grandi, sono fregato.
Mannaggia.
Ciao e grazie... Maurizio


 Ciao


 :-)
Infatti il tipo VB6 "intero" (o meglio, con virgola fissa) a 64 bit è il
Currency, non Decimal.
Bye
Raf
-----------------------------------------------------
Funk: cooler than the other side of the pillow.

 Insomma, a me serve o un 64 bit, o due 32 Unsigned... datemeliiiiii :-)
Signed o unsigned è indifferente: il bit c'è, se poi verrà letto come bit di 
segno o bit di dati è irrilevante.
Ciao 

 Mannaggia.
Come ti dicevo di là: fregatene del bit di segno!
64bit sono 64bit.
Ciao 

 segno o bit di dati è irrilevante.
...
Ecco qui! Ieri, metre tornavo a casa, mi sono messo a pensare un po' sulla
faccenda (e girare in moto mentre si pensa a bit, byte e variabili long,
non e' molto salutare).
Riflettevo proprio su questo.
Il numero piu' grande che posso memorizzare su un long e' 2.147.483.647
che, dei 32 bit che ha, il primo e' posto a 0, mentre tutti gli altri a 1.
Diciamo che io debba passare 2.147.483.649, potrei, in VB, passare -1
(cioe' in bit 100.....1), ed aspettarmi che la dll (che vuole un unsigned
long) interpreti corretamente il tutto?
Domandina:
il numero seguente di 2.147.483.647, dovrebbe avere l primo bit a 1, tutti
gli altri a 0.... dal punto di vista vb, questo dovrebbe significare -0 ?
Oppure in microsoft sono stati cosi' paraculi da assegnare a questo stato
di bit il valore -1? 
Con la seconda ipotesi si spiegherebbe perche il limite inferiore del long
non e' -2.147.483.647 ma -2.147.483.648
Quanto sono fuori strada?
Grazie ancora (quando passate per Latina, un caffe' e' pagato ^__^)
In fede... Maurizio


 Quanto sono fuori strada?
la risposta alle tue domande e' 'complemento a due'
ragionando a 16 bit ma il discorso scala perfettamente
2^16  = 65536 2^(16-1)=32768
1) come variabili senza segno hai un range compreso tra: 0 e 65535
2a) per variabili signed hai un range tra -32768 e 32767 ( notare 
l'asimmetria
i valori positivi sono tra 0 e 32767 e sono perfettamente corrispondenti 
agli interi senza segno rappresentabili con 15 bit
2b) i valori negativi sono compresi tra -32768 e -1
e sono rappresentati cosi':
-1     = 1111111111111111
-32768 = 1000000000000000
per 'cambiare di segno' si deve:
complementrare bit a bit e poi aggiungere uno ( con la sola notevole 
eccezione per -32768 che genera un overflow non essendo possibile 
rappresentare a 16 bit signed 32768 ma funziona come risultato unsigned)
2c) per le altre notevoli proprieta' delle rappresentazioni 'in modulo' 
di cui il complemento a due e' una delle possibilita' wikypedia dovrebbe 
essere d'aiuto
nota bene: i numeri interi compresi ( ed includenti ) -32768 e 32768 
sono in totale 65537 !!!


 10000.
...
Ricapitoliamo... la mia DLL si aspetta un unsigned long...
Diciamo che io la dichiaro cosi':
Public Declare Sub Vattelappesca Lib "FaiTu.dll" (byVal Dato as Currency)
Quindi io nella dichiarazione della dll gli dico che come parametro le
daro' un Currency, la mia dll non si oppone perche' non sa cosa sto
scrivendo.
Nel bel mezzo del mio codicillo:
Dim Parametro as Currency
Parametro = 10 ' (cioe' 10.0000 per via delle 4 cifre decimali)
Vattelappesca Parametro
la dll legge il mio parametro (currency) = 10 come un Int64 che vale
100000 ?
