Ordine dei byte

Questa voce o sezione sull'argomento informatica non cita le fonti necessarie o quelle presenti sono insufficienti.

---

Puoi migliorare questa voce aggiungendo citazioni da fonti attendibili secondo le linee guida sull'uso delle fonti. Segui i suggerimenti del progetto di riferimento.

L'ordine dei byte (conosciuto anche come big-endian, little-endian o middle-endian a seconda dei metodi differenti), in informatica, indica modalità differenti usate dai calcolatori per immagazzinare in memoria dati di dimensione superiore al byte (es. word, dword, qword).

La endianness (ordine dei byte) di un computer dipende essenzialmente dall'architettura hardware usata. Ad esempio, Intel e Digital usano il formato little-endian mentre Motorola, IBM e Sun usano il formato big-endian. Il formato dei dati contenuti nelle intestazioni dei protocolli di rete è anch'esso big-endian; altri esempi di uso di questi due diversi formati sono quello del bus PCI, che è little-endian, o quello del bus VME che è big-endian.

I termini big-endian e little-endian derivano dai nomi di due popolazioni che abitavano nelle favolose isole di Lilliput e Blefuscu nel romanzo I viaggi di Gulliver di Jonathan Swift. Queste erano entrate in rivalità per il modo in cui aprivano le uova - rompendo la punta o il fondo: a Lilliput, per editto dell'imperatore il cui figlio una volta si tagliò aprendo un uovo dall'estremità più grande, fu ordinato di aprire le uova dall'estremità più piccola (little endians); a Blefuscu si rifugiarono gli oppositori che volevano conservare la tradizione di rompere le uova dall'estremità più grande (big endians). A causa di questa differenza e della sua legittimazione imperiale era scoppiata tra le due isole una guerra sanguinosa.

Questa differenziazione non riguarda né la posizione dei bit all'interno del byte, nel qual caso si parla di ordine dei bit, né le posizioni dei caratteri in una stringa. Ha invece importanza nell'interpretazione (decodifica) di stringhe multi-byte di caratteri, ad esempio la codifica UTF-16 dello standard unicode.

La differenza tra i due sistemi è data dall'ordine con cui i byte costituenti il dato da immagazzinare vengono memorizzati o trasmessi:

• big-endian: memorizzazione/trasmissione che inizia dal byte più significativo (estremità più grande) per finire col meno significativo, è utilizzata dai processori Motorola;
• little-endian: memorizzazione/trasmissione che inizia dal byte meno significativo (estremità più piccola) per finire col più significativo, è utilizzata dai processori Intel;

Nota bene: il termine endian genera spesso confusione; per ricordare correttamente la differenza si rammenti che endian si riferisce alla estremità da cui il dato originale comincia a essere elaborato (scritto/letto su/da memoria o trasmesso/ricevuto su/da canale di comunicazione), non a quale estremità finisce per ultima in memoria o su canale di comunicazione.

L'ordine big-endian è stato scelto come ordine standard in molti protocolli utilizzati in Internet, viene perciò anche chiamato network byte order. Per contro viene chiamato host byte order l'ordine nativo dell'host

Nel caso di una WORD (16 bit), il numero esadecimale 0x0123 viene immagazzinato come:

      Little-endian             Big-endian        +----+----+              +----+----+        |0x23|0x01|              |0x01|0x23|        +----+----+              +----+----+  byte:    0    1                   0    1  

Nel caso di una DWORD (32 bit), il numero esadecimale 0x01234567 verrà immagazzinato come:

           Little-endian             Big-endian        +----+----+----+----+    +----+----+----+----+        |0x67|0x45|0x23|0x01|    |0x01|0x23|0x45|0x67|        +----+----+----+----+    +----+----+----+----+  byte:    0    1    2    3         0    1    2    3  

(Negli esempi il valore 0x01 è il byte più significativo)

Le seguenti funzioni possono essere usate per convertire da little a big endian e viceversa (la conversione è perfettamente simmetrica).

 unsigned short int Endian_Word_Conversion(unsigned short int word) {     return ((word>>8)&0x00FF) | ((word<<8)&0xFF00)  ;  } 

 unsigned long int Endian_DWord_Conversion(unsigned long int dword) {     return ((dword>>24)&0x000000FF) | ((dword>>8)&0x0000FF00) | ((dword<<8)&0x00FF0000) | ((dword<<24)&0xFF000000);  } 

 public uint Endian_UInt32_Conversion(uint value){     return ((value >> 24) & 0x000000FF) | ((value >> 8) & 0x0000FF00) | ((value << 8) & 0x00FF0000) | ((value << 24) & 0xFF000000);  } 

 public ulong Endian_UInt64_Conversion(ulong value){     return ((value >> 56) & 0x00000000000000FF) | ((value >> 40) & 0x000000000000FF00) | ((value >> 24) & 0x0000000000FF0000) | ((value >> 8) & 0x00000000FF000000) | ((value << 8) & 0x000000FF00000000)   | ((value << 24) & 0x0000FF00000000) | ((value << 40) & 0x00FF0000000000) | ((value << 56) & 0xFF000000000000);  } 

Da C++23 è disponibile std::byteswap.

I termini vengono alle volte usati^{[senza fonte]} anche per indicare il formato di data:

• gg/mm/aaaa: la data europea è little-endian
• aaaa/mm/gg: la data big-endian è usata in Giappone e in ISO 8601
• mm/gg/aaaa: la data usata in U.S.A. è middle-endian

• Bit
• Byte
• Byte Order Mark

• Wikimedia Commons contiene immagini o altri file sull'ordine dei byte

Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica