[VB6] Overflow di un valore intero

[stefano3]

buon natale.

ho questo problema:
devo lavorare con numeri che occupano più di 4 byte (1 long) anche se mi interessano solo i 4 meno significativi.
mi spiego:
2222222222 -> hex 84746b8e (4 byte ok)
2222222222 * 2 = 4444444444 -> hex 108e8d71c (+ di 4 byte ko)
a me interessa del secondo valore solo 08e8d71c.

in c (decisamente migliore) posso decidere di non gestire l'overflow e quindi di perdere i bit più significativi e ottengo il risultato che mi aspetto (nella variabile non trovo l'1 a sinistra)

qualcuno conosce un modo per ottenere la stessa cosa in vb6?

grazie

[Luke(BI)]

hai provato usando stringhe?

[oregon]

Non ti sei spiegato bene.

A te interessano le ultime cifre del numero convertito in esadecimale?

[stefano3]

esatto. mi interessano le più a destra

[oregon]

Per capire che tipo di codice suggerirti, puoi fare un esempio di quello che ti serve magari nel contesto del tipo di programma che stai realizzando ...

Cioe', tu hai *sempre* un valore long su cui effettuare dei calcoli che vadano oltre i 32 bit con segno ... ma se ti interessano solamente le ultime due cifre esadecimali (ovvero l'ultimo byte), prima dell'operazione, azzera i byte precedenti.

[stefano3]

mi spiego:
codice c:

int i;
unsigned long code;

code = 1234567890;
for( i = 0; i < 8; i ++ )
{
unsigned long t;

t = ( code & 0x00F00000 ) >> 28;
code *= 0x00000011;
code |= t;
}

return (code);

quando in visual basic faccio
code = code * &H11
va in overflow e se faccio
code = code AND &H0fffffff
cioè metto a zero il nible più significativo prima di
code = code * &H11
non ottengo lo stesso risultato

[oregon]

Ok .. ma mi avevi detto che ti interessava solamente l'ultimo byte dei risultati intermedi. Dato che i valori sono

499602D2
E2F62FF2
12592F12
37EC2032
B6AE2352
21905872
3A95DF92
E3F3D8B2
233163D2

a te interessa sempre e solo D2, F2, 12 ... giusto?

P.S. Nel codice che hai mostrato la linea

t = ( code & 0x00F00000 ) >> 28;

non fa altro che azzerare t in ogni caso e quindi la

code |= t;

e' completamente inutile ...

Probabilmente dovrai rivedere queste linee ...

[pprllo]

Originariamente inviato da stefano3
mi spiego:
codice c:

int i;
unsigned long code;

code = 1234567890;
for( i = 0; i < 8; i ++ )
{
unsigned long t;

t = ( code & 0x00F00000 ) >> 28;
code *= 0x00000011;
code |= t;
}

return (code);

quando in visual basic faccio
code = code * &H11
va in overflow e se faccio
code = code AND &H0fffffff
cioè metto a zero il nible più significativo prima di
code = code * &H11
non ottengo lo stesso risultato

Scusa l'ignoranza, ma &H11 non vale 17 ? Perchè sopra avevi fatto l'esempio con 2, che era fattibile. Invece col 17 non saprei come fare. Comunque, con 2:
a = Risultato che ti interessa
b = 16^9
x = Numero di partenza

a = x*2-b //Il numero moltiplicato 2 - 100000000
a/2 = x - b/2
a = (x-b/2)*2

Da cui, nel caso del 2:
a = (x-80000000)*2

Tuttavia questo funziona solo se il numero per cui moltiplichi è divisore di 100000000, cosa che non accade moltiplichi per 17.

P.S.: Sicuramente ci altre soluzioni, ma al volo questo mi è venuto in mente

[stefano3]

hai ragione, avrei potuto essere più chiaro dall'inizio. soprattutto facendo l'esempio con il due (che corrisponde a uno shift) vi ho mandati fuori strada.
alla fine ho risolto con una dll appoggiandomi a un file.
grazie comunque

[stefano3]

per oregon:
ho sbagliato a scrivere
non t = ( code & 0x00F00000 ) >> 28
ma t = ( code & 0xF0000000 ) >> 28
e poi mi interessano i quattro byte meno significativi.
comunque grazie