Conversion d'un tableau d'octets (tableau char) en un type entier (short, int, long)

Je me demandais si le système de stockage des questions lors de la conversion d'un tableau d'octets pour un court /int /long. Serait-ce incorrect de faire si le code s'exécute sur big-endian et little-endian machines?

short s = (b[0] << 8) | (b[1]);
int i = (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | (b[3])

source d'informationauteur Mike

c++

14

Oui, endianness questions. En little endian vous avez l'octet le plus significatif dans la partie supérieure de court ou de type int - c'est à dire les bits 8 à 15, pour courte et 24-31 pour int. Pour big endian l'octet de commande devra être inversée:
```
short s = ((b[1] << 8) | b[0]);
int i = (b[3] << 24) | (b[2] << 16) | (b[1] << 8) | (b[0]);
```
On suppose que le tableau d'octets est en little endian commande. Stockage et de conversion entre le tableau d'octets et les types integer, ne dépend pas seulement sur le boutisme de la CPU, mais aussi sur le boutisme du tableau d'octets de données.

Il est recommandé d'envelopper ces conversions dans les fonctions qui sauront (soit via des indicateurs de compilation ou à l'exécution) le boutisme du système et d'effectuer la conversion correctement.

En outre, la création d'une norme pour le tableau d'octets de données (toujours en big endian, par exemple) et l'utilisation de la socket ntoh_s et ntoh_l va décharger de la décision concernant le stockage de l'OS socket de mise en œuvre qui est au courant de ces choses. Notez que par défaut, réseau afin est big endian (le n dans ntoh_x), afin d'avoir le tableau d'octets de données comme big endian serait la plus simple façon de le faire.

Comme l'a souligné par les OP (@Mike), boost fournit également boutisme des fonctions de conversion.

//on little endian:

unsigned char c[] = { 1, 0 };       //"one" in little endian order { LSB, MSB }

int a = (c[1] << 8) | c[0];         //a = 1

//----------------------------------------------------------------------------

//on big endian:

unsigned char c[] = { 0, 1 };       //"one" in big endian order { MSB, LSB }

int a = (c[1] << 8) | c[0];         //a = 1

//----------------------------------------------------------------------------

//on little endian:

unsigned char c[] = { 0, 1 };       //"one" in big endian order { MSB, LSB }

int a = (c[0] << 8) | c[1];         //a = 1 (reverse byte order)

//----------------------------------------------------------------------------

//on big endian:

unsigned char c[] = { 1, 0 };       //"one" in little endian order { LSB, MSB }

int a = (c[0] << 8) | c[1];         //a = 1 (reverse byte order)

0

Non, c'est bien aussi loin que l'endianness, mais vous pouvez avoir des problèmes si votre ints sont seulement 16 bits de large.
0

Le problème comme vous l'avez spécifié, où vous êtes à l'aide d'un existant tableau d'octets, fonctionnera très bien sur tous les ordinateurs. Vous allez vous retrouver avec la même réponse.

Toutefois, selon la façon dont vous êtes la création de ce cours d'eau, il peut être affecté par l'endianness et vous ne pouvez pas fin avec le numéro que vous le pensez.

Vous pouvez utiliser des syndicats pour cela. Endianness questions, de le changer, vous pouvez utiliser x86 BSWAP instruction (ou analogues pour l'autre des plates-formes), fourni par la plupart des compilateurs c intrinsèque.

#include <stdio.h>
typedef union{
  unsigned char bytes[8];
  unsigned short int words[4];
  unsigned int dwords[2];
  unsigned long long int qword;
} test;
int main(){
  printf("%d %d %d %d %d\n", sizeof(char), sizeof(short), sizeof(int), sizeof(long), sizeof(long long));
  test t;
  t.qword=0x0001020304050607u;
  printf("%02hhX|%02hhX|%02hhX|%02hhX|%02hhX|%02hhX|%02hhX|%02hhX\n",t.bytes[0],t.bytes[1] ,t.bytes[2],t.bytes[3],t.bytes[4],t.bytes[5],t.bytes[6],t.bytes[7]);
  printf("%04hX|%04hX|%04hX|%04hX\n" ,t.words[0] ,t.words[1] ,t.words[2] ,t.words[3]);
  printf("%08lX|%08lX\n" ,t.dwords[0] ,t.dwords[1]);
  printf("%016qX\n" ,t.qword);
  return 0;
}

Vous devez vous connecter pour publier un commentaire.