Lecture des octets de taille "entier" à partir d'un tableau de caractères *.

Je veux lire sizeof(int) octets à partir d'un char* tableau.

a) Dans ce scénario, nous avons besoin de vous inquiéter si l'endianness doit être vérifiée?

b) Comment feriez-vous de lire les 4 premiers octets soit en prenant l'endianness en considération ou non.

EDIT : La sizeof(int) octets que j'ai lu doit être comparée avec une valeur entière.

Quelle est la meilleure approche pour aller sur ce problème

source d'informationauteur kal

  1. 19

    Voulez-vous dire quelque chose comme ça?:

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

    Vous avez seulement à vous soucier d'endianess si la source de données à partir d'une plate-forme différente, comme un appareil.

  2. 9

    un), Vous avez uniquement besoin de s'inquiéter à propos de "boutisme" (c'est à dire, byte-swapping) si les données ont été créées sur un big-endian machine et est en cours de traitement sur un little-endian machine, ou vice versa. Il existe de nombreuses façons cela peut se produire, mais en voici quelques exemples.

    1. Vous de recevoir des données sur un ordinateur Windows via un socket. Windows utilise un little-endian l'architecture tandis que le réseau de données est "censé" être en format big-endian.
    2. Le traitement d'un fichier de données qui a été créé sur un système par un autre "endianness."

    Dans ces deux cas, vous aurez besoin de byte-swap de tous les nombres plus grands que 1 octet, par exemple, shorts, ints, des longs, des chambres doubles, etc. Toutefois, si vous êtes toujours face à des données à partir de la même plate-forme, endian questions sont d'aucun intérêt.

    b) en Fonction de votre question, il semble que vous avez un pointeur de char et souhaitez extraire les 4 premiers octets comme un int, et donc, tout endian questions. Faire l'extraction, l'utilisation de ce:

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

    Évidemment, cela suppose myArray n'est pas un pointeur null; sinon, cela va se planter car il déréférence le pointeur, donc employer une bonne défensive de la programmation système.

    Pour échanger les octets dans Windows, vous pouvez utiliser l'ah()/ntohl() et/ou htons()/htonl() les fonctions définies dans les winsock2.h. Ou vous pouvez écrire certaines des routines simples de faire cela en C++, par exemple:

    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));
}
  3. 3

    Dépend de la façon dont vous souhaitez les lire, j'ai l'impression que vous voulez jeter de 4 octets en entier, de le faire sur le réseau des données en streaming finissent généralement dans quelque chose comme ceci:

    int foo = *(int*)(stream+offset_in_stream);
  4. 3

    Le moyen facile de résoudre ce problème est de veillez à ce que génère les octets n'est donc cohérent de l'endianness. En général, le "network byte order" utilisés par les différents TCP/IP est des trucs
    mieux: les routines de la bibliothèque de htonl et ntohl travail très bien avec cela, et ils
    sont généralement assez bien optimisé.

    Toutefois, si l'ordre des octets de réseau n'est pas utilisé, vous pourriez avoir besoin de faire des choses dans
    d'autres moyens. Vous avez besoin de savoir deux choses: la taille d'un entier, et l'ordre des octets.
    Une fois que vous savez cela, vous savez combien d'octets à extraire et à l'ordre dans lequel mettre
    dans un int.

    Un exemple de code qui suppose sizeof(int) est le nombre d'octets:

    #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
  5. 3

    Comment sur

    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;
}

    Que vous souhaitez utiliser comme ceci:

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

    Si vous êtes sur un système où la coulée void * à int * peut entraîner l'alignement des conflits, vous pouvez utiliser

    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;
}
  6. 1

    Vous ne devriez pas avoir à vous soucier d'endianess, sauf si vous êtes à la lecture des octets à partir d'une source créé sur une machine différente, par exemple un flux réseau.

    Donné que tu ne peux pas utiliser une boucle for?

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

    Demandez-vous quelque chose de plus compliqué que cela?

  7. 1

    Vous avez besoin de s'inquiéter à propos de endianess seulement si les données que vous êtes en train de lire est composé de nombres qui sont plus d'un octet.

    si vous êtes en train de lire sizeof(int) octets et s'attendre à les interpréter comme un int alors endianess fait une différence. essentiellement endianness est la façon dont une machine interprète une série de plus de 1 octets en une valeur numérique.

  8. 1

    Suffit d'utiliser une boucle for qui se déplace sur le tableau dans sizeof(int) morceaux.

    Utiliser la fonction ntohl (qui se trouve dans l'en-tête <arpa/inet.h>, au moins sous Linux) pour convertir des octets du réseau de commande de réseau (l'ordre est défini comme big-endian) au local de l'ordre des octets. Que la fonction de la bibliothèque est mis en œuvre pour effectuer le bon réseau à l'hôte de conversion pour tout ce processeur vous êtes en cours d'exécution sur.

  9. 1

    Pourquoi lire quand vous pouvez comparer?

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

    Si vous vous faites du souci à propos de l'endianness lorsque vous avez besoin de convertir tous les entiers certaine forme invariante. htonl et ntohl sont de bons exemples.