Pourquoi utiliser hex?
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 nombres hexadécimaux, comme à la ligne 134:
for (j = 1; val && j <= 0x80; j <<= 1, q++)
Maintenant, pourquoi utiliseraient-ils le 0x80? Je ne suis pas si bon avec hex mais j'ai trouvé un hex en ligne décimal et il m'a donné 128 pour 0x80.
Toujours avant la ligne 134, à la ligne 114, ils ont ceci:
small_n = (n & 0xffff0000) == 0;
L'hex décimal m'a donné 4294901760 pour ce nombre hexadécimal. Donc ici, dans cette ligne, ils font un peu ET et comparent le résultat à 0 ??
Pourquoi ne pas simplement utiliser le numéro? Quelqu'un peut-il expliquer et donner des exemples d'autres situations?.
J'ai aussi vu de grandes lignes de code où ce sont juste des nombres hexadécimaux et je n'ai jamais vraiment compris pourquoi :(
Dans les deux cas, vous citez, le motif binaire du nombre est important, pas le nombre réel.
Par exemple, dans le premier cas, j va être 1, puis 2, 4, 8, 16, 32, 64 et enfin 128 à mesure que la boucle progresse.
En binaire, c'est-à-dire,
0000:0001, 0000:0010, 0000:0100, 0000:1000, 0001:0000, 0010:0000, 0100:0000 et 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, et 0x80.
Dans le deuxième exemple, l'objectif était de supprimer les deux octets inférieurs de la valeur. Donc, étant donné une valeur de 1 234 567 890, nous voulons nous retrouver avec 1 234 567 168.
En hexadécimal, c'est plus clair: commencez par 0x4996:02d2, terminer par 0x4996:0000.
c'est un peu un masque. Les valeurs hexadécimales permettent de voir facilement la représentation binaire sous-jacente. n & 0xffff0000 renvoie les 16 premiers bits de n. 0xffff0000 signifie "16 1 et 16 0 en binaire"
0x80 signifie "1000000", vous commencez donc par "00000001" et continuez à déplacer ce bit vers la gauche "0000010", "0000100", etc. jusqu'à "1000000"
Il existe un mappage direct entre les chiffres hexadécimaux (ou octaux d'ailleurs) et les modèles de bits sous-jacents, ce qui n'est pas le cas avec les décimales. 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 nombres 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 mes jours 8 bits, je trouve hex un raccourci pratique pour tout ce qui est binaire. Le bit twiddling est une compétence mourante. Une fois (il y a environ 10 ans), j'ai vu un article de réseautage de troisième année à l'université où seulement 10% (5 sur 50 environ) des gens de la classe pouvaient calculer un masque de bits.
0xffff0000 est facile à comprendre que c'est 16 fois "1" et 16 fois "0" dans une valeur de 32 bits, tandis que 4294901760 est magique.
Je trouve affolant que la famille de langages C ait toujours supporté l'octal et l'hex mais pas le binaire. J'ai longtemps souhaité qu'ils ajoutent un support direct pour le binaire:
int mask = 0b00001111;
Il y a de nombreuses années/emplois, alors que je travaillais sur un projet qui impliquait une énorme quantité de mathématiques au niveau du bit, je me suis fatigué et j'ai généré un fichier d'en-tête qui contenait 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)
Il a parfois rendu certains codes au niveau du bit plus lisibles.
La plus grande utilisation de hex est probablement la programmation intégrée. Les nombres hexadécimaux sont utilisés pour masquer des bits individuels dans les registres matériels ou pour fractionner plusieurs valeurs numériques regroupées dans un seul registre 8, 16 ou 32 bits.
Lors de la spécification de masques de bits individuels, de nombreuses personnes commencent par:
#define bit_0 1
#define bit_1 2
#define bit_2 4
#define bit_3 8
#define bit_4 16
etc...
Après un certain temps, ils avancent vers:
#define bit_0 0x01
#define bit_1 0x02
#define bit_2 0x04
#define bit_3 0x08
#define bit_4 0x10
etc...
Ensuite, ils apprennent à tricher et laissent le compilateur générer les valeurs dans le cadre de l'optimisation du temps de compilation:
#define bit_0 (1<<0)
#define bit_1 (1<<1)
#define bit_2 (1<<2)
#define bit_3 (1<<3)
#define bit_4 (1<<4)
etc...
Parfois, la représentation visuelle des valeurs dans HEX rend le code plus lisible ou compréhensible. Par exemple, le masquage de bits ou l'utilisation de bits devient non évident lorsque l'on regarde les représentations décimales des nombres.
Cela peut parfois concerner la quantité d'espace qu'un type de valeur particulier a à offrir, ce qui peut également jouer un rôle.
Un exemple typique pourrait être dans un paramètre binaire, donc au lieu d'utiliser décimal pour afficher certaines valeurs, nous utilisons binaire.
disons qu'un objet avait un ensemble non exclusif de propriétés dont les valeurs étaient soit on, soit off (3 d'entre elles) - une façon de représenter l'état de ces propriétés est avec 3 bits.
les représentations valides sont comprises entre 0 et 7 en décimal, mais ce n'est pas si évident. plus évidente est la représentation binaire:
000, 001, 010, 011, 100, 101, 110, 111
De plus, certaines personnes sont très à l'aise avec l'hex. Notez également que les nombres magiques codés en dur ne sont que cela et que ce n'est pas si important, peu importe le système de numérotation à utiliser
J'espère que ça aide.
En règle générale, l'utilisation de nombres hexadécimaux au lieu de décimaux est due au fait que l'ordinateur fonctionne avec des bits (nombres binaires) et lorsque vous travaillez avec des bits, il est également plus compréhensible d'utiliser des nombres hexadécimaux, car il est plus facile de passer de hexadécimal à binaire que de décimal à binaire. .
OxFF = 1111 1111 ( F = 1111 )
mais
255 = 1111 1111
car
255 / 2 = 127 (rest 1)
127 / 2 = 63 (rest 1)
63 / 2 = 31 (rest 1)
... etc
Tu vois cela? C'est beaucoup plus simple de passer de Hex à binaire.
Il y a 8 bits dans un octet. Hex, base 16, est laconique. Toute valeur d'octet possible est exprimée à l'aide de deux caractères de la collection 0..9, plus a, b, c, d, e, f.
La base 256 serait plus concise. Chaque octet possible pourrait avoir son propre caractère, mais la plupart des langues humaines n'utilisent pas 256 caractères, donc Hex est le gagnant.
Pour comprendre l'importance d'être concis, considérez que dans les années 1970, lorsque vous vouliez examiner votre mégaoctet de mémoire, il était imprimé en hexadécimal. L'impression utiliserait plusieurs milliers de pages de grand papier. Octal aurait gaspillé encore plus d'arbres.
Les nombres hexadécimaux ou hexadécimaux représentent 4 bits de données, 0 à 15 ou en HEX 0 à F. Deux valeurs hexadécimales représentent un octet.
Pour être plus précis, hexadécimal et décimal, ce sont tous des NOMBRES. Les radix (base 10, 16, etc.) sont des moyens de présenter ces chiffres d'une manière plus claire ou plus pratique.
Lorsque nous discutons de "combien il y a quelque chose", nous utilisons normalement décimal. Lorsque nous examinons des adresses ou des modèles de bits sur des ordinateurs, hex est généralement préféré, car souvent la signification des octets individuels peut être importante.
Hex, (et octal) ont la propriété d'être des puissances de deux, donc ils mappent bien les groupes. Hex mappe 4 bits à un quartet hexadécimal (0-F), donc un octet est stocké dans deux quartets (00-FF). Octal était populaire sur les équipements numériques (DEC) et d'autres machines plus anciennes, mais un chiffre octal est mappé sur trois bits, de sorte qu'il ne franchit pas aussi bien les frontières d'octets.
Dans l'ensemble, le choix de Radix est un moyen de faciliter votre programmation - utilisez celui qui correspond le mieux au domaine.
En regardant le fichier, c'est un code assez grincheux. J'espère que vous êtes bon en C et que vous ne l'utilisez pas comme tutoriel ...
Hex est utile lorsque vous travaillez directement au niveau du bit ou juste au-dessus. Par exemple, travailler sur un pilote où vous regardez directement les bits provenant d'un périphérique et déformer les résultats afin que quelqu'un d'autre puisse lire un résultat cohérent. C'est une représentation compacte assez facile à lire du binaire.