Binaire, Décimal & Hexadécimal

🔢 COMPRENDRE LES BASES

Chaque système de numération utilise un certain nombre de symboles (chiffres). La base détermine combien de symboles existent et la valeur positionnelle de chaque chiffre.

🕹️ ANALOGIE GAMING

Imagine un compteur de score. En base 10, tu comptes de 0 à 9 avant de passer à la dizaine — c'est notre système humain. En base 2 (binaire), tu ne comptes que 0 et 1 — c'est le langage du CPU, qui ne connaît que "courant / pas de courant". En base 16 (hex), tu utilises 0-9 puis A-F pour représenter des valeurs plus grandes en moins de caractères — les programmeurs adorent ça pour lire la mémoire.

DÉCIMAL

Base 10

Symboles : 0 1 2 3 4 5 6 7 8 9

Préfixe : aucun

Usage : vie courante

BINAIRE

Base 2

Symboles : 0 1

Préfixe : 0b ou %

Usage : CPU, mémoire, bits

HEXADÉCIMAL

Base 16

Symboles : 0-9 A B C D E F

Préfixe : 0x

Usage : adresses, couleurs, opcodes

📋 DÉC / BIN / HEX / OCT — LES VALEURS CLÉS

DÉC	BINAIRE	HEX	OCTAL	Notes
0	0000 0000	0x00	000	NULL
1	0000 0001	0x01	001
2	0000 0010	0x02	002
3	0000 0011	0x03	003
4	0000 0100	0x04	004
7	0000 0111	0x07	007
8	0000 1000	0x08	010	2³ — retenue
9	0000 1001	0x09	011
10	0000 1010	0x0A	012	A en hex
11	0000 1011	0x0B	013	B en hex
12	0000 1100	0x0C	014	C en hex
13	0000 1101	0x0D	015	D en hex
14	0000 1110	0x0E	016	E en hex
15	0000 1111	0x0F	017	F en hex
16	0001 0000	0x10	020	2⁴ — retenue hex
32	0010 0000	0x20	040	SPACE (ASCII)
48	0011 0000	0x30	060	'0' (ASCII)
65	0100 0001	0x41	101	'A' (ASCII)
97	0110 0001	0x61	141	'a' (ASCII)
127	0111 1111	0x7F	177	INT8 max / DEL
128	1000 0000	0x80	200	MSB — signe négatif
192	1100 0000	0xC0	300	Masque /2 réseau
255	1111 1111	0xFF	377	UINT8 max
256	1 0000 0000	0x100	400	2⁸ — overflow byte
65535	1111 1111 1111 1111	0xFFFF	—	UINT16 max

🧬 LIRE UN OCTET BIT PAR BIT

Chaque bit a un poids positionnel : une puissance de 2. La valeur totale = somme des poids des bits à 1.

Exemple : 0b10110101 = 181 décimal = 0xB5

2⁷

1

2⁶

0

2⁵

1

2⁴

1

2³

0

2²

1

2¹

0

2⁰

1

= 128+32+16+4+1 =

181

  Bit 7   Bit 6   Bit 5   Bit 4   Bit 3   Bit 2   Bit 1   Bit 0
  MSB                                                       LSB
  (Most Significant Bit)                   (Least Significant Bit)

  128     64      32      16      8       4       2       1
  1       0       1       1       0       1       0       1
  = 128 + 0 + 32 + 16 + 0 + 4 + 0 + 1 = 181 = 0xB5

Astuce rapide : retiens les puissances de 2 — 1, 2, 4, 8, 16, 32, 64, 128. Tu peux lire n'importe quel octet en 5 secondes.

🔄 DÉCIMAL → BINAIRE — DIVISIONS SUCCESSIVES PAR 2

Divise par 2 en notant le reste à chaque étape. Lis les restes de bas en haut.

Ex

Convertir 181 en binaire

  181 ÷ 2 = 90  reste 1   ↑ LSB (lire de bas en haut)
   90 ÷ 2 = 45  reste 0   ↑
   45 ÷ 2 = 22  reste 1   ↑
   22 ÷ 2 = 11  reste 0   ↑
   11 ÷ 2 =  5  reste 1   ↑
    5 ÷ 2 =  2  reste 1   ↑
    2 ÷ 2 =  1  reste 0   ↑
    1 ÷ 2 =  0  reste 1   ↑ MSB

  Résultat (lire de bas en haut) : 1011 0101 = 181 ✅

🔄 BINAIRE → DÉCIMAL — SOMME DES POIDS

  1011 0101
  = 1×2⁷ + 0×2⁶ + 1×2⁵ + 1×2⁴ + 0×2³ + 1×2² + 0×2¹ + 1×2⁰
  = 128 + 0  + 32  + 16  + 0  + 4   + 0  + 1
  = 181

🔄 DÉCIMAL → HEX — DIVISIONS PAR 16

Même principe qu'en binaire mais on divise par 16. Les restes 10-15 deviennent A-F.

  181 ÷ 16 = 11  reste 5   ↑
   11 ÷ 16 =  0  reste B   ↑ (11 = B)

  Résultat : 0xB5 = 181 ✅

Astuce encore plus rapide : via le binaire — groupes de 4 bits.

  1011  0101
    ↓       ↓
   B      5
  = 0xB5 ✅

  4 bits = 1 chiffre hex
  8 bits = 2 chiffres hex (1 octet)
  16 bits = 4 chiffres hex
  32 bits = 8 chiffres hex

🔄 HEX → BINAIRE — LE PLUS RAPIDE

Chaque chiffre hex = exactement 4 bits. Traduis chiffre par chiffre.

  0xDEAD

  D = 13 = 1101
  E = 14 = 1110
  A = 10 = 1010
  D = 13 = 1101

  0xDEAD = 1101 1110 1010 1101 = 57005

  Hex vers décimal : 0xDEAD = 13×16³ + 14×16² + 10×16¹ + 13×16⁰
                              = 53248  + 3584   + 160    + 13 = 57005

En cybersécurité tu verras souvent 0xDEADBEEF, 0xCAFEBABE (magic bytes), 0x90 (NOP opcode), 0xFF (masque réseau). Reconnaître ces valeurs devient un réflexe.

⚡ ADDITION BINAIRE

Règles : 0+0=0, 0+1=1, 1+0=1, 1+1=10 (retenue !), 1+1+1=11 (retenue !)

EXEMPLE : 42 + 27 = 69

retenues : 0 0 1 0 1 0 0 0

42 = 0010 1010

+27 = 0001 1011

69 = 0100 0101

⚠️ OVERFLOW : 200 + 100 sur 8 bits

200 = 1100 1000

+100 = 0110 0100

44 = 0010 1100 ← overflow !

300 ne tient pas dans 8 bits (max 255), le bit de retenue est perdu.

🔧 AND, OR, XOR, NOT, SHIFTS

  A = 0b1010 1100 = 0xAC = 172
  B = 0b1100 1010 = 0xCA = 202

  AND  (&)  1 si les deux bits = 1 → masquage
  1010 1100 & 1100 1010 = 1000 1000 = 136 = 0x88

  OR   (|)  1 si au moins un bit = 1 → mise à 1
  1010 1100 | 1100 1010 = 1110 1110 = 238 = 0xEE

  XOR  (^)  1 si les deux bits sont différents → chiffrement
  1010 1100 ^ 1100 1010 = 0110 0110 = 102 = 0x66

  NOT  (~)  inverse tous les bits
  ~1010 1100              = 0101 0011 = 83  = 0x53

  SHIFT gauche (<<)  décale les bits vers la gauche = × par 2
  0000 0001 << 3       = 0000 1000 = 8   (1 × 2³ = 8)
  0000 0101 << 1       = 0000 1010 = 10  (5 × 2 = 10)

  SHIFT droite (>>) décale vers la droite = ÷ par 2
  0001 0000 >> 2       = 0000 0100 = 4   (16 ÷ 4 = 4)

🎯 TRICKS BITWISE — USAGES CONCRETS

Opération	Code C	Explication
Tester le bit N	`if (x & (1 << n))`	Est-ce que le bit N vaut 1 ?
Mettre bit N à 1	`x \|= (1 << n)`	SET le bit N
Mettre bit N à 0	`x &= ~(1 << n)`	CLEAR le bit N
Inverser bit N	`x ^= (1 << n)`	TOGGLE le bit N
Pair ou impair	`if (x & 1)`	Impair si bit 0 = 1
Multiplier par 2ⁿ	`x << n`	Plus rapide que x * pow(2,n)
Diviser par 2ⁿ	`x >> n`	Plus rapide que x / pow(2,n)
Mettre à zéro	`x & 0`	Résultat = 0 toujours
Copier valeur	`x \| 0`	Résultat = x inchangé
XOR swap	`a^=b; b^=a; a^=b`	Swap sans variable temporaire

💻 POURQUOI C'EST ESSENTIEL

Adresses mémoire & pointeurs

Les adresses mémoire s'affichent toujours en hex : 0x7fff5fbff8a0. Savoir lire l'hex est indispensable pour déboguer avec GDB, Valgrind, ou analyser un crash dump.

  (gdb) x/4xb 0x7fff5fbff8a0
  0x7fff5fbff8a0: 0x48 0x65 0x6c 0x6c  = "Hell"

Couleurs CSS & RGB

Les couleurs web sont en hex sur 3 octets : Rouge / Vert / Bleu. Chaque composante va de 0x00 à 0xFF.

  #FF0000 = Rouge pur   (R=255, G=0,   B=0)
  #00FF00 = Vert pur    (R=0,   G=255, B=0)
  #4D9FFF = Bleu néon   (R=77,  G=159, B=255)
  #FFFFFF = Blanc       (tous à 255)
  #000000 = Noir        (tous à 0)

Adresses IP & masques réseau

Une IPv4 = 4 octets. Les masques réseau (subnetting) utilisent les AND bitwise pour isoler les plages d'adresses.

  IP      : 192.168.1.42
            11000000.10101000.00000001.00101010
  Masque  : 255.255.255.0  = /24
            11111111.11111111.11111111.00000000
  AND     :
  Réseau  : 192.168.1.0    ← plage réseau

Permissions Unix (chmod)

Les permissions Linux sont en octal. Chaque groupe rwx = 3 bits.

  r=4(100) w=2(010) x=1(001)
  chmod 755 fichier
  7 = rwx (owner)  = 111 en binaire
  5 = r-x (group)  = 101 en binaire
  5 = r-x (others) = 101 en binaire

  chmod 644 fichier  = rw-r--r--
  chmod 777 fichier  = rwxrwxrwx ⚠️ dangereux

Cybersécurité — XOR & chiffrement

XOR est la base de nombreux chiffrements. La propriété clé : A XOR B XOR B = A — XOR avec la même clé deux fois redonne l'original.

  message : 0100 1000  ('H' = 72)
  clé     : 0010 1010  (42)
  XOR     : 0110 0010  (98 = chiffré)

  chiffré : 0110 0010
  clé     : 0010 1010
  XOR     : 0100 1000  ('H' retrouvé !) ✅

Magic bytes & signatures de fichiers

Chaque type de fichier commence par des octets signature en hex (les "magic bytes"). Indispensable en forensics/analyse de malware.

  FF D8 FF        → JPEG
  89 50 4E 47     → PNG  (.PNG)
  50 4B 03 04     → ZIP / JAR / DOCX
  7F 45 4C 46     → ELF  (binaire Linux)
  4D 5A           → MZ   (binaire Windows .exe)
  CA FE BA BE     → Java .class
  25 50 44 46     → PDF  (%PDF)

⌨️ ÉCRIRE ET AFFICHER LES BASES EN C

/* Notation des littéraux */
int dec = 181;           /* décimal   — normal */
int bin = 0b10110101;   /* binaire   — préfixe 0b (GCC extension) */
int hex = 0xB5;          /* hex       — préfixe 0x */
int oct = 0265;          /* octal     — préfixe 0 (attention !) */

/* Afficher en différentes bases avec printf */
printf("%d",  n);   /* décimal   → 181  */
printf("%x",  n);   /* hex       → b5   */
printf("%X",  n);   /* HEX MAJ  → B5   */
printf("%#x", n);   /* hex avec préfixe → 0xb5 */
printf("%o",  n);   /* octal    → 265  */
printf("%08b",n);   /* binaire  → pas natif en C standard */

/* Fonction pour afficher en binaire */
void print_binary(unsigned char n)
{
    int i = 7;
    while (i >= 0)
    {
        putchar((n >> i) & 1 ? '1' : '0');
        i--;
    }
}

En C, 0265 est un octal (= 181 en décimal), PAS 265 ! Un zéro devant = octal. Source de bugs classiques dans les permissions chmod.

🗺️ LA CARTE MENTALE COMPLÈTE

/*
 *  SYSTÈMES        BASE   SYMBOLES          PRÉFIXE C    PRINTF
 *  ────────────────────────────────────────────────────────────
 *  Binaire          2     0-1               0b           custom
 *  Octal            8     0-7               0            %o
 *  Décimal         10     0-9               rien         %d
 *  Hexadécimal     16     0-9 A-F           0x           %x %X
 *
 *  CONVERSIONS RAPIDES
 *  ────────────────────────────────────────────────────────────
 *  Dec → Bin   : divisions successives par 2, lire restes de bas en haut
 *  Dec → Hex   : divisions par 16, ou via binaire (groupes de 4 bits)
 *  Bin → Dec   : somme des poids (2⁰ à 2⁷)
 *  Bin → Hex   : grouper par 4 bits, chaque groupe = 1 chiffre hex
 *  Hex → Bin   : chaque chiffre hex → 4 bits directs
 *
 *  PUISSANCES DE 2 À MÉMORISER
 *  ────────────────────────────────────────────────────────────
 *  2⁰=1  2¹=2  2²=4  2³=8  2⁴=16  2⁵=32  2⁶=64  2⁷=128
 *  2⁸=256  2¹⁰=1024(1K)  2²⁰=1M  2³⁰=1G
 *
 *  OPÉRATEURS BITWISE
 *  ────────────────────────────────────────────────────────────
 *  &  AND  → masquage, test de bits
 *  |  OR   → mise à 1 de bits
 *  ^  XOR  → chiffrement, toggle, swap
 *  ~  NOT  → inversion complète
 *  << SHL  → ×2ⁿ
 *  >> SHR  → ÷2ⁿ
 *
 *  VALEURS CLÉS
 *  ────────────────────────────────────────────────────────────
 *  0xFF   = 255  = 1111 1111 = UINT8 max / masque 8 bits
 *  0x7F   = 127  = 0111 1111 = INT8 max
 *  0x80   = 128  = 1000 0000 = bit de signe (négatif en signed)
 *  0x0F   = 15   = 0000 1111 = masque nibble bas
 *  0xF0   = 240  = 1111 0000 = masque nibble haut
 */