2.

LES CODES BINAIRES

2.1 Introduction
L'action de faire correspondre à des nombres, des lettres ou des mots un groupe spécial de
symboles s'appelle CODAGE et le groupe de symboles s'appelle un CODE. En fait, le binaire
est déjà un codage par rapport au décimal. Nous allons examiner quelques codes que nous
utiliserons plus tard.
2.2 Représentation des nombres
L’écriture d’un nombre peut se faire dans différentes « bases ».
La base 10 ou décimale que nous connaissons tous (10 chiffres de 0 à 9)
La base 2 ou binaire (avec des 2 chiffres 0 et 1)
La base 16 ou hexadécimale (avec 16 chiffres de 0 à 9 et A à F)
La base 16 est très utilisée par exemple pour coder les couleurs dans une page web en html-
CSS ou encore la représentation d’une adresse IP pour la norme V6. Elle a l’avantage d’être
« compacte » à l’écriture.

Base 10 Binaire pur BCD Hexadécimal

0 0000 0000 0000 0
1 0001 0000 0001 1
2 0010 0000 0010 2
3 0011 0000 0011 3
4 0100 0000 0100 4
5 0101 0000 0101 5
6 0110 0000 0110 6
7 0111 0000 0111 7
8 1000 0000 1000 8
9 1001 0000 1001 9
10 1010 0001 0000 A
11 1011 0001 0001 B
12 1100 0001 0010 C
13 1101 0001 0011 D
14 1110 0001 0100 E
15 1111 0001 0101 F
16 10000 0001 0110 10
17 10001 0001 0111 11
18 10010 0001 1000 12
19 10011 0001 1001 13
20 10100 0010 0000 14

2.3 Représentation des entiers relatifs

Plusieurs représentations existent mais on utilisera la notation binaire en complément à 2 qui
permet de réaliser des opérations arithmétiques sans problème.

Dans cette notation, les nombres positifs utilisent le même procédé de représentation que la
notation binaire de la section précédente.
Pour obtenir le codage binaire d'un nombre négatif on procède en commençant par fixer la
taille de l'espace de codage en nombre de bits : par exemple 8, 16 ou 32 bits. Prenons 8 bits
dans le cas présent. Ensuite :
1. on prend la valeur absolue du nombre que l'on code sur 8 bits
2. on complémente chacun des bits (i.e. on remplace les 0 par des 1 et inversement)
3. on ajoute 1 au résultat final
Par exemple, pour représenter (-8)10 :
| -8 | = 8 = 0 0 0 0 1 0 0 0
Complément à 1
11110111
(changement de bits)
Complément à 2 (+1) 1 1 1 1 1 0 0 0

Ainsi le nombre négatif (- 8) est codé sur 8 bits par le nombre binaire 11111000
-1 = 1 1 1 1 1 1 1 1
Soit (-8)10 = 111110002
-2 = 1 1 1 1 1 1 1 0
Autres représentations sur 8 bits : -127 = 1 0 0 0 0 0 0 1
-128 = 1 0 0 0 0 0 0 0
On remarque que tous les nombres négatifs ont leur bit de poids fort à 1, alors que les
nombres positifs ont leur bit de poids fort à 0.

Dans la notation binaire en complément à 2 sur n bits, on peut coder les nombres entre :

-(2n-1) à +(2n-1 - 1)

avec n bits : valeur min valeur max

avec 8 bits : -128 +127
avec 16 bits : -32768 +32767
avec 32 bits : -2.147.483.648 +2.147.483.647

2.4. Représentation des nombres réels (norme IEEE 754)

La norme IEEE 754 (Standard for Binary Floating-Point Arithmetic) définit 4 représentations
de nombres réels (appelés flottants en informatique) :
 simple précision (32 bits)
 double précision (64 bits)
 simple précision étendue (43 bits et plus)
 double précision étendue (79 bits en plus, on utilise 80 bits)

Les nombres sont décomposés en :

 signe
 mantisse (tronquée)
 exposant (décalé)

N = (-1)signe × 2(exposant décalé - 127) × (1,mantisse tronquée2)

Caractéristiques des représentations IEEE 754
Simple Double
Représentation
précision précision
taille (bits) 32 64
signe 1 1
Exposant 8 11
Mantisse 23 52
+/- 38
Echelle 10 10+/- 308
Exemples de représentations :
Valeur Signe Exposant Mantisse Hexadécimal
12,5 0 100.0001.0 100.1000.0000.0000.0000.0000 41.48.00.00
-0,5 1 011.1111.0 000.0000.0000.0000.0000.0000 BF.00.00.00
0.0 0 000.0000.0 000.0000.0000.0000.0000.0000 00.00.00.00

2.4.1 Exemple de conversion

On désire convertir 12,510 en notation IEEE 754 :

 pour la partie entière : 1210 = C16 × 160

 pour la partie décimale : 0,510 = 8 / 16 = 8 × 16-1
 12,510 = C,8 E160
 soit en base 2 : 1100,1000 × 20
 ou encore 1,1001 × 23
 l'exposant est alors calculé suivant la formule : 127 + 3 = 130 (exposant décalé)
 la mantisse devient 1001, le premier 1 étant supprimé car les nombres différents de 0
