122 lines
8.2 KiB
Plaintext
122 lines
8.2 KiB
Plaintext
[set
|
||
title = "Types fondamentaux"
|
||
partAs = chapitre
|
||
translator = "Raphaël Jakse"
|
||
proofreader = "Stéphane Goujet"
|
||
]
|
||
|
||
Nous avons vu que le cerveau d'un ordinateur est le CPU. La plupart des tâches d'un programme sont effectuées par le CPU et le reste est dispatché aux autres parties de l'ordinateur.
|
||
|
||
La plus petite unité de données dans un ordinateur est appelé un [* bit], qui peut avoir la valeur 0 ou 1.
|
||
|
||
Comme un type de données qui ne peut stocker que des 0 ou des 1 n'aurait qu'une utilité très limitée, le CPU définit des type de données plus grands qui sont des combinaisons de plus d'un bit. Par exemple, un octet est composé de 8 bits. Le type le plus efficace d'un CPU fait de ce CPU un CPU ''N'' bits, comme dans CPU 32 bits, CPU 64 bits, etc.
|
||
|
||
Les types de données que le CPU définit ne sont encore pas suffisants~ : ils ne peuvent représenter des concepts de plus haut niveau comme le nom d'un étudiant ou une carte à jouer. D propose beaucoup de type de données utiles, mais même ces types ne sont pas suffisants pour représenter beaucoup de concepts de plus haut niveau. De tels concepts doivent être définis par le programmeur au moyen de structures et de classes, que l'on verra dans des chapitres ultérieurs.
|
||
|
||
Les types fondamentaux du D sont très similaires aux types fondamentaux de beaucoup d'autres langages~ ; ils sont présentés dans le tableau qui suit (les termes qui apparaissent dans ce tableau sont expliqués en dessous)~ :
|
||
|
||
|><=Type fondamental du D |><=Définition |><= Valeur initiale
|
||
|[c bool] | type booléen | false
|
||
|[c byte] | 8 bits signé | 0
|
||
|[c ubyte] | 8 bits non signé | 0
|
||
|[c short] | 16 bits signé | 0
|
||
|[c ushort] | 16 bits non signé | 0
|
||
|[c int] | 32 bits signé | 0
|
||
|[c uint] | 32 bits non signé | 0
|
||
|[c long] | 64 bits signé | 0L
|
||
|[c ulong] | 64 bits non signé | 0L
|
||
|[c float] | 32 bits à virgule flottante | float.nan
|
||
|[c double] | 64 bits à virgule flottante | double.nan
|
||
|[c real] | soit le type à virgule flottante le plus large que le matériel prend en charge, soit [c double]~ : le plus large des deux | real.nan
|
||
|[c ifloat] | [c float] à valeur imaginaire | float.nan * 1.0i
|
||
|[c idouble] | [c double] à valeur imaginaire | double.nan * 1.0i
|
||
|[c ireal] | [c real] à valeur imaginaire | real.nan * 1.0i
|
||
|[c cfloat] | nombre complexe construit à partir de deux [c float] | float.nan + float.nan * 1.0i
|
||
|[c cdouble] | nombre complexe construit à partir de deux [c double] | double.nan + double.nan * 1.0i
|
||
|[c creal] | nombre complexe construit à partir de deux [c real] | real.nan + real.nan * 1.0i
|
||
|[c char] | unité de stockage UTF-8 | 0xFF
|
||
|[c wchar] | unité de stockage UTF-16 | 0xFFFF
|
||
|[c dchar] | unité de stockage UTF-32 et point de code Unicode | 0x0000FFFF
|
||
|
||
En plus de ces types, le mot-clé [c void] représente "aucun type". Les mots-clés [c cent] et [c ucent] sont réservés pour un usage futur pour représenter les valeurs 128-bit signées et non signées.
|
||
|
||
Sauf s'il y a une raison specifique de ne pas le faire, vous pouvez utiliser [c int] pour représenter les valeurs entières. Pour représenter des valeurs fractionnaires, utilisez plutôt [c double].
|
||
|
||
Les termes suivants apparaissent dans le tableau~ :
|
||
|
||
- [** Booléen]~ : le type des expressions logiques, avec la valeur [c true] pour représenter quelque chose de vrai et [c false] pour quelque chose de faux.
|
||
|
||
- [** Type signé]~ : un type qui peut avoir des valeurs positives ou négatives. Par exemple, [c byte] peut stocker des valeurs entre -128 et 127. Le nom de ces types viennent du signe négatif.
|
||
|
||
- [** Type non signé]~ : un type qui ne peut stocker que des valeurs positives. Par exemple, [c ubyte] peut stocker des valeurs entre 0 et 255. Le [c u] au début du nom de ces types vient de ''unsigned'' (qui veut dire "non signé").
|
||
|
||
- [** Virgule flottante]~ : un type qui peut représenter un nombre à virgule comme 1,25 ([comment <<<Les NdT~ : avec usage de [note] ou pas ? il faut homogénéiser>>>]NdT~ : on parle de valeur à virgule flottante ou de valeur flottante). La précision des calculs à virgule flottante est directement reliée au nombre de bits du type~ : plus le nombre de bits est grand, plus le résultat est précis. Seuls les types à virgule flottante peuvent représenter des nombres à virgule. Les types entiers comme [c int] ne peuvent représenter que des valeurs entières comme 1 et 2.
|
||
|
||
- [** Type complexe]~ : un type qui peut représenter les nombres complexes des mathématiques.
|
||
|
||
- [** Type imaginaire]~ : un type qui représente seulement la partie imaginaire d'un nombre complexe. Le ''i'' qui apparaît dans la colonne des valeurs initiales est le nombre ''i'' tel que [m i^2=-1] en mathématiques.
|
||
|
||
- **[c nan]**~ : initiales de "Not A Number" ("n'est pas un nombre"), représentant une valeur flottante non valide.
|
||
|
||
[ = Attributs des types
|
||
|
||
Les types D ont des propriétés auxquelles on peut accéder par des attributs. On accède à ces propriétés avec un point après le nom du type. Par exemple, on accède à la taille de [c int] avec [c int.sizeof]. Nous verrons seulement 4 de ces attributs dans ce chapitre~ :
|
||
- [c .stringof] est le nom du type
|
||
- [c .sizeof] est la longueur du type en termes d'octet. (Pour déterminer le nombre de bits, cette valeurs doit être multipliée par 8, le nombre de bits dans un octet.)
|
||
- [c .min] (pour "minimum"). C'est la plus petite valeur que le type peut avoir.
|
||
- [c .max] (pour "maximum"). C'est la plus grande valeut que le type peut avoir.
|
||
|
||
Voici un programme qui affiche ces propriétés pour [c int]~ :
|
||
|
||
[code=d <<<
|
||
import std.stdio;
|
||
|
||
void main()
|
||
{
|
||
writeln("Type ~ : ", int.stringof);
|
||
writeln("Longueur en octets~ : ", int.sizeof);
|
||
writeln("Valeur minimale ~ : ", int.min);
|
||
writeln("Valeur maximale ~ : ", int.max);
|
||
}
|
||
>>>]
|
||
|
||
Sur ma machine, ce programme donnerait le résultat suivant:
|
||
|
||
[output <<<
|
||
Type : int
|
||
Length in bytes: 4
|
||
Minimum value : -2147483648
|
||
Maximum value : 2147483647
|
||
Initial value : 0
|
||
>>>]
|
||
|
||
[ = [c size_t]
|
||
|
||
Vous allez également rencontrer le type [c size_t]. [c size_t] n'est pas un type à part entière mais est un [* alias] d'un type non signé existant. Son non vient de "size type" (type taille). C'est le meilleur type pour représenter des idées comme la taille ou pour compter. [c size_t] doit être assez large pour représenter le nombre d'octets de la mémoire qu'un programme peut potentiellement utiliser. Sa taille est donc dépendante du système : [c uint] sur un système 32 bits, [c ulong] sur un système 64 bits, etc.
|
||
|
||
Vous pouvez utiliser l'attribut [c .stringof] pour savoir de quel type [c size_t] est un alias sur votre système~ :
|
||
|
||
[code=d <<<
|
||
import std.stdio;
|
||
|
||
void main()
|
||
{
|
||
writeln(size_t.stringof);
|
||
}
|
||
>>>]
|
||
|
||
Sur mon système (NdT: et sur le mien aussi), cela donne~ :
|
||
|
||
[output ulong]
|
||
]
|
||
|
||
[ = Exercice
|
||
Afficher les propriétés d'autres types.
|
||
|
||
Note~ : vous ne pouvez pas utiliser les types réservés [c cent] et [c ucent], et [c void] n'a pas les attributs [c .min], [c .max] et [c .init].
|
||
|
||
[* De plus, la propriété [c .min] a été dépréciée pour les types à virgule flottante. (Vous pouvez voir les différentes propriétés des types fondamentaux dans la [[http://dlang.org/property.html | Spécification des propriétés]]). Si vous utilisez un type à virgule flottante dans cet exercice, le compilateur vous préviendra que [c .min] n'est pas valide pour ce type. À la place, comme nous le verrons plus tard dans le chapitres sur les types à virgule flottante, il faut utiliser le négative de la propriété [c .max], comme par exempe [c -double.max].]
|
||
|
||
[[part:corrections/types | … La solution]]
|
||
]
|