Differenze tra le versioni di "Ottenere dai suoi singoli dati-byte un valore numerico di tipo superiore al Byte"
Da Gambas-it.org - Wikipedia.
(Creata pagina con "Volendo estrarre un valore di dimensioni superiori al tipo ''Byte'', memorizzato in un flusso di dati o in un'area di memoria riservata o in un vettore di tipo Byte[], si potr...") |
|||
| Riga 1: | Riga 1: | ||
| − | Volendo estrarre un valore di dimensioni superiori al tipo ''Byte'', memorizzato in un flusso di dati | + | Volendo estrarre un valore di dimensioni superiori al tipo ''Byte'', memorizzato in un flusso di dati oppure in un'area di memoria riservata oppure in un vettore di tipo Byte[], si potrà procedere come appresso indicato. |
==Se il valore può essere rappresentato da un ''Integer''== | ==Se il valore può essere rappresentato da un ''Integer''== | ||
| Riga 5: | Riga 5: | ||
==1<SUP>a</sup> modalità== | ==1<SUP>a</sup> modalità== | ||
| − | + | Public Sub Main() | |
Dim bb As Byte[] = [&33, &22, &11, &00] | Dim bb As Byte[] = [&33, &22, &11, &00] | ||
| Riga 15: | Riga 15: | ||
Print i | Print i | ||
| − | + | End | |
e similmente con gli altri tipi di dati superiori al Byte. | e similmente con gli altri tipi di dati superiori al Byte. | ||
| − | |||
==2<SUP>a</sup> modalità== | ==2<SUP>a</sup> modalità== | ||
| − | + | Public Sub Main() | |
Dim i As Integer | Dim i As Integer | ||
| Riga 43: | Riga 42: | ||
Print i | Print i | ||
| − | + | End | |
| Riga 50: | Riga 49: | ||
Ad esempio si deve estrarre un valore memorizzato da 4 byte &FF &FF &FF &FF in ''Little-Endian'': | Ad esempio si deve estrarre un valore memorizzato da 4 byte &FF &FF &FF &FF in ''Little-Endian'': | ||
| − | + | Public Sub Main() | |
Dim bb As Byte[] = [&FF, &FF, &FF, &FF] | Dim bb As Byte[] = [&FF, &FF, &FF, &FF] | ||
| Riga 62: | Riga 61: | ||
Print l, Hex(l, 8) | Print l, Hex(l, 8) | ||
| − | + | End | |
Se invece il valore è memorizzato in ''Big-Endian'': | Se invece il valore è memorizzato in ''Big-Endian'': | ||
| − | + | Public Sub Main() | |
Dim bb As Byte[] = [&FF, &FF, &FF, &FF] | Dim bb As Byte[] = [&FF, &FF, &FF, &FF] | ||
| Riga 77: | Riga 76: | ||
Print l, Hex(l, 8) | Print l, Hex(l, 8) | ||
| − | + | End | |
| − | |||
| Riga 85: | Riga 83: | ||
Se il valore, rappresentabile solo con il tipo di dati ''Long'', è memorizzato in ''Little-Endian'': | Se il valore, rappresentabile solo con il tipo di dati ''Long'', è memorizzato in ''Little-Endian'': | ||
| − | + | Public Sub Main() | |
Dim l As Long | Dim l As Long | ||
| Riga 103: | Riga 101: | ||
Print l, Hex(l, 8) | Print l, Hex(l, 8) | ||
| − | + | End | |
Se il valore, rappresentabile solo con il tipo di dati ''Long'', è memorizzato in ''Big-Endian'': | Se il valore, rappresentabile solo con il tipo di dati ''Long'', è memorizzato in ''Big-Endian'': | ||
| − | + | Public Sub Main() | |
Dim l As Long | Dim l As Long | ||
| Riga 124: | Riga 122: | ||
Print l, Hex(l, 8) | Print l, Hex(l, 8) | ||
| − | + | End | |
Versione attuale delle 15:05, 4 apr 2024
Volendo estrarre un valore di dimensioni superiori al tipo Byte, memorizzato in un flusso di dati oppure in un'area di memoria riservata oppure in un vettore di tipo Byte[], si potrà procedere come appresso indicato.
Indice
Se il valore può essere rappresentato da un Integer
Poniamo il caso che il valore da estrapolare sia il seguente Integer: 1122867.
1a modalità
Public Sub Main() Dim bb As Byte[] = [&33, &22, &11, &00] Dim i As Integer ' Dereferenziamo il "Puntatore" restituito dalla proprietà .Data del vettore: i = Int@(bb.Data) Print i End
e similmente con gli altri tipi di dati superiori al Byte.
2a modalità
Public Sub Main() Dim i As Integer ' Se i byte, che nel file rappresentano quel numero, sono disposti secondo l'ordine "Little-Endian", allora: Dim bb As Byte[] = [&33, &22, &11, &00] i = CInt(bb[3]) * 16777216 ' &01000000 i += bb[2] * 65536 ' &010000 i += bb[1] * 256 ' &0100 i += bb[0] ' Se, invece, l'ordine dei byte è "Big-Endian", allora la sequenza degli indici dei singoli elementi del vettore sarà invertita: ' Dim bb As Byte[] = [&00, &11, &22, &33] ' i = CInt(bb[0]) * 16777216 ' i += bb[1] * 65536 ' i += bb[2] * 256 ' i += bb[3] Print i End
Se il valore può essere rappresentato solo da un Long
Se la grandezza del valore può essere rappresentata solo da un Long, allora si potrà procedere come segue.
Ad esempio si deve estrarre un valore memorizzato da 4 byte &FF &FF &FF &FF in Little-Endian:
Public Sub Main() Dim bb As Byte[] = [&FF, &FF, &FF, &FF] Dim l As Long l = CLong(bb[3]) * 16777216 ' &01000000 l += bb[2] * 65536 ' &010000 l += bb[1] * 256 ' &0100 l += bb[0] Print l, Hex(l, 8) End
Se invece il valore è memorizzato in Big-Endian:
Public Sub Main() Dim bb As Byte[] = [&FF, &FF, &FF, &FF] Dim l As Long l = CLong(bb[0]) * 16777216 ' &01000000 l += bb[1] * 65536 ' &010000 l += bb[2] * 256 ' &0100 l += bb[3] Print l, Hex(l, 8) End
3a modalità
Si potrà anche effettuare uno spostamento a sinistra dei bit di ciascun byte-valore letto a partire dal secondo.
Se il valore, rappresentabile solo con il tipo di dati Long, è memorizzato in Little-Endian:
Public Sub Main() Dim l As Long Dim bb As Byte[] = [&33, &22, &11, &FF] ' 4279312947 l = CLong(bb[0]) l += CLong(Shl(CInt(bb[1]), 8)) l += CLong(Shl(CInt(bb[2]), 16)) l += CLong(Shl(CLong(bb[3]), 24)) ' Altresì utilizzando l'operatore OR: ' l = CLong(bb[0]) ' l = l Or CLong(Shl(CInt(bb[1]), 8)) ' l = l Or CLong(Shl(CInt(bb[2]), 16)) ' l = l Or CLong(Shl(CLong(bb[3]), 24)) Print l, Hex(l, 8) End
Se il valore, rappresentabile solo con il tipo di dati Long, è memorizzato in Big-Endian:
Public Sub Main() Dim l As Long Dim bb As Byte[] = [&FF, &11, &22, &33] ' 4279312947 l = CLong(Shl(CLong(bb[0]), 24)) l += CLong(Shl(CInt(bb[1]), 16)) l += CLong(Shl(CInt(bb[2]), 8)) l += CLong(bb[3]) ' Altresì utilizzando l'operatore OR: ' l = CLong(Shl(CLong(bb[0]), 24)) ' l = l Or CLong(Shl(CInt(bb[1]), 16)) ' l = l Or CLong(Shl(CInt(bb[2]), 8)) ' l = l Or CLong(bb[3]) Print l, Hex(l, 8) End