commencent tous par un 1.

Finalement, on obtient :

S exposant déc. mantisse tronquée

01000001010010000000000000000000
hexadécimal 4 1 4 8 0 0 0 0

2.4.2 Problèmes liés à la représentation IEEE 754

La représentation IEEE 754 peut poser des problèmes de représentation pour certains nombres
après réalisation de calculs. Soit le programme suivant :

v1=1.2
v2=1.3
v3=1.3001
w1=v1-v2
w2=v2-v3
print("w1 = ",w1)
print("w2 = ",w2)
Le résultat en sortie est :
w1 = -0.10000000000000009 (au lieu de 0.1)
w2 = -9.999999999998899e-05 (au lieu de 0.0001)

En outre, pour comparer deux nombres flottants, on n’utilisera pas l'opérateur d'égalité (=)
mais on vérifiera que la valeur absolue de leur différence est inférieure ou égale à un ε donné:

2.5 Caractères (ASCII, Unicode)

Le codage des caractères a été normalisé dès 1968 avec la norme ASCII (American Standard
Code for Information Interchange)

 1968 ASCII (Ansi X3.4, 128 caractères)

 1972 ASCII localisé
 1985 ASCII étendu (ISO-8859-1) : 256 caractères, prise en compte des langues
européennes
 1993 Unicode 1.1 (ISO 10646-1:1993)
 2000 Unicode 3.0 (ISO 10646-1:2000)

Suivant les langages, les chaînes de caractères sont codées différemment :

 en langage C, une chaîne est une suite consécutive d'octets (au format ASCII)
terminée par le caractère '\0',
 en Pascal, une chaîne a une longueur maximum de 255 caractères, car le premier octet
de la chaîne code pour la longueur.

2.5.1 Codage ASCII

Le code ASCII est décomposé en deux tables de 128 caractères :

 caractères 0 à 127 (ASCII américain)

 caractères 128 à 255 (ASCII étendu ou européen) avec caractères accentués

(Remarque : les tables ci-dessus sont issues du site lookuptables).

Les caractères 0 à 31 sont des caractères non imprimables et correspondent à des codes de
contrôle :

 8 = BS = backspace
 13 = CR = Carriage Return
 10 = LF = Line Feed
 27 = ESC = escape

Remarque : sous Windows, la fin de ligne est représentée par CR suivi de LF, alors que sous
Linux seul LF est utilisé. C'est pourquoi lorsque l'on ouvre sous Linux un fichier texte édité
sous Windows on voit apparaître des caractères '^M' qui correspondent à CR.

 Remarque 1 : la valeur 015 est interprétée en octal car elle commence par le chiffre 0
et vaut donc 13 en décimal.
  Remarque 2 : la commande tr -d supprime toute occurrence de CR dans le fichier
passé en entrée et stocke le fichier résultat dans tmp.txt. Taper man tr sous Unix pour
connaître les autres fonctionnalités de tr
 Remarque 3 : on peut également installer les utilitaires dos2unix et unix2dos du
package tofrodos sous Ubuntu par exemple.

2.5.2 Codage Unicode

Le standard Unicode est un mécanisme universel de codage de caractères. Les 256 caractères
du code ASCII ne sont malheureusement pas suffisants pour coder des langues comme
l'arabe, l'hindi, le chinois, le japonais, ... La version 4.1.0 d'Unicode de 2005 permet de coder
245.000 caractères. Les caractères Unicode utilisent 16 ou 32 bits pour stockage.

voir le site suivant pour plus d'informations : unicode.org et le tuteur Unicode.

Remarque : En Java les chaînes de caractères sont codées en utilisant le format UNICODE.

2.6 Espace mémoire occupé par les types de base en

langage C
Espace mémoire occupé par les types de base en C
type / octets 32 bits 64 bits
char 1 1
short int 2 2
int 4 4
long int 4 8
long long int 8 8
float 4 4
double 8 8
void * 4 8

Compétences à acquérir
il faut être capable de :

 coder et décoder des nombres entiers naturels écrits en base 2, 8, 10 ou 16.

 coder et décoder des nombres entiers relatifs en base 2
 réaliser des additions avec des chiffres en base 2
 convertir un nombre réel en sa représentation IEEE 754
Exercices d'entraînement
Exercice 1 : donner la valeur décimale des nombres suivants :

N1 = 1100012 N2 = 4218 N3 = 7F16

N4 = FF16 N5 = FACE16 N6 = CAFE,BAC16

Exercice 2 : convertir les nombres entiers positifs suivants en base 2, 8 et 16 :

M1 = 11 M2 = 23 M3 = 127
M4 = 160 M5 = 511 M6 = 1024

Exercice 3 : convertir les nombres entiers négatifs suivants en notation binaire en

complément à 2 en utilisant une représentation sur 8 bits :

K1 = – 11 K2 = – 23 K3 = – 160 K4 = – 123

Exercice 4 : convertir les nombres réels suivants en notation IEEE 754 sur 32 bits :

Q1 = 121,125 Q2 = 98,625 Q3 = 1,046875 Q4 = 0,1

Exercices de programmation
Exercice 6 : écrire un programme en langage C qui prend en paramètre un nombre réel et
donne sa représentation binaire au format IEEE 754.