Pour dénombrer quelque chose, nous avons pour habitude d’utiliser les dix chiffres que sont 0,1,2,3,4,5,6,7,8,9. Ce n’a pas toujours été le cas : les Babyloniens utilisaient 60 chiffres (qu’ils représentaient à l’aide de deux symboles, le clou et le chevron), les Mayas comptaient avec 20 chiffres et disposaient du 0...
Nos ordinateurs, eux, n’utilisent que 2 chiffres. Comment font-ils ?
Le système décimal est un système de numération en base 10 : tout nombre se décompose en puissances de 10. Le chiffre le plus à droite est appelé chiffre des unités, celui à sa droite chiffre des dizaines, etc...
Il est essentiel de bien comprendre que le système de numération décimal est positionnel : cela signifie que la position (ou le rang) d’un chiffre est importante dans l’écriture d’un nombre, et qu’elle détermine son poids et sa valeur, définis par : $$ \text{Poids} = ~\text{Base}^\text{Rang} \hspace{1cm} \text{Valeur} = ~\text{Chiffre} \times \text{Poids}$$
Le nombre 5173 se décompose sans surprise en $5000 + 100 + 70 + 3 = 5 \times 10^3 + 1 \times 10^2 + 7 \times 10^1 + 3 \times 10^0$.
Le système binaire est un système de numération en base 2. Cela signifie que :
En décimal, on fait des « paquets de 10 » (1, 10, 100, 1000, ...) alors qu'en binaire, on fait des « paquets de 2 » (1, 2, 4, 8, 16, ...). Commençons à compter :
| Valeur décimale | Valeur binaire |
|---|---|
| 0 | 0 |
| 1 | 1 |
| 2 | 10 |
| 3 | 11 |
| 4 | 100 |
| 5 | 101 |
| 6 | 110 |
En base 10, on ne peut dépasser le chiffre 9 : on revient alors à 0, et on incrémente le chiffre de rang supérieur.
En base 2, la règle est identique : il est impossible de dépasser 1, alors si c’est le cas, on revient à 0 et on incrémente le chiffre de rang supérieur.
| Valeur décimale | Valeur binaire |
|---|---|
| 7 | 111 |
| 8 | 1000 |
| 9 | 1001 |
| 10 | 1010 |
Pour écrire le nombre 26 en binaire, on ne continue pas à remplir le tableau précédent : on raisonne en puissances de 2. Les premières puissances de 2 sont à connaître par coeur !
| $n$ | 0 | 1 | 2 | 3 | 4 | 5 |
| $2^n$ | 1 | 2 | 4 | 8 | 16 | 32 |
La méthode est la suivante :
| $n$ | 4 | 3 | 2 | 1 | 0 |
| $2^n$ | 16 | 8 | 4 | 2 | 1 |
| 27 | 1 | 1 | 0 | 1 | 0 |
On peut donc écrire $26 = (11010)_2$.
Pour convertir un nombre en binaire, on peut utiliser la méthode suivante, qui est une méthode algorithmique : il est facile d’en faire un algorithme et de le programmer sur un ordinateur. On réalise des divisions successives par 2 du nombre à convertir, jusqu’à trouver un quotient nul. On lit ensuite la liste des restes de bas en haut. Exemple avec 42 :
On a donc $42 = (101010)_2$.
Passer du binaire au décimal n’a rien de compliqué. Il suffit de se rappeler que chaque bit compte pour une puissance de 2, et que seules les puissances de 2 dont le bit est égal à 1 sont comptabilisées.
Prenons le nombre $(1010~1101)_2$. On peut s’aider d’un tableau :
| Nombre | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 1 |
| Rang | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
| Puissance de 2 | $2^7$ | $2^6$ | $2^5$ | $2^4$ | $2^3$ | $2^2$ | $2^1$ | $2^0$ |
| Valeurs | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
On a donc $(1010~1101)_2$ = 1$\times 2^7$ + 0$\times 2^6$ + 1$\times 2^5$ + 0$\times 2^4$ + 1$\times 2^3$ + 1$\times 2^2$ + 0$\times 2^1$ + 1$\times 2^0$ = 128 + 32 + 8 + 4 + 1 = 173.
Avec 8 bits : $(1111~1111)_2$ = 255
Avec 16 bits : $(1111~1111~1111~1111)_2$ = 65 535
Pour calculer rapidement ces valeurs, il suffit de considérer le nombre entier suivant, par exemple $(1~0000~0000)_2 = 2^8 = 256$. La valeur précédente est $(1111~1111)_2 = 255$.
Un octet est un nombre binaire de 8 bits. En anglais, octet se dit byte (à ne pas confondre avec bit... !).
L’octet est l’unité de mémoire de l’informatique.
Un octet permet de représenter $2^8$ = 256 nombres différents : de 0 à 255 = $(1111~1111)_2$. Imaginons un instant la chose suivante : à chaque lettre minuscule et majuscule de l’alphabet, on attribue un nombre. On attribue également un nombre aux différents signesde ponctuations, ainsi qu’aux lettres accentuées... et aussi aux chiffres ! En tout, cela fait moins de 256 caractères.
À l’aide d’un octet, on peut donc représenter n’importe quelle lettre de notre clavier d’ordinateur.
Bon, en réalité, c’est un peu plus compliqué que ça, mais l’idée est là. C’est ce que l’on appelle l’encodage des caractères. Nous y reviendrons dans un prochain chapitre.
Le système héxadécimal est un système de numération en base 16. Ainsi :
Compter en « paquets de 16 » est un peu plus compliqué, du fait de la taille des paquets : 1, 16, 256, 4096, ...
Mais comment obtenir 16 chiffres ? C’est simple :
| Valeur décimale | Valeur héxadécimale |
|---|---|
| 0 | 0 |
| 1 | 1 |
| 2 | 2 |
| 3 | 3 |
| 4 | 4 |
| 5 | 5 |
| 6 | 6 |
| 7 | 7 |
| 8 | 8 |
| 9 | 9 |
| 10 | A |
| 11 | B |
| 12 | C |
| 13 | D |
| 14 | E |
| 15 | F |
Au delà, on fait un paquet de 16 :
| Valeur décimale | Valeur héxadécimale |
|---|---|
| 15 | F |
| 16 | (10)$_{16}$ |
| 17 | (11)$_{16}$ |
| 18 | (12)$_{16}$ |
| 19 | (13)$_{16}$ |
Au delà de 31, on fait 2 paquets de 16 :
| Valeur décimale | Valeur héxadécimale |
|---|---|
| 31 | (1F)$_{16}$ |
| 32 | (20)$_{16}$ |
| 33 | (21)$_{16}$ |
| 34 | (22)$_{16}$ |
| 35 | (23)$_{16}$ |
À partir de 255 = (FF)$_{16}$, on commence à faire des paquets de 256 !
| Valeur décimale | Valeur héxadécimale |
|---|---|
| 255 | (FF)$_{16}$ |
| 256 | (100)$_{16}$ |
| 257 | (101)$_{16}$ |
| 258 | (102)$_{16}$ |
| 259 | (103)$_{16}$ |
La méthode est analogue à la conversion binaire : on utilise les divisions successives par 16 (et non plus par 2). C'est généralement plus difficile car la table de 16 est plus compliquée que la table de 2, mais souvent plus rapide.
Dans l'exemple ci-dessus, on a 42 = (2A)$_{16}$ : 10 s'écrit A en héxadécimal !