Comment écrire un message 24 bits après avoir lu à partir d'un nombre entier de 4 octets sur une grosse machine endian (C)?

Question

Je suis en train de construire un message à envoyer un numéro 24 bits sur le réseau. Pour de petites machines endian, le code est (PTR est le pointeur vers le tampon de message):

*ptr++ = (num >> 16) & 0xFF;
*ptr++ = (num >> 8)  & 0xFF;
*ptr++ = (num)       & 0xFF;

(Donc, si NUM0, num1, num2 et num3 sont les octets qui composent num, le message serait codé comme num2|num1|num0.)

Quel devrait être le code pour le codage num2|num1|num0 sur une grosse machine endian?

Answer 1

Votre code est portable, peu importe endianess. Les opérateurs de décalage >> travail << avec les valeurs, non pas avec la représentation.

Answer 2

La question est ici, dans quel ordre octet est message être envoyé / construit? Parce que si vous êtes sur une petite ou grosse machine endian n'a pas d'importance en ce qui concerne num, comme vous divisant déjà num en octets individuels d'une manière endian-agnostique.

Le code que vous avez posté magasins 24 bits de num en big endian (aka l'ordre des octets du réseau). Donc, si c'est ce que vous voulez vous déjà fait. Si vous voulez stocker en grand peu à la place, juste inverser l'ordre:

*ptr++ = (num)       & 0xFF;
*ptr++ = (num >> 8)  & 0xFF;
*ptr++ = (num >> 16) & 0xFF;

Answer 3

Dans la machine de réception, quelle que soit endian-ness, si vous les recevez dans la même ordre que sont stockés dans ptr, les assembler comme ceci:

num = (ptr[0] << 16) + (ptr[1] << 8) + (ptr[2]);

Answer 4

int main(int argc, char** argv) {

    int a, b;
    a = 0x0f000000;        // Contain 32 bit value
    printf("before = %d\n", a);
    b = a & (~0xff000000); // convert the last 8 bits to zero so we got only 24 bit value in b
    printf("After = %d\n", b);
    return (EXIT_SUCCESS);
}

Il y a un nombre contenant une valeur de 32 bits, mais le numéro B ne contient que 24 bits, à partir de chiffre le moins significatif. Et cela ne dépend pas de boutisme parce que les opérateurs de ne fonctionnent pas au niveau du bit avec une représentation de la mémoire.

Vous pouvez donc utiliser

num = num & (~0xff000000);

pour obtenir la dernière valeur 24 bits.