Lettura di byte di dimensioni "integer" da un array char *.

Question

Desidero leggere i byte sizeof(int) da un array char*.

a) In quale scenario è necessario preoccuparsi se è necessario verificare l'endianità?

b) Come leggeresti i primi 4 byte prendendo in considerazione o meno endianness.

MODIFICA: I byte che ho letto devono essere confrontati con un valore intero.

Qual è l'approccio migliore per andare su questo problema

Answer 1

Non dovrebbe essere necessario preoccuparsi di endianess a meno che non si sta leggendo il byte da una fonte creato su una macchina diversa, per esempio un flusso di rete.

Dato che, non puoi semplicemente usare un ciclo for?

void ReadBytes(char * stream) { 
    for (int i = 0; i < sizeof(int); i++) { 
     char foo = stream[i]; 
     } 
    } 
} 

Stai chiedendo qualcosa di più complicato di così?

Answer 2

È necessario preoccuparsi di endianess solo se i dati che si sta leggendo sono composti da numeri maggiori di un byte.
se stai leggendo i byte sizeof (int) e prevedi di interpretarli come un interno, l'endianità fa la differenza. essenzialmente endianness è il modo in cui una macchina interpreta una serie di più di 1 byte in un valore numerico.

Answer 3

dipende da come si desidera leggere loro, ho la sensazione che si desidera lanciare 4 byte in un intero, così facendo sulla rete in streaming i dati di solito finiscono in qualcosa di simile:

int foo = *(int*)(stream+offset_in_stream); 

Answer 4

Do vuoi dire una cosa del genere ?:

char* a; 
int i; 
memcpy(&i, a, sizeof(i)); 

Devi solo preoccuparti di endianess se la fonte dei dati è da una piattaforma diversa, come un dispositivo.

Answer 5

Basta usare un ciclo for che si sposta sull'array nei blocchi sizeof (int).
Utilizzare la funzione ntohl (trovata nell'intestazione <arpa/inet.h>, almeno su Linux) per convertire da byte nell'ordine di rete (l'ordine di rete è definito big-endian) nell'ordine di byte locale. Questa funzione di libreria è implementata per eseguire la corretta conversione da rete a host per qualsiasi processore su cui stai lavorando.

Answer 6

a) È necessario preoccuparsi solo di "endianità" (cioè scambio di byte) se i dati sono stati creati su una macchina big-endian e vengono elaborati su una macchina little-endian o viceversa. Ci sono molti modi in cui ciò può accadere, ma qui ci sono un paio di esempi.

1. Si ricevono dati su una macchina Windows tramite un socket. Windows utilizza un'architettura little-endian mentre i dati di rete sono "supposti" per essere in formato big-endian.
2. Si elabora un file di dati che è stato creato su un sistema con un diverso "endianness".

In entrambi i casi, è necessario scambiare byte tutti i numeri superiori a 1 byte, ad es., corti, inte, long, double, ecc. Tuttavia, se si hanno sempre a che fare con dati della stessa piattaforma, i problemi di endian non sono di alcuna importanza.

b) In base alla tua domanda, sembra che tu abbia un puntatore char e desideri estrarre i primi 4 byte come un int e quindi affrontare eventuali problemi di endian. Per eseguire l'estrazione, utilizzare:

int n = *(reinterpret_cast<int *>(myArray)); // where myArray is your data 

Ovviamente, questo presuppone che myArray non sia un puntatore nullo; in caso contrario, questo si bloccherà in quanto dereferenzia il puntatore, quindi impiegare un buon schema di programmazione difensiva.

Per scambiare i byte su Windows, è possibile utilizzare le funzioni ntohs()/ntohl() e/o htons()/htonl() definite in winsock2.h. Oppure si può scrivere alcune semplici routine per fare questo in C++, ad esempio:

inline unsigned short swap_16bit(unsigned short us) 
{ 
    return (unsigned short)(((us & 0xFF00) >> 8) | 
          ((us & 0x00FF) << 8)); 
} 

inline unsigned long swap_32bit(unsigned long ul) 
{ 
    return (unsigned long)(((ul & 0xFF000000) >> 24) | 
          ((ul & 0x00FF0000) >> 8) | 
          ((ul & 0x0000FF00) << 8) | 
          ((ul & 0x000000FF) << 24)); 
} 

Answer 7

Il modo più semplice per risolvere questo è quello di assicurarsi tutto ciò genera il byte lo fa in un endianness coerente. In genere l ' "ordine di byte di rete" usato da vari roba TCP/IP è migliore: la biblioteca routine htonl e ntohl lavoro molto bene con questo, e sono di solito abbastanza ben ottimizzato.

Tuttavia, se non si utilizza l'ordine dei byte di rete, potrebbe essere necessario eseguire altre operazioni in . Hai bisogno di sapere due cose: la dimensione di un intero e l'ordine dei byte. Una volta che lo sai, sai quanti byte estrarre e in quale ordine mettere insieme in un int.

qualche esempio di codice che assume sizeof (int) è il giusto numero di byte:

#include <limits.h> 

int bytes_to_int_big_endian(const char *bytes) 
{ 
    int i; 
    int result; 

    result = 0; 
    for (i = 0; i < sizeof(int); ++i) 
     result = (result << CHAR_BIT) + bytes[i]; 
    return result; 
} 

int bytes_to_int_little_endian(const char *bytes) 
{ 
    int i; 
    int result; 

    result = 0; 
    for (i = 0; i < sizeof(int); ++i) 
     result += bytes[i] << (i * CHAR_BIT); 
    return result; 
} 


#ifdef TEST 

#include <stdio.h> 

int main(void) 
{ 
    const int correct = 0x01020304; 
    const char little[] = "\x04\x03\x02\x01"; 
    const char big[] = "\x01\x02\x03\x04"; 

    printf("correct: %0x\n", correct); 
    printf("from big-endian: %0x\n", bytes_to_int_big_endian(big)); 
    printf("from-little-endian: %0x\n", bytes_to_int_little_endian(little)); 
    return 0; 
} 

#endif 

Answer 8

Perché leggere quando si può semplicemente confrontare?

bool AreEqual(int i, char *data) 
{ 
    return memcmp(&i, data, sizeof(int)) == 0; 
} 

Se ci si preoccupa di endianness quando è necessario convertire tutti gli interi in qualche forma invariabile. htonl e ntohl sono buoni esempi.

Answer 9

Come su

int int_from_bytes(const char * bytes, _Bool reverse) 
{ 
    if(!reverse) 
     return *(int *)(void *)bytes; 

    char tmp[sizeof(int)]; 

    for(size_t i = sizeof(tmp); i--; ++bytes) 
     tmp[i] = *bytes; 

    return *(int *)(void *)tmp; 
} 

usereste in questo modo:

int i = int_from_bytes(bytes, SYSTEM_ENDIANNESS != ARRAY_ENDIANNESS); 

---

Se siete su un sistema in cui la fusione void *-int * può comportare conflitti di allineamento, si possibile utilizzare

int int_from_bytes(const char * bytes, _Bool reverse) 
{ 
    int tmp; 

    if(reverse) 
    { 
     for(size_t i = sizeof(tmp); i--; ++bytes) 
      ((char *)&tmp)[i] = *bytes; 
    } 
    else memcpy(&tmp, bytes, sizeof(tmp)); 

    return tmp; 
}