Entier (informatique)

Pour les articles homonymes, voir Entier.

En informatique, un entier est un type de donnée qui représente un sous-ensemble fini de nombres entiers relatifs. On utilise aussi le terme type de données entières (integral type data). Un type de donnée est la nature des valeurs que peut prendre une donnée.

## Historique[modifier | modifier le code]

Certains traitements comme le recensement des États-Unis ont d'abord été effectués en utilisant une représentation décimale à l'aide de cartes perforées[1]. Le système décimal utilise dix chiffres (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) et où leur position correspond à une puissance de 10 (1, 10, 100, 1000, etc.).

Le développement de l'informatique a ensuite conduit à l'utilisation de la représentation binaire des entiers, mais aussi de la représentation décimale, où chaque chiffre de 0 à 9 est codé en binaire (voir Binary coded decimal, IBM 1620). Autrement dit, on représente chacun des dix chiffres en binaire (sur 4 bits) pour implémenter l'arithmétique décimale.

## Représentation binaire[modifier | modifier le code]

Un ordinateur moderne utilise des tensions électriques pour gérer ses données. En théorie, plusieurs tensions pourraient être utilisées pour représenter une information[réf. nécessaire], mais en pratique on en n’utilise que deux. En effet, des problèmes de distorsion apparaitraient et empêcheraient de conserver l'information. De plus, les avancées technologiques tendent à réduire la tension afin d'éviter de chauffer les matériaux[réf. nécessaire]. On utilise donc deux niveaux de tension, un bit prend alors 2 valeurs qui correspondent à 0 et 1.

