Type primitif

Dans le de l'informatique, les types primitifs - à la différence du composé de dactylographie '- sont les types de données fournis par un langage de programmation en tant que blocs fonctionnels de base. Des types primitifs sont également connus en tant que des types de fonction intégrée de ou types de base de .

Selon la langue et son exécution, types primitifs les mai ou mai ne pas avoir une correspondance linéaire avec des objets dans la mémoire d'ordinateur. Cependant, on prévoit habituellement que les opérations sur les types primitifs à être les constructions de langue les plus rapides là sont. L'addition de nombre entier, par exemple, peut être effectuée en tant qu'une instruction de machine simple, et quelques instructions spécifiques d'offre des processeurs aux ordres de processus des caractères avec une instruction simple. En particulier, la norme du C mentionne cela " ; un objet de 'plain' international a la taille normale suggérée par l'architecture du environment" d'exécution ;. Ceci signifie que int est susceptible d'être 32 bits longtemps sur un à 32 bits architecture.

La plupart des langues ne permettent pas le comportement ou les possibilités des types primitifs à modifier par des programmes. Les exceptions incluent la causerie , qui de permet aux datatypes primitifs d'être prolongés dans le cadre d'un programme, s'ajoutant aux opérations qui peuvent être effectuées sur elles ou même redéfinissant les opérations intégrées.

Vue d'ensemble

La gamme réelle des types primitifs qui est disponible dépend du langage de programmation spécifique qui est employé. Par exemple, dans le C , ficelle , sont un type de données composé, tandis que dans des dialectes modernes du de base et dans le Javascript , ils sont un type de données primitif.

Les types primitifs typiques peuvent inclure :
Caractère (character, char) de ;
Nombre entier (integer, int, short, long, byte) de avec une série de précisions ;
Nombre à point mobile (float, double, real, à double précision) de ;
Nombre à point fixe (fixed) de avec une série de précisions et une balance programmeur-choisie .
booléen ayant le vrai de valeurs et le faux.
Référence (également appelé un indicateur de ou la poignée de ), une petite valeur de se rapportant à l'adresse d'un autre objet dans la mémoire, probablement beaucoup plus grande.

Des types plus sophistiqués qui peuvent être primitifs incluent :
Tuples dans le ml , python
Les listes chaînées dans le blèsent
Les nombres complexes en Fortran , le C (C99) , de blèsent , le python
Les nombres raisonnables dans le blèsent
Les tables de brouillage dans diverses apparences, dans le blèsent , le python , Lua
Les suites des fermetures des fonctions de la première classe de dans les langages de programmation fonctionnelle tel que le blèsent et ml

Types primitifs spécifiques

Nombres de nombre entier

Un nombre de nombre entier ne peut tenir un nombre entier, mais aucune fraction. Des nombres entiers peuvent ou être signés (permettant des valeurs négatives) ou non signé (des valeurs non négatives seulement). Les tailles typiques des nombres entiers sont :

Booleans

Un type booléen du , " typiquement dénoté ; bool" ; ou " ; boolean" ; , est un type à bit unique qui peut être l'un ou l'autre " ; true" ; (1) ou " ; false" ; (0). Dans quelques langues (par exemple, C++ ), des bools peuvent être implicitement convertis en nombres entiers (par exemple, " ; rectifier + true" ; est une expression valide égale à 2), mais d'autres langues (par exemple, Java et Pascal ) rejettent ceci.

Nombres à point mobile

Un nombre à point mobile du représente un vrai nombre qui peut avoir une cloison partielle. Ces nombres sont stockés intérieurement dans la notation scientifique , typiquement dans le binaire mais parfois dans le décimal. Puisque le nombre à point mobile ont seulement un nombre limité de chiffres, la plupart des valeurs peuvent être représentées seulement approximativement.

Beaucoup de langues ont une précision simple (souvent appelée le " ; float" ;) et un type à double précision du .

Les coquilles pour des nombres de virgule flottante incluent une virgule décimale, et emploient typiquement le " ; e" ; pour dénoter la notation scientifique. Les exemples des coquilles à point mobile sont :

20.02e23

Quelques langues (par exemple, Fortran ) ont également un type du nombre complexe comporter deux nombres à point mobile : une partie réelle et une cloison imaginaire.

Caractères et cordes

Un type du caractère (typiquement appelé le " ; char" ;) peut contenir une lettre simple , le chiffre , le signe de ponctuation , ou le caractère de commande . Quelques langues ont deux types de caractère, un type de simple-byte pour des caractères du ASCII et un type de multi-byte pour des caractères d'Unicode .

Des caractères peuvent être combinés dans les cordes . Les données de corde peuvent inclure des nombres et d'autres symboles numériques mais seront traitées comme texte.

Dans la plupart des langues, une corde est équivalente à un choix de caractères, mais le Java les traite en tant que types distincts. D'autres langues (telles que python , et beaucoup de dialectes de BASIC ) n'ont aucun type de caractère séparé, mais seulement cordes avec une longueur d'une.

Des coquilles pour des caractères et des cordes sont habituellement entourées par les guillemets : souvent, des apostrophes (') sont employées pour des caractères et des guillemets (le " ;) sont employés pour des cordes.

Les exemples des coquilles de caractère en syntaxe de C sont :
« A »
« 4 »
« $ »
« \ t » (caractère d'étiquette )

Les exemples des constantes de chaîne en syntaxe de C sont :
" ; A" ;
" ; Bonjour World" ;
" ; Je suis 6000 années de " ;

Type de données numériques gammes

Chaque type de données numériques a un maximum et une valeur minimum connus sous le nom de gamme . Essayer de stocker un nombre en dehors de la gamme peut mener au compilateur/aux erreurs d'exécution, ou aux calculs incorrects (dus à troncation ) selon la langue étant employée.

La gamme d'une variable est basée sur le nombre de bytes employés pour sauver la valeur, et un type de données de nombre entier peut habituellement stocker des valeurs de $2^n$ (où $n$ est le nombre du peu . Pour d'autres types de données (par exemple valeurs de virgule flottante ) la gamme est plus compliquée et variera selon la méthode employée pour la stocker. Il y a également quelques types qui n'emploient pas des bytes entiers, par exemple un booléen qui exige un peu simple , et représentent une valeur binaire du (bien que dans la pratique un byte est employé souvent, avec les 7 bits demeurants étant superflus). Quelques langages de programmation (tels qu'ADA et Pascal ) permettent également la direction opposée, c., le programmeur définit la gamme et la précision requise pour résoudre un problème donné et le compilateur choisit le type de nombre entier le plus approprié ou de virgule flottante automatiquement.

Random links: