Type de données primitif - Primitive data type

En informatique , le type de données primitif est l'un des suivants :

  • un type de base est un type de données fourni par un langage de programmation en tant que bloc de construction de base. La plupart des langages permettent de construire récursivement des types composites plus compliqués à partir de types de base.
  • un type intégré est un type de données pour lequel le langage de programmation fournit une prise en charge intégrée.

Dans la plupart des langages de programmation, tous les types de données de base sont intégrés. De plus, de nombreux langages fournissent également un ensemble de types de données composites.

Selon le langage et son implémentation, les types de données primitifs peuvent ou non avoir une correspondance un à un avec les objets dans la mémoire de l'ordinateur. Cependant, on s'attend généralement à ce que les opérations sur les types de données primitifs de base soient les constructions de langage les plus rapides qui soient. L'addition d'entiers, par exemple, peut être effectuée comme une seule instruction machine, et certains processeurs proposent des instructions spécifiques pour traiter des séquences de caractères avec une seule instruction. En particulier, la norme C mentionne qu'"un objet int 'plain' a la taille naturelle suggérée par l'architecture de l'environnement d'exécution". Cela signifie qu'il intest susceptible d'être long de 32 bits sur une architecture 32 bits. Les types primitifs de base sont presque toujours des types valeur .

La plupart des langages ne permettent pas que le comportement ou les capacités des types de données primitifs (intégrés ou basiques) soient modifiés par les programmes. Les exceptions incluent Smalltalk , qui permet à tous les types de données d'être étendus dans un programme, en ajoutant aux opérations qui peuvent être effectuées sur eux ou même en redéfinissant les opérations intégrées.

Aperçu

La gamme réelle de types de données primitifs disponibles dépend du langage de programmation spécifique utilisé. Par exemple, en C# , les chaînes sont un type de données composite mais intégré, alors que dans les dialectes modernes de BASIC et en JavaScript , elles sont assimilées à un type de données primitif à la fois basique et intégré.

Les types primitifs de base classiques peuvent inclure :

Les primitives ci-dessus sont généralement supportées plus ou moins directement par le matériel informatique, sauf peut-être pour la virgule flottante, donc les opérations sur de telles primitives sont généralement assez efficaces. Certains langages de programmation prennent en charge les chaînes de texte en tant que primitive (par exemple BASIC) tandis que d'autres traitent une chaîne de texte comme un tableau de caractères (par exemple C). Certains matériels informatiques (par exemple x86) ont des instructions qui aident à gérer les chaînes de texte, mais la prise en charge matérielle complète des chaînes de texte est rare.

Les chaînes peuvent être n'importe quelle série de caractères dans l' encodage utilisé . Pour séparer les chaînes du code, la plupart des langages les entourent de guillemets simples ou doubles. Par exemple "Hello World" ou "Hello World". Notez que "200" peut être confondu avec un type entier mais est en fait un type chaîne car il est contenu entre guillemets doubles.

Les types plus sophistiqués qui peuvent être intégrés incluent :

Types de données primitifs spécifiques

Nombres entiers

Un type de données entier représente une plage d'entiers mathématiques . Les entiers peuvent être signés (autorisant les valeurs négatives) ou non signés ( entiers non négatifs uniquement). Les plages courantes sont :

Taille ( octets ) Taille ( bits ) Noms Plage signée (en supposant un complément à deux pour signé ) Gamme non signée
1 octet 8 bits Octet , octet , taille minimale de charen C99 ( voir bounds.h CHAR_BIT) -128 à +127 0 à 255
2 octets 16 bits mot x86 , taille minimale de shortet inten C −32 768 à +32 767 0 à 65 535
4 octets 32 bits x86 double mot, taille minimale de longen C, taille réelle de intpour la plupart des compilateurs C modernes, pointeur pour les processeurs compatibles IA-32 −2 147 483 648 à +2 147 483 647 0 à 4 294 967 295
8 octets 64 bits quadruple mot x86, taille minimale de long longen C, taille réelle de longpour la plupart des compilateurs C modernes, pointeur pour les processeurs compatibles x86-64 −9 223 372 036 854 775 808 à +9 223 372 036 854 775 807 0 à 18 446 744 073 709 551 615
illimité/8 illimité Bignum –2 illimité /2 à +(2 illimité /2 − 1) 0 à 2 illimité − 1

Les littéraux des nombres entiers peuvent être écrits sous forme de chiffres arabes réguliers , constitués d'une séquence de chiffres et dont la négation est indiquée par un signe moins avant la valeur. Cependant, la plupart des langages de programmation interdisent l'utilisation de virgules ou d'espaces pour le regroupement de chiffres . Exemples de littéraux entiers :

  • 42
  • 10000
  • -233000

Il existe plusieurs méthodes alternatives pour écrire des littéraux entiers dans de nombreux langages de programmation :

  • La plupart des langages de programmation, en particulier ceux influencés par C , préfixent un littéral entier avec 0X ou 0x pour représenter une valeur hexadécimale , par exemple 0xDEADBEEF . D'autres langages peuvent utiliser une notation différente, par exemple certains langages d'assemblage ajoutent un H ou un h à la fin d'une valeur hexadécimale.
  • Perl , Ruby , Java , Julia , D , Rust et Python (à partir de la version 3.6) autorisent les traits de soulignement intégrés pour plus de clarté, par exemple 10_000_000 , et le Fortran de forme fixe ignore les espaces intégrés dans les littéraux entiers.
  • En C et C++ , un zéro non significatif indique une valeur octale , par exemple 0755 . Ceci était principalement destiné à être utilisé avec les modes Unix ; cependant, il a été critiqué parce que les entiers normaux peuvent également mener avec zéro. En tant que tels, Python , Ruby , Haskell et OCaml préfixent les valeurs octales avec 0O ou 0o , en suivant la disposition utilisée par les valeurs hexadécimales.
  • Plusieurs langages, dont Java , C# , Scala , Python , Ruby et OCaml , peuvent représenter des valeurs binaires en préfixant un nombre avec 0B ou 0b .

Nombres à virgule flottante

Un nombre à virgule flottante représente un nombre rationnel à précision limitée qui peut avoir une partie fractionnaire. Ces nombres sont stockés en interne dans un format équivalent à la notation scientifique , typiquement en binaire mais parfois en décimal . Comme les nombres à virgule flottante ont une précision limitée, seul un sous-ensemble de nombres réels ou rationnels est exactement représentable ; d'autres nombres ne peuvent être représentés qu'approximativement.

De nombreux langages ont à la fois un type simple précision (souvent appelé "float") et un type double précision .

Les littéraux pour les nombres à virgule flottante incluent un point décimal et utilisent généralement e ou E pour désigner la notation scientifique. Voici des exemples de littéraux à virgule flottante :

  • 20.0005
  • 99,9
  • -5000.12
  • 6.02e23

Certains langages (par exemple, Fortran , Python , D ) ont également un type de nombre complexe comprenant deux nombres à virgule flottante : une partie réelle et une partie imaginaire.

Nombres à virgule fixe

Un nombre à virgule fixe représente un nombre rationnel à précision limitée qui peut avoir une partie fractionnaire. Ces nombres sont stockés en interne sous forme d'entier mis à l'échelle, généralement en binaire mais parfois en décimal . Comme les nombres à virgule fixe ont une précision limitée, seul un sous-ensemble de nombres réels ou rationnels est exactement représentable ; d'autres nombres ne peuvent être représentés qu'approximativement. Les nombres à virgule fixe ont également tendance à avoir une plage de valeurs plus limitée que la virgule flottante , et le programmeur doit donc faire attention à éviter tout débordement dans les calculs intermédiaires ainsi que dans le résultat final.

Booléens

Un type booléen , généralement noté « bool » ou « booléen », est généralement un type logique qui peut avoir la valeur « true » ou la valeur « faux ». Bien qu'un seul bit soit nécessaire pour prendre en charge les valeurs définies "true" et "false", les langages de programmation implémentent généralement des types booléens sur un ou plusieurs octets.

De nombreux langages (par exemple Java , Pascal et Ada ) implémentent des booléens adhérant au concept de booléen en tant que type logique distinct. Les langages, cependant, peuvent parfois convertir implicitement des booléens en types numériques pour donner une sémantique étendue aux booléens et aux expressions booléennes ou pour obtenir une compatibilité descendante avec les versions antérieures du langage. Par exemple, les premières versions du langage de programmation C qui suivaient ANSI C et ses anciennes normes n'avaient pas de type booléen dédié. Au lieu de cela, les valeurs numériques de zéro sont interprétées comme « faux », et toute autre valeur est interprétée comme « vrai ». Le nouveau C99 a ajouté un type booléen distinct qui peut être inclus avec stdbool.h , et C++ prend boolen charge en tant que type intégré et "true" et "false" en tant que mots réservés.

Caractères et chaînes

Un type de caractère (généralement appelé "char") peut contenir une seule lettre , chiffre , signe de ponctuation , symbole , code de formatage, code de contrôle ou tout autre code spécialisé (par exemple, une marque d'ordre d'octet ). En C , charest défini comme la plus petite unité de mémoire adressable. Sur la plupart des systèmes, c'est 8 bits ; Plusieurs normes, telles que POSIX , exigent qu'il soit de cette taille. Certaines langues ont deux types de caractères ou plus, par exemple un type à un octet pour les caractères ASCII et un type à plusieurs octets pour les caractères Unicode . Le terme "type de caractère" est normalement utilisé même pour des types dont les valeurs représentent plus précisément des unités de code , par exemple une unité de code UTF-16 comme en Java (prise en charge limitée aux caractères 16 bits uniquement) et JavaScript .

Les caractères peuvent être combinés en chaînes . Les données de chaîne peuvent inclure des nombres et d'autres symboles numériques, mais sont traitées comme du texte. Par exemple, les opérations mathématiques qui peuvent être effectuées sur une valeur numérique (par exemple 200) ne peuvent généralement pas être effectuées sur cette même valeur écrite sous forme de chaîne (par exemple "200").

Les chaînes sont implémentées de différentes manières, selon le langage de programmation. La façon la plus simple d'implémenter des chaînes est de les créer sous la forme d'un tableau de caractères, suivi d'un caractère de délimitation utilisé pour signaler la fin de la chaîne, généralement NUL . Celles-ci sont appelées chaînes à zéro terminal et se trouvent généralement dans les langages avec une faible quantité d' abstraction matérielle , tels que C et Assembly . Bien que faciles à implémenter, les chaînes terminées par null ont été critiquées pour provoquer des débordements de tampon . La plupart des langages de script de haut niveau, tels que Python , Ruby et de nombreux dialectes de BASIC , n'ont pas de type de caractère distinct ; les chaînes d'une longueur de un sont normalement utilisées pour représenter des caractères uniques. Certains langages, tels que C++ et Java , ont la capacité d'utiliser des chaînes à zéro terminal (généralement pour les mesures de compatibilité descendante), mais fournissent en plus leur propre classe pour la gestion des chaînes ( std::stringet java.lang.String, respectivement) dans la bibliothèque standard.

Il existe également une différence selon que les chaînes sont mutables ou immuables dans une langue. Les chaînes mutables peuvent être modifiées après leur création, tandis que les chaînes immuables conservent une taille et un contenu constants. Dans ce dernier cas, la seule façon de modifier les chaînes est d'en créer de nouvelles. Il y a à la fois des avantages et des inconvénients à chaque approche : bien que les chaînes immuables soient beaucoup moins flexibles, elles sont plus simples et totalement thread-safe . Quelques exemples de langages qui utilisent des chaînes mutables incluent C++ , Perl et Ruby , tandis que les langages qui n'incluent pas JavaScript , Lua , Python et Go . Quelques langages, tels que Objective-C , fournissent différents types de chaînes mutables et immuables.

Les littéraux pour les caractères et les chaînes sont généralement entourés de guillemets : parfois, les guillemets simples ( ' ) sont utilisés pour les caractères et les guillemets doubles ( " ) sont utilisés pour les chaînes. Python accepte l'une ou l'autre variante pour sa notation de chaîne.

Voici des exemples de littéraux de caractères dans la syntaxe C :

Des exemples de littéraux de chaîne dans la syntaxe C sont :

  • "UNE"
  • "Bonjour le monde"
  • "Il y a 4 chats."

Plages de types de données numériques

Chaque type de données numérique a sa valeur maximale et minimale connue sous le nom de plage . Tenter de stocker un nombre en dehors de la plage peut entraîner des erreurs de compilation/d'exécution, ou des calculs incorrects (en raison de la troncature ) selon la langue utilisée.

La plage d'une variable est basée sur le nombre d'octets utilisés pour enregistrer la valeur, et un type de données entier est généralement capable de stocker 2 n valeurs (où n est le nombre de bits qui contribuent à la valeur). Pour les autres types de données (par exemple les valeurs à virgule flottante ), la plage est plus compliquée et variera en fonction de la méthode utilisée pour la stocker. Il existe également certains types qui n'utilisent pas des octets entiers, par exemple un booléen qui nécessite un seul bit et représente une valeur binaire (bien qu'en pratique un octet soit souvent utilisé, les 7 bits restants étant redondants). Certains langages de programmation (tels que Ada et Pascal ) permettent également la direction opposée, c'est-à-dire que le programmeur définit la plage et la précision nécessaires pour résoudre un problème donné et le compilateur choisit automatiquement le type entier ou à virgule flottante le plus approprié.

Voir également

Les références

Liens externes