La représentation des nombres passe donc par une représentation binaire (à l'aide des chiffres 0 et 1). Il est possible d'utiliser le système binaire, une numération de position qui n'utilise que deux chiffres (0 et 1) et où chaque bit correspond à une puissance de 2 (1, 2, 4, 8, 16, 32, 64, etc.). C'est la représentation utilisée pour les entiers machines des processeurs modernes.

### Nombres de bits fixés[modifier | modifier le code]

Les types de données entiers usuels des langages de programmation utilisent la représentation binaire. Ils peuvent être de taille (nombre de bits) bornée : si elle est de n bits, elle permet de représenter

* soit les entiers naturels de 0 à 2n \- 1 (entier non signé),
* soit les entiers relatifs de -2n \- 1 à 2n \- 1 \- 1 (entier signé).

Dans les deux cas l'arithmétique utilisée est (le plus souvent) l'arithmétique modulo 2n, c'est-à-dire que du point de vue de l'arithmétique usuelle, elle est exacte tant que les opérations ne débordent pas de l'intervalle considéré. Sur les processeurs courants, elle est particulièrement efficace quand la taille du type de donnée correspond à celle des mots gérés nativement par le processeur, de par la conception de celui-ci.

### Nombres de bits arbitraires[modifier | modifier le code]

Les langages de programmation peuvent éventuellement gérer des entiers de taille arbitraire, il n'y a pas de limite autre que celles physiques liée à la machine utilisée, l'arithmétique est exacte : la place mémoire allouée à la représentation d'un entier n'est pas constante, et peut augmenter en fonction des besoins du calcul.

## Types d'entiers courants[modifier | modifier le code]

Bits  | Nom  | Intervalle (en supposant un complément à deux pour les signés)  | Nombre de chiffres en décimal  | Usages

|
|
|
|

4  | nibble, semioctet ou quartet  | Signé : De -8 à 7, soit de  − ( 2 3 ) {\displaystyle -(2^{3})} à  2 3 − 1 {\displaystyle 2^{3}-1} | 1  | Décimal codé binaire, single decimal kamal digit representation.
Non-signé : De 0 à 15 soit  2 4 − 1 {\displaystyle 2^{4}-1} | 2
8  | byte, octet | Signé : De -128 à 127, soit de  − ( 2 7 ) {\displaystyle -(2^{7})} à  2 7 − 1 {\displaystyle 2^{7}-1} | 3  | caractères ASCII , C/C++ char, C/C++ uint8_t, int8_t, C# byte, sbyte, T-SQL tinyint, Delphi Byte, Shortint, Java byte
Non-signé : De 0 à 255 soit  2 8 − 1 {\displaystyle 2^{8}-1} | 3
16  | halfword, word, short | Signé : De -32 768 à 32 767, soit de  − ( 2 15 ) {\displaystyle -(2^{15})} à  2 15 − 1 {\displaystyle 2^{15}-1} | 5  | caractères UCS-2, short en C/C++, C/C++ int (minimum), C/C++ uint16_t, int16_t, C# short, ushort, Delphi Word, Smallint, T-SQL smallint, Java char/short
Non-signé : De 0 à 65 535 soit  2 16 − 1 {\displaystyle 2^{16}-1} | 5
32  | I4, word, long, doubleword, longword, int  | Signé : De -2 147 483 648 à 2 147 483 647, soit de  − ( 2 31 ) {\displaystyle -(2^{31})} à  2 31 − 1 {\displaystyle 2^{31}-1} | 10  | caractères UCS-4, Truecolor avec alpha, C/C++ int (avec certains compilateurs, 32 et 64 bit)[2], C/C++ long (sur Windows et DOS 32-bit et Unix), C/C++ uint32_t, int32_t, C# int, uint, FourCC, Delphi Cardinal, Integer, LongWord, LongInt, T-SQL int, Java int
Non-signé : De 0 à 4 294 967 295 soit  2 32 − 1 {\displaystyle 2^{32}-1} | 10
64  | I8, doubleword, longword, long long, quad, quadword, int64  | Signé : De -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807, soit de  − ( 2 63 ) {\displaystyle -(2^{63})} à  2 63 − 1 {\displaystyle 2^{63}-1} | 19  | C/C++ long, C/C++ long long, C/C++ uint64_t, int64_t, C# long, ulong, Delphi Int64, T-SQL bigint, Java long
Non-signé : De 0 à 18 446 744 073 709 551 615 soit  2 64 − 1 {\displaystyle 2^{64}-1} | 20
128  | octaword, double quadword  | Signé : De -170 141 183 460 469 231 731 687 303 715 884 105 728 à 170 141 183 460 469 231 731 687 303 715 884 105 727, soit de  − ( 2 127 ) {\displaystyle -(2^{127})} à  2 127 − 1 {\displaystyle 2^{127}-1} | 39  | Disponible en C via certains compilateurs, en non-standard. Disponible en Fortran en standard (gnu, intel par ex.).
Non-signé : De 0 à 340 282 366 920 938 463 463 374 607 431 768 211 455 soit  2 128 − 1 {\displaystyle 2^{128}-1} | 39
n | n-bit integer
(cas général)  | Signé : De  ( − 2 n − 1 ) {\displaystyle (-2^{n-1})} à  ( 2 n − 1 − 1 ) {\displaystyle (2^{n-1}-1)} |  ⌈ ( n − 1 ) log 10 ⁡ 2 ⌉ {\displaystyle \lceil (n-1)\log _{10}{2}\rceil } | Ada `range -2**(n-1)..2**(n-1)-1`
Non-signé : De 0 à  ( 2 n − 1 ) {\displaystyle (2^{n}-1)} |  ⌈ n log 10 ⁡ 2 ⌉ {\displaystyle \lceil n\log _{10}{2}\rceil } | Ada `range 0..2**n-1`, Ada `mod 2**n`
? | bignum  | entier de précision arbitraire  | infini  | Tous usages, avec quelques pertes de performances. Langages: Python, Perl, Haskell, Ruby…

## Voir aussi[modifier | modifier le code]

* Arithmétique binaire

### Références[modifier | modifier le code]

1. ↑ (en) « Arncom », sur arnakazim.com (consulté le 12 octobre 2023).
2. ↑ "On compilers for 32 bit and larger processors (including Intel x86 processors executing in 32 bit mode, such as Win32 or Linux) an int is usually 32 bits long and has exactly the same representation as a long." The Int Types Jack Klein, Integer Types In C and C++, http://jk-technology.com/c/inttypes.html (c) 2008

v · m

Types de données

Non interprétée |

* Bit
* Byte
* Trit
* Tryte
* Mot

Numérique |

* Bignum
* Complexe (en)
* Décimal (en)
* Virgule fixe
* Virgule flottante
* Entier
* Non signé (en)
* Intervalle
* Rationnel (en)

Texte brut |

* Caractère
* Chaîne de caractères

Pointeur |

* Adressage mémoire
* Physique
* Virtuelle
* Référence

Composite (en) |

* Type algébrique de données
* Généralisé
* Tableau
* Tableau associatif
* Classe
* Dépendant
* Égalité (en)
* Inductive (en)
* Liste
* Objet
* Métaobjet
* Option (en)
* Produit
* Enregistrement
* Ensemble (set)
* Vecteur
* Union (en)
* Disjointe

Autres |

* Booléen
* Type vide
* Collection
* Conteneur
* Type énuméré
* Exception
* Fonction
* Opaque (en)
* Type récursif
* Sémaphore
* Flux
* Top (en)
* Type class (en)
* Type unité
* Void

Articles liés |

* Type abstrait
* Structure de données
* Généricité
* Kind (en)
* Métaclasse
* Parametric polymorphism (en)
* Primitive data type (en)
* Interface
* Subtyping (en)
* Type constructor (en)
* Conversion de type
* Type system (en)

* Portail de la programmation informatique

*[(en)]: Langue : anglais
*[v]: Voir ce modèle.
*[m]: Modifier ce modèle. Merci de prévisualiser avant de sauvegarder.