Riguardo la conversione little endian e big endian

La memoria interna del formato intero nativo è un aspetto della rappresentazione binaria interna dei numeri su vari processori (il complemento a due contro il complemento a uno è un altro). La posizione dei byte più significativi rispetto a quelli meno significativi è un aspetto importante dell'archiviazione e del trasporto dei dati. Ad esempio, l'ordine dei byte è un problema quando si trasferiscono dati tra due sistemi utilizzando un formato dati binario (esempi: XDR, Xupl, UBJson, ecc.)

Possiamo esaminare parole a 32 bit (b32) e 16 bit (b16) su una macchina. Sono memorizzati in quattro byte ( byte[4] ) o due byte ( byte[2] ) e possono essere esaminati come una matrice di byte. Considerare la disposizione dei byte in una parola a 32 bit (byte [4]). Contrassegna i byte A, B, C, D e ci sono% permessi possibili per% co_de,

ABCD ABDC ACBD ACDB ADBC ADCB 
BACD BADC BCAD BCDA BDAC BDCA 
CABD CADB CBAD CBDA CDAB CDBA 
DABC DACB DBAC DBCA DCAB DCBA 

Due di queste permutazioni, ABCD e DCBA, sono spesso usate sui processori e chiamiamo questi ordini "endianità" del processore. Ciò vuol dire che l'ordine dei byte definisce la endianità del processore. Supponiamo che l'etichetta A sia la più significativa e che D sia la meno significativa, quindi questi due formati hanno nomi speciali,

• Big-endian: ABCD, la significanza del byte diminuisce all'aumentare dell'indirizzo di memoria
• Little-endian: DCBA, la significatività dei byte aumenta all'aumentare dell'indirizzo di memoria

Il caso a 16 bit è molto più semplice, solo due permutazioni, AB e BA.

Sono utilizzati altri formati; il pdp-11 aveva un layout middle-endian, BADC.

Ci sono molti processori (ARM, PowerPC, Sparc9 +, Alpha, Mips, Pa-Risc, IA-64) che possono passare tra big-endian e little-endian.

Questo è un breve programma in C che ti dirà il endianness del tuo processore,

#include <stdio.h>
#include <string.h>
typedef unsigned long ulong;
typedef unsigned char uchar;
int
main(int argc, char *argv[])
{
    uchar word[4] = {(uchar)0x01,(uchar)0x23,(uchar)0x45,(uchar)0x67};
    ulong be = 0x01234567;
    ulong le = 0x67452301;
    ulong me = 0x23016745;
    ulong we; ulong ue;
    memcpy(&we,word,4);
    if( we == be ) printf("Big-endian\n");
    if( we == le ) printf("Little-endian\n");
    if( we == me ) printf("Middle-endian\n");

    char UNIX[4+1]="UNIX";
    ue  = ((ulong)'U'); ue<<=8;
    ue += ((ulong)'N'); ue<<=8;
    ue += ((ulong)'I'); ue<<=8;
    ue += ((ulong)'X');
    printf("%s = %.4s\n",UNIX,(char*)&ue);

    int ndx;
    uchar *p = word;
    printf("@%x:\n", p );
    for( ndx=0; ndx<sizeof(we); ndx++ )
    {
        printf("[%02x] %03d:%02x\n", ndx, p[ndx], p[ndx] );
    }

}

La risposta è: dipende .

Se stai condividendo dati con un'altra piattaforma, o (de) serializzando alcuni formati binari con endianness definito, allora devi abbinare l'endianità di quella piattaforma o formato.

Supponendo che il target endianness sia ben definito (e diverso dal tuo endianness nativo), questo ti dirà di quali conversioni ti servono.

Oh, e suggerirei di utilizzare htons , htonl e amici anziché ruotare manualmente i byte: è più probabile che vengano ottimizzati per una singola istruzione BSWAP o simile.

la conversione stessa di solito è una soluzione per twiddler di fantasia come: (per un intero a 32 bit)

i = ((i&0xff000000) >>> 24) | ((i&0x00ff0000) >> 8) | ((i&0x0000ff00) << 8) | ((i&0x000000ff) <<24)

perché è necessario che alcune architetture siano big endian e alcune siano little endian e se vogliono comunicare attraverso un flusso di byte devono essere d'accordo su endianness sul flusso di byte in modo che un 1 non diventi un 16,777,216 ( 2^24 )

la conversione viene utilizzata solo per le primitive che superano 1 byte; gli altri tipi (compositi) sono generalmente definiti come una sequenza di altri tipi compositi e / o primitivi che rimarranno in ordine

ad esempio il formato di file LAS è definito in little endian. questo significa che i primi byte di intestazione in ordine sono:

1. primo carattere della firma, ( L )
2. secondo carattere della firma, ( A )
3. terzo carattere della firma, ( S )
4. quarto carattere della firma, ( F )
5. basso byte dell'ID sorgente del file,
6. byte elevato dell'ID sorgente del file,
7. basso byte della codifica globale,
8. byte elevato di codifica globale,

e così via