Aller au contenu
Encyclopédie informatique Édition 2026

Variables et types de données

Partie 3 sur 5

Niveau de lecture :

6Les types de données

Les données manipulées par un langage sont typées : pour chaque donnée que l’on utilise (dans les variables par exemple), il faut préciser le type de donnée, ce qui permet de connaître l’occupation mémoire (le nombre d’octets) de la donnée ainsi que sa représentation. Les grandes familles sont les mêmes partout :

  • les nombres entiers (int) : sans virgule ;
  • les nombres à virgule flottante (float, double) : les « réels » ;
  • les caractères (char) : une lettre, un chiffre, un symbole ;
  • les booléens : vrai ou faux ;
  • les pointeurs (en anglais pointers) : ils permettent de stocker l’adresse d’une autre donnée et « pointent » vers elle (voir le langage C) ;
  • les textes et les tableaux, vus plus loin, qui rassemblent plusieurs valeurs.

Un type est dit primitif quand il est fourni de base par le langage et correspond directement à une représentation en mémoire (les entiers, les flottants, les caractères, les booléens). Il s’oppose aux types composés, que le programmeur construit en assemblant d’autres types (tableaux, structures, classes).

6.1Les types du C

En C, il existe plusieurs types entiers, dépendant du nombre d’octets sur lesquels ils sont codés et de leur format, c’est-à-dire de leur caractère signé (possédant le signe « − » ou « + ») ou non signé (unsigned). Par défaut les données sont signées. Le tableau 1 donne les types usuels.

Tableau 1. Les types de données du langage C (valeurs usuelles ; les tailles varient avec la machine).
TypeSignificationTaille (octets)Plage de valeurs
charCaractère1−128 à 127
unsigned charCaractère non signé10 à 255
short intEntier court2−32 768 à 32 767
unsigned short intEntier court non signé20 à 65 535
intEntier2 (processeur 16 bits), 4 (32 bits)−32 768 à 32 767 ; −2 147 483 648 à 2 147 483 647
unsigned intEntier non signé2 ou 40 à 65 535 ; 0 à 4 294 967 295
long intEntier long4−2 147 483 648 à 2 147 483 647
unsigned long intEntier long non signé40 à 4 294 967 295
floatFlottant (réel)43,4×10−38 à 3,4×1038
doubleFlottant double81,7×10−308 à 1,7×10308
long doubleFlottant double long103,4×10−4932 à 3,4×104932

Une précision actuelle : les tailles ne sont pas figées par le langage. La taille d’un int dépend du processeur et du compilateur ; sur les ordinateurs de 64 bits, un long fait souvent 8 octets (sous Linux) ou 4 (sous Windows). C’est pourquoi les programmes portables utilisent aujourd’hui des types à taille fixe, comme int32_t (32 bits exactement) ou uint8_t (un octet non signé), définis par la norme depuis 1999. Autre précision : la valeur de char sans autre précision peut être signée ou non selon la machine.

6.2Ce qu’ajoute le C++ : le booléen

Le C++ introduit, par rapport au C, un nouveau type appelé bool. Cette variable accepte deux états : true (vrai), correspondant à la valeur 1, et false (faux), correspondant à la valeur 0. On fait remarquer que ce type étant codé sur 8 bits (un octet), 7 de ces bits ne servent à rien, puisqu’une variable de ce type ne peut prendre que deux états. En réalité, toutes les valeurs différentes de zéro sont considérées comme vraies, donc comme égales à 1 : 5 vaut « vrai ». Le tableau du C++ reprend celui du C, avec une ligne bool de plus (« même taille que le type int, parfois 1 sur quelques compilateurs »).

6.3Les primitives du Java

Java est un langage orienté objet (voir la programmation orientée objet), c’est-à-dire que les éléments manipulés sont des classes, ou plus exactement des objets, des instances de classes. Toutefois, ces objets contiennent des données possédant un type et une représentation : des éléments stockés en mémoire et baptisés pour l’occasion primitives. Java introduit un type boolean, à deux états : true et false. Contrairement au C, il ne tolère pas qu’un entier tienne lieu de booléen. Le tableau 2 donne les huit primitives.

Tableau 2. Les primitives de Java (identiques sur toutes les machines).
PrimitiveSignificationTaille (octets)Plage de valeurs
charCaractère2caractère Unicode (environ 65 000 possibles)
byteEntier très court1−128 à 127
shortEntier court2−32 768 à 32 767
intEntier4−2 147 483 648 à 2 147 483 647
longEntier long8−9 223 372 036 854 775 808 à 9 223 372 036 854 775 807
floatFlottant (réel)4−1,4×10−45 à 3,4×1038
doubleFlottant double84,9×10−324 à 1,7×10308
booleanBooléen1true ou false

La grande différence avec le C est la taille fixe : un int Java fait toujours 4 octets, quelle que soit la machine, ce qui fait la portabilité du langage. Le char Java occupe deux octets, car il stocke un caractère Unicode (voir les caractères) : il peut donc contenir une lettre accentuée. Il existe aussi une valeur par défaut : une variable booléenne non initialisée vaut false (pour les champs d’un objet).

Les enveloppeurs

Les primitives peuvent être « enveloppées » dans un objet provenant d’une classe prévue à cet effet et appelée wrapper (mot anglais signifiant enveloppeur). Les enveloppeurs sont donc des objets pouvant contenir une primitive et auxquels sont associées des méthodes permettant de les manipuler. La liste : Character pour char, Byte, Short, Integer, Long, Float, Double, Boolean pour leurs primitives, et Void pour void. Deux classes n’ont aucune primitive associée : BigInteger et BigDecimal, qui peuvent contenir des valeurs entières ou décimales de précision quelconque, ce que ne permet aucune primitive. Ce sont les outils des calculs financiers, où l’on ne tolère pas d’arrondi (partie 7.4). Depuis la version 5 du langage (2004), Java convertit automatiquement une primitive en enveloppeur et inversement (autoboxing), ce qui a ses pièges : comparer deux enveloppeurs avec « == » compare des objets, pas des valeurs.

7Les nombres dans la machine

7.1Les entiers et leurs bases

Un nombre entier (int) est un nombre sans virgule, qui peut être exprimé dans différentes bases. En base décimale, l’entier est représenté par une suite de chiffres de 0 à 9, ne devant pas commencer par le chiffre 0. En base hexadécimale (base seize), il est représenté par une suite d’unités de 0 à 9 ou de A à F (ou a à f), devant commencer par 0x ou 0X : 0x1F vaut 31 (voir le binaire et l’hexadécimal). En base octale (base huit), il est représenté par des chiffres de 0 à 7, devant commencer par 0 : 017 vaut 15, un piège classique, car un zéro devant un nombre en change le sens ! Les langages récents ajoutent le préfixe 0b pour le binaire (0b1010 vaut 10) et acceptent un séparateur pour la lisibilité (1_000_000).

Le complément à deux

Les entiers sont signés par défaut : ils comportent un signe. Pour stocker l’information concernant le signe, les ordinateurs utilisent le complément à deux. Le principe : sur 8 bits, les nombres de 0 à 127 s’écrivent normalement ; pour un nombre négatif, on inverse tous les bits de sa valeur absolue puis on ajoute 1. Ainsi, −1 s’écrit 11111111, −2 s’écrit 11111110, et le plus petit nombre est −128 (10000000). Le premier bit sert donc de bit de signe : 0 pour positif, 1 pour négatif. L’intérêt est qu’une même circuit d’addition fonctionne pour les nombres positifs et négatifs. Cela explique les plages du tableau 1 : sur n bits, un entier signé va de −2n−1 à 2n−1 − 1 (de −128 à 127 sur 8 bits), un non signé de 0 à 2n − 1 (de 0 à 255).

Le débordement

Que se passe-t-il si l’on dépasse la plage ? Ajoutez 1 à 127 dans un entier signé de 8 bits : le résultat « tourne » et donne −128, comme un compteur kilométrique qui repasse à zéro. C’est le débordement d’entier (integer overflow). Il ne provoque en C aucune erreur visible, et reste une source de bogues et de failles de sécurité (partie 12). Certains langages le détectent (Rust en mode de développement, Swift), d’autres le contournent par des entiers de taille illimitée (Python).

7.2Les nombres à virgule flottante

Un nombre à virgule flottante peut être représenté de différentes façons dans le code : un entier décimal (895), un nombre comportant un point et non une virgule (845.32), ou un nombre exponentiel, c’est-à-dire un nombre éventuellement à virgule suivi de la lettre e (ou E), puis d’un entier correspondant à la puissance de 10, signé ou non : 2.75e-2 vaut 0,0275, 35.8E+10 vaut 358 milliards, .25e-2 vaut 0,0025. On cite parfois aussi « une fraction : 27/11 », mais celle-ci est en réalité un calcul que l’on écrit dans le programme, et qui, entre entiers, donne en C et en Java une division entière (2 et non 2,4545…) : un piège à connaître.

En réalité, les nombres réels sont des nombres à virgule flottante : la position de la virgule n’est pas fixe, elle est repérée par une partie des bits, l’exposant. Le reste des bits code le nombre sans virgule, la mantisse. C’est la « notation scientifique » de la machine : 6,02 × 1023 a une mantisse (6,02) et un exposant (23). Les nombres de type float sont codés sur 32 bits dont 23 bits pour la mantisse, 8 bits pour l’exposant et 1 bit pour le signe. Les double sont codés sur 64 bits dont 52 pour la mantisse, 11 pour l’exposant et 1 pour le signe. Les long double (non standardisés) sont codés sur 80 bits dont 64 bits pour la mantisse, 15 pour l’exposant et 1 pour le signe. Ces formats sont ceux de la norme IEEE 754, que presque tous les processeurs appliquent.

La précision des nombres réels est approchée. Elle dépend du nombre de positions décimales : suivant le type de réel, elle sera au moins de 6 chiffres pour le type float, de 15 chiffres pour le type double et de 17 chiffres pour le type long double. (On dit parfois « chiffres après la virgule » : il s’agit en fait de chiffres significatifs au total.)

7.3Pourquoi 0,1 + 0,2 n’est pas 0,3

La précision approchée a une conséquence que tout programmeur finit par rencontrer. En binaire, le nombre 0,1 n’a pas d’écriture finie, comme 1/3 n’en a pas en décimal (0,3333…). La machine en garde la meilleure approximation, légèrement fausse. Quand on additionne 0,1 et 0,2, on obtient 0,30000000000000004, et non 0,3 : le test « 0,1 + 0,2 == 0,3 » est faux dans presque tous les langages. La parade est de ne jamais comparer deux flottants par l’égalité exacte, mais de vérifier que leur différence est très petite.

Autre conséquence : à partir d’une certaine taille, le flottant ne distingue plus deux entiers voisins, et un float ne peut représenter exactement tous les entiers au-delà de 16 777 216 (224). Un cas célèbre est le missile Patriot de la guerre du Golfe, dont l’horloge, mal convertie en nombre à virgule, a accumulé une erreur d’un tiers de seconde en cent heures (voir les anecdotes).

7.4L’argent : ne pas utiliser de flottants

Pour les montants d’argent, on évite les flottants, précisément à cause de ces approximations. Deux solutions : stocker les centimes en entiers (12,34 euros sont 1 234 centimes), ou employer un type décimal exact (BigDecimal en Java, decimal en C#, Decimal en Python). C’est la raison d’être des deux classes d’enveloppeurs de précision quelconque mentionnées plus haut.

Pour s’exercer

Exercice 4 : plages de valeurs

Quelle est la plage d’un entier signé sur 8 bits ? Sur 16 bits ? D’un entier non signé sur 16 bits ? Que se passe-t-il quand on ajoute 1 à 127 dans un entier signé de 8 bits ?

Voir la réponse

Signé 8 bits : de −128 à 127 (de −27 à 27 − 1). Signé 16 bits : de −32 768 à 32 767. Non signé 16 bits : de 0 à 65 535 (216 − 1). 127 + 1 déborde : en complément à deux, le résultat « tourne » et donne −128.

Exercice 5 : le complément à deux

Écrivez −5 sur 8 bits en complément à deux. Vérifiez en ajoutant 5.

Voir la réponse

5 s’écrit 00000101. On inverse tous les bits : 11111010. On ajoute 1 : 11111011. C’est −5. Vérification : 11111011 + 00000101 = 100000000 ; le neuvième bit est abandonné, il reste 00000000, soit 0. Donc 11111011 est bien l’opposé de 5.