Pourquoi utiliser l'hexagone ?

Question

Hey ! Je regardais ce code à http://www.gnu.org/software/m68hc11/examples/primes_8c-source.html

J'ai remarqué que dans certaines situations, ils utilisaient des chiffres hexagonaux, comme à la ligne 134 :

for (j = 1; val && j <= 0x80; j <<= 1, q++)

Maintenant, pourquoi utiliseraient-ils le 0x80 ? Je ne suis pas très doué avec les hexagones mais j'ai trouvé un outil en ligne pour convertir les hexagones en décimales et il m'a donné 128 pour 0x80.

Avant la ligne 134, à la ligne 114, il y a aussi ceci :

small_n = (n & 0xffff0000) == 0;

Le passage de l'hexagone au décimal m'a donné 4294901760 pour ce numéro hexagonal. Donc ici, dans cette ligne, ils font un bit ET et comparent le résultat à 0 ??

Pourquoi ne pas simplement utiliser le numéro ? Quelqu'un peut-il m'expliquer et me donner des exemples d'autres situations ?

J'ai également vu de grandes lignes de code où il n'y avait que des chiffres hexadécimaux et je n'ai jamais vraiment compris pourquoi :(

Answer 1

Dans les deux cas que vous citez, c'est la structure binaire du nombre qui est importante, et non le nombre lui-même.

Par exemple, Dans le premier cas, j sera 1, puis 2, 4, 8, 16, 32, 64 et enfin 128 au fur et à mesure que la boucle progresse.

En binaire, bien sûr,

0000:0001 , 0000:0010 , 0000:0100 , 0000:1000 , 0001:0000 , 0010:0000 , 0100:0000 y 1000:0000 .

Il n'y a pas d'option pour les constantes binaires en C ou C++, mais c'est un peu plus clair en Hex : 0x01 , 0x02 , 0x04 , 0x08 , 0x10 , 0x20 , 0x40 y 0x80 .

Dans le deuxième exemple, le but était de supprimer les deux octets inférieurs de la valeur. Ainsi, pour une valeur de 1 234 567 890, nous voulons obtenir 1 234 567 168.
Dans l'hexagone, c'est plus clair : commencer par 0x4996:02d2 et se termine par 0x4996:0000 .

Answer 2

C'est un masque de bits. Les valeurs hexadécimales permettent de voir facilement la représentation binaire sous-jacente. n & 0xffff0000 renvoie les 16 bits supérieurs de n. 0xffff0000 signifie "16 1 et 16 0 en binaire".

0x80 signifie "1000000", donc on commence par "00000001" et on continue à décaler ce bit vers la gauche "0000010", "0000100", etc. jusqu'à "1000000".

Answer 3

Il existe une correspondance directe entre les chiffres hexagonaux (ou octaux, d'ailleurs) et les modèles binaires sous-jacents, ce qui n'est pas le cas avec le système décimal. Un '9' décimal représente quelque chose de différent en ce qui concerne les modèles de bits, selon la colonne dans laquelle il se trouve et les chiffres qui l'entourent - il n'a pas de relation directe avec un modèle de bits. En hexadécimal, un '9' signifie toujours '1001', quelle que soit la colonne. 9 = '1001', 95 = '*1001*0101' et ainsi de suite.

En tant que vestige de mon époque 8-bit, je trouve que l'hexagone est un raccourci pratique pour tout ce qui est binaire. La manipulation des bits est une compétence en voie de disparition. Une fois (il y a environ 10 ans), j'ai vu un devoir de troisième année de réseau à l'université où seulement 10% (5 sur 50 environ) des personnes de la classe pouvaient calculer un masque de bits.

Answer 4

0xffff0000 est facile à comprendre car il s'agit de 16 fois "1" et 16 fois "0" dans une valeur de 32 bits, tandis que 4294901760 est magique.

Answer 5

Je trouve exaspérant que la famille des langages C ait toujours supporté l'octal et l'hexa mais pas le binaire. J'ai longtemps souhaité qu'ils ajoutent un support direct pour le binaire :

int mask = 0b00001111;

Il y a plusieurs années/emplois, alors que je travaillais sur un projet qui impliquait une énorme quantité de mathématiques au niveau des bits, j'en ai eu assez et j'ai généré un fichier d'en-tête contenant des constantes définies pour toutes les valeurs binaires possibles jusqu'à 8 bits :

#define b0        (0x00)
#define b1        (0x01)
#define b00       (0x00)
#define b01       (0x01)
#define b10       (0x02)
#define b11       (0x03)
#define b000      (0x00)
#define b001      (0x01)
...
#define b11111110 (0xFE)
#define b11111111 (0xFF)

Elle a parfois rendu plus lisible certains codes au niveau des bits.