Calcul
MathCalculatrice hexadécimale
Calculatrice hex pour programmeurs : AND/OR/XOR/NOT, décalages et arithmétique avec largeur de bits 8/16/32/64 ou BigInt, sortie signée en complément à deux, hex/déc/binaire.
Vous avez des commentaires ? Signalez des bugs, suggérez des fonctionnalités ou partagez vos idées — nous lisons toutComment calculer en hexadécimal ?
Le système hexadécimal (base 16) utilise 16 symboles : 0-9 et A-F. Il est courant en programmation et dans les systèmes numériques. Chaque position correspond à une puissance de 16.
Conversion hexadécimal → décimal :
- Écrivez le nombre hexadécimal
- Multipliez chaque chiffre par 16 élevé à la puissance de sa position (en partant de 0 à droite)
- Additionnez les résultats
0xFF = 15×16¹ + 15×16⁰ = 240 + 15 = 255
Conversion décimal → hexadécimal :
- Divisez le nombre décimal par 16
- Relevez le reste (10-15 deviennent A-F)
- Poursuivez la division par 16 jusqu'à obtenir 0
255 ÷ 16 = 15 remainder 15 → F
15 ÷ 16 = 0 remainder 15 → F
Result: 0xFF
Table de référence hexadécimale
| Decimal | Hexadecimal | Binary |
|---|---|---|
| 0 | 0x0 | 0000 |
| 1 | 0x1 | 0001 |
| 10 | 0xA | 1010 |
| 15 | 0xF | 1111 |
| 16 | 0x10 | 10000 |
| 255 | 0xFF | 11111111 |
| 256 | 0x100 | 100000000 |
À propos de cette calculatrice hexadécimale
Entrez deux nombres dans n'importe quelle combinaison de bases — hex, décimal ou binaire — choisissez une opération et une largeur de bits, et la calculatrice renvoie le résultat en même temps en hex, décimal non signé, décimal signé et binaire. Le cœur de calcul utilise BigInt, donc en mode Arbitraire (BigInt) les très grandes valeurs comme 0xFFFFFFFFFFFFFFFF fonctionnent sans perte de précision (0xFFFFFFFFFFFFFFFF + 1 = 0x10000000000000000). Le sélecteur de largeur de bits (8/16/32/64) fait que les opérations bit à bit (AND, OR, XOR, NOT, décalages) bouclent dans un registre fixe exactement comme en C, en Rust ou en Python avec masque : NOT 0xFF en 8 bits donne 0x00, et les résultats négatifs sont affichés en hex complément à deux et en décimal signé. Tout s'exécute dans votre navigateur — aucune entrée n'est envoyée.
Questions fréquentes
Lisez les chiffres hex de droite à gauche en multipliant chacun par une puissance croissante de 16. Pour 0xFF : F×16¹ + F×16⁰ = 15·16 + 15·1 = 240 + 15 = 255. Pour quelque chose de plus long comme 0x1A2B : 1·16³ + 10·16² + 2·16¹ + 11·16⁰ = 4096 + 2560 + 32 + 11 = 6699. La calculatrice effectue la conversion en une étape — choisissez 'Hex' comme base d'entrée et la valeur décimale s'affiche en dessous.
Divisez plusieurs fois par 16 en notant chaque reste. Lus de bas en haut, les restes donnent la valeur hex (avec 10–15 écrits A–F). Exemple pour 255 : 255 ÷ 16 = 15 reste 15 (F) ; 15 ÷ 16 = 0 reste 15 (F). De bas en haut : FF. Donc 255 = 0xFF. La calculatrice convertit dans les deux sens — choisissez la base source dans le menu déroulant et le résultat apparaît dans les trois bases.
Les opérations bit à bit AND, OR et XOR opèrent sur la représentation binaire des opérandes, bit par bit. 0xFF AND 0x0F : en binaire 11111111 AND 00001111 = 00001111 = 0x0F (ne garde que le quartet bas). 0xA0 OR 0x0B : 10100000 OR 00001011 = 10101011 = 0xAB (combine les bits). 0xFF XOR 0x0F : 11111111 XOR 00001111 = 11110000 = 0xF0 (inverse les bits là où le second opérande vaut 1). Ce sont les briques de la programmation par masques de bits et des astuces sur les canaux de couleur.
Le décalage à gauche de n positions déplace tous les bits de n vers la gauche en complétant par des zéros à droite — équivalent à multiplier par 2ⁿ. 0x0F << 4 = 0xF0 (un décalage d'un quartet). Le décalage à droite de n positions déplace les bits vers la droite en abandonnant ce qui dépasse — équivalent à diviser entier par 2ⁿ. 0xFF >> 4 = 0x0F. Les décalages servent à empaqueter/désempaqueter les canaux RGB (red = (color >> 16) & 0xFF), à lire des formats binaires et à implémenter une multiplication/division rapide par des puissances de deux.
Chaque paire hex code une valeur 00–FF (0–255) qui donne l'intensité d'un canal de couleur. #FF0000 est le rouge pur (R=255, G=0, B=0) ; #00FF00 le vert pur ; #FFFFFF le blanc. Trois octets tiennent exactement dans six chiffres hex, c'est pourquoi le format est universel en CSS, dans les outils graphiques et dans les API d'image. Utiliser hex au lieu de décimal garde chaque canal visuellement distinct (#FF6347 vs rgb(255, 99, 71)) et rend triviale l'extraction de chaque canal par masquage.
Non. 0x10 vaut seize en hexadécimal — le préfixe '0x' indique au lecteur (et au compilateur) que les chiffres sont en base 16. Sans préfixe, 10 vaut dix en décimal. Les mêmes chiffres peuvent représenter des valeurs différentes selon la base : 10 en binaire vaut 2, 10 en hex vaut 16, 10 en décimal vaut 10. Le menu de base placé à côté de chaque nombre permet de l'indiquer explicitement, supprimant toute ambiguïté.
Oui. Réglez le menu de largeur de bits sur Arbitraire (BigInt) et l'arithmétique n'a aucune limite de largeur : 0xFFFFFFFFFFFFFFFF + 1 = 0x10000000000000000 (17 chiffres hex), et vous pouvez multiplier ou décaler des valeurs bien au-delà de 256 bits sans perte de précision. Si vous choisissez plutôt une largeur fixe (8/16/32/64 bits), le résultat est masqué à cette taille de registre et boucle — exactement ce que ferait un uint8_t/uint32_t/uint64_t en C ou en Rust.
Sur un vrai processeur il n'y a pas de 'bit de signe' séparé — une valeur négative est stockée en complément à deux dans un registre de largeur fixe, donc la réponse dépend entièrement de la largeur de bits. Choisissez 8/16/32/64 bits et l'outil masque le résultat à cette largeur : NOT 0xFF en 8 bits = 0x00, NOT 0x00 en 8 bits = 0xFF, et 5 − 10 en 32 bits affiche le hex non signé 0xFFFFFFFB à côté du décimal signé −5. En mode Arbitraire (BigInt) il n'y a pas de registre où boucler, donc NOT et la soustraction peuvent afficher une valeur avec un signe moins explicite au lieu du complément à deux. Le champ Décimal signé indique toujours comment un résultat de largeur fixe est interprété comme entier signé.
Adaptez la largeur au registre ou au type que vous étudiez : 8 bits pour un octet ou uint8_t, 16 bits pour un short, 32 bits pour un int courant, 64 bits pour un long/pointeur, ou Arbitraire (BigInt) pour un calcul exact en grands nombres sans bouclage. Le débordement par bouclage signifie qu'un résultat qui ne tient pas dans la largeur choisie ne garde que les bits de poids faible : 0xFF + 1 en 8 bits = 0x00 (il a bouclé de 255 à 0), et 0xFFFFFFFF + 1 en 32 bits = 0x00000000. C'est le comportement dont dépendent le firmware, l'embarqué et la rétro-ingénierie, et il correspond à l'arithmétique entière de C/Rust et à Python avec un masque & explicite.
Les adresses mémoire s'affichent en hex (un pointeur comme 0x7fff5fbff7c0 est plus lisible que sa forme décimale à 13 chiffres). Les drapeaux de bits et masques de permissions utilisent des constantes hex (modes Unix tels que 0644, bits de registre comme 0x80000000). Les empreintes cryptographiques et les UUID sont affichés en hex. Les valeurs de couleurs CSS, les identifiants d'assets dans les moteurs de jeu, les opcodes dans les désassembleurs et les codes d'erreur Windows (0x80070005 'accès refusé') sont en hex. Cette calculatrice est pensée précisément pour les calculs que vous faites en déboguant ou en lisant la documentation sur ces sujets.
CALCULATRICES MATHéMATIQUES32
WUTOOLS