Qu'est-ce que 0xFF et pourquoi est-il décalé de 24 fois?

#define SwapByte4(ldata) \
   (((ldata & 0x000000FF) << 24) | \
   ((ldata & 0x0000FF00) << 8) | \
   ((ldata & 0x00FF0000) >> 8) | \
   ((ldata & 0xFF000000) >> 24))

Ce n'est que 0x000000FF représenter? Je sais que décimal 15 est représenté en hexadécimal, comme F, mais pourquoi est-il << 24?

1. vous n'avez pas besoin de le \ à la fin des lignes. 2. Dois-je sens l'odeur des devoirs? Si oui, veuillez étiqueter en conséquence
Je soupçonne le début de la première ligne est "#define"; comment le marquage [devoirs] vous aider à mieux répondre à cette question?
Il ne serait pas. C'est juste une coutume en SORTE de balise devoirs questions avec les devoirs de la balise
parce qu'une meilleure réponse à des devoirs à faire à la question enseigne l'OP quelque chose. Si c'est juste une question technique, en fournissant la réponse est assez. Si c'est les devoirs, juste provding la réponse est probablement pas le meilleur tihng à faire.
Comment être affecté par un enseignant de modifier le fonctionnement de l'OP sera mieux comprendre?

OriginalL'auteur piyapiya | 2010-10-30

  1. 29

    Ici est une valeur hexadécimale, 0x12345678, écrit en binaire, et annoté avec certaines positions de bits:

    |31 24/23 16/15 8/7 bit 0| 
+---------------+---------------+---------------+---------------+ 
|0 0 0 1 0 0 1 0/0 0 1 1 0 1 0 0/0 1 0 1 0 1 1 0/0 1 1 1 1 0 0 0| 
+---------------+---------------+---------------+---------------+

    ...et c'est là 0x000000FF:

    +---------------+---------------+---------------+---------------+ 
|0 0 0 0 0 0 0 0/0 0 0 0 0 0 0 0/0 0 0 0 0 0 0 0/1 1 1 1 1 1 1 1| 
+---------------+---------------+---------------+---------------+

    Donc un bit à bit ET sélectionne juste en bas de 8 bits de la valeur d'origine:

    +---------------+---------------+---------------+---------------+ 
|0 0 0 0 0 0 0 0/0 0 0 0 0 0 0 0/0 0 0 0 0 0 0 0/0 1 1 1 1 0 0 0| 
+---------------+---------------+---------------+---------------+

    ...et de la décaler de 24 bits à gauche se déplace de bas en 8 bits vers le haut:

    +---------------+---------------+---------------+---------------+ 
|0 1 1 1 1 0 0 0/0 0 0 0 0 0 0 0/0 0 0 0 0 0 0 0/0 0 0 0 0 0 0 0| 
+---------------+---------------+---------------+---------------+

    ...qui est 0x78000000 dans l'hex.

    Les autres parties de travail sur le reste de la 8-bits parties de l'entrée:

     0x12345678 
& 0x000000FF 
---------- 
0x00000078 << 24 = 0x78000000 (comme illustré ci-dessus) 

0x12345678 
& 0x0000FF00 
---------- 
0x00005600 << 8 = 0x00560000 

0x12345678 
& 0x00FF0000 
---------- 
0x00340000 >> 8 = 0x00003400 

0x12345678 
& 0x00000000 
---------- 
0x12000000 >> 24 = 0x00000012 

| ---------- 
0x78563412

    de sorte que l'effet global est de considérer la valeur de 32 bits ldata comme une séquence de quatre octets de 8 bits, et d'inverser leur ordre.

    Donc, en gros, c'est un 32 bits valeur Little-Endian <=> Big Endian convertisseur.
    un grand merci ce sera l'objet de en little Endian et big Endian
    est-ce lié à la machine epsilon..
    est-ce utilisé pour WKB
    "Machine " epsilon" est numérique, la propriété d'une représentation à virgule flottante, et n'a rien à voir avec le décalage de bits de masquage, ou boutisme. Je n'ai aucune idée de ce que vous entendez par "WKB".

    OriginalL'auteur Matthew Slattery

  2. 5

    Ce genre de code tend à être utilisé pour échanger des choses entre les big endian et little endian format. Il y a aussi un petit truc qui vous permet de convertir un mot dans certains connus (format permet de dire, en little endian), et ce, endianness la machine actuelle arrive d'être, et vice versa. Que serait quelque chose comme ceci:

    unsigned long littleEndian;
unsigned char* littleBytes = &littleEndian;
unsigned long result = 0;
for (i = 0; i < 4; i++)
    result += unsigned long(littleBytes[i]) << (8 * i);

    Cela fonctionne (en supposant que je n'ai pas testé), parce que peu importe combien d'octets sont stockés, la touche maj de gauche est la garantie de s'orienter vers plus de bits significatifs. La conversion d'un char* vous permet d'accéder les octets dans l'ordre qu'ils sont en fait stockées dans la mémoire. En utilisant cette astuce, vous n'avez pas besoin de détecter la machine boutisme de lire/écrire des trucs dans un format connu. Il est vrai que vous pourriez tout aussi bien utiliser les fonctions standard (hton, etc.) 😛

    (Note: Vous devez être un peu prudent et de lancer le char avant de passer, sinon ça ne déborde tous tes chaussures. Aussi, += n'est pas la seule option,|=, seraient probablement plus de sens, mais peut-être moins clair, si vous n'êtes pas habitué à elle, je ne suis pas sûr)

    pouvez-vous me dire sur nombre important.. j'ai lu sur double et float point de la représentation, mais je ne comprenais pas significative.
    est-ce lié à la machine epsilon?
    par d'importants je viens de dire plus de valeur, ou plus. Si j'ai le numéro 123, le plus important chiffre est le 1, parce que c'est "une valeur" 100. Même idée pour les bits et les octets dans plusieurs. Certains machine à stocker des octets dans un ordre différent, de sorte que l'octet le plus significatif d'un nombre peut être conservé à la première adresse de la mémoire, ou il pourrait être le dernier.
    QU'EST-CE QUE LA MACHINE EPSILON. EST-CE lié À l'une OU wWKB
    oh, je vois OK pouvez-vous me parler de façon significative chiffres en float point de la représentation en binaire.. comme flotter prendre 4B de la mémoire et de ses représenté comme 0sign bits,8 bits d'exposant et tous les autres sont de la fraction.. ce sera la signification des chiffres ici pour le stockage d'un nombre.

    OriginalL'auteur David

  3. 2

    Vous avez besoin de regarder le 0x000000FF comme un masque de bits, c'est à dire où il est de 1 la valeur de ldata seront prises et où il est en 0 - 0 seront prises.

    Afin de comprendre le masque de bits u besoin de le convertir en binaire, hexadécimal, c'est très facile, à chaque nombre hexadécimal à 4 chiffres binaires, c'est à dire:

    hex 0 = binaire 0000
    hex 1 = binaire 0001
    et ainsi de suite.

    Maintenant à l'évolution: à noter que le changement prend certaines données de la source, 8 bits exactement, et se déplace à un autre endroit de la destination.

    Maintenant noter qu'il y a | c'est à dire OU l'opération sur l'ensemble du masque de bits ET des opérations, c'est à dire les zéros de séjour de zéros et dans le cas où il y a '1' le résultat contiendra un.

    Espère que cela aide 🙂

    ou est utilisé pour wkb..

    OriginalL'auteur Drakosha

  4. 0

    Disons données est un nombre 32 bits représenté comme 0x12345678 (chaque nombre est de 4 bits en hexadécimal)

    De données & 0x000000FF moyen de ne garder que les 8 derniers bits (appelé bit de masque)
    = 0x00000078

    La << 24 signifie déplacer cette valeur à la gauche de 24 bits (78 commence à la position 24 [0 indice])
    = 0x78000000

    L' | moyens logiques ou qui dans ce cas sera juste un plus

    Résultat Final = 0x78563412

    Lire sur des manipulations logiques

    merci.... mais quel est le but de tout cela.
    Dans ce cas, c'est pour échanger endianess d'un nombre 32 bits. Je n'écris pas cela comme un #define, mais une fonction à la place. Voici une bonne lecture, et pourquoi vous avez besoin de ces types de fonctions: en.wikipedia.org/wiki/Endianness

    OriginalL'auteur David