Cours complet pour apprendre à programmer en D


précédentsommairesuivant

8. Types fondamentaux

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ée 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 types 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 types 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

bool

type booléen

false

byte

8 bits signé

0

ubyte

8 bits non signé

0

short

16 bits signé

0

ushort

16 bits non signé

0

int

32 bits signé

0

uint

32 bits non signé

0

long

64 bits signé

0L

ulong

64 bits non signé

0L

float

32 bits à virgule flottante

float.nan

double

64 bits à virgule flottante

double.nan

real

soit le type à virgule flottante le plus large que le matériel prend en charge, soit double : le plus large des deux

real.nan

ifloat

float à valeur imaginaire

float.nan * 1.0i

idouble

double à valeur imaginaire

double.nan * 1.0i

ireal

real à valeur imaginaire

real.nan * 1.0i

cfloat

nombre complexe construit à partir de deux float

float.nan + float.nan * 1.0i

cdouble

nombre complexe construit à partir de deux double

double.nan + double.nan * 1.0i

creal

nombre complexe construit à partir de deux real

real.nan + real.nan * 1.0i

char

unité de stockage UTF-8

0xFF

wchar

unité de stockage UTF-16

0xFFFF

dchar

unité de stockage UTF-32 et point de code Unicode

0x0000FFFF

En plus de ces types, le mot-clé void représente « aucun type ». Les mots-clés cent et 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 spécifique de ne pas le faire, vous pouvez utiliser int pour représenter les valeurs entières. Pour représenter des valeurs fractionnaires, utilisez plutôt double.

Les termes suivants apparaissent dans le tableau :

  • Booléen : le type des expressions logiques, avec la valeur true pour représenter quelque chose de vrai et false pour quelque chose de faux ;
  • Type signé : un type qui peut avoir des valeurs positives ou négatives. Par exemple, byte peut stocker des valeurs entre -128 et 127. Le nom de ces types vient du signe négatif ;
  • Type non signé : un type qui ne peut stocker que des valeurs positives. Par exemple, ubyte peut stocker des valeurs entre 0 et 255. Le 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 (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 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 kitxmlcodeinlinelatexdvpi^2=-1finkitxmlcodeinlinelatexdvp en mathématiques ;
  • nan  : initiales de « Not A Number » (« n'est pas un nombre »), représentant une valeur flottante non valide.

8-1. 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 int avec int.sizeof. Nous verrons seulement quatre de ces attributs dans ce chapitre :

  • . stringof est le nom du type ;
  • . sizeof est la longueur du type en termes d'octet. (Pour déterminer le nombre de bits, cette valeur doit être multipliée par 8, le nombre de bits dans un octet.) ;
  • .min (pour « minimum »). C'est la plus petite valeur que le type peut avoir ;
  • .max (pour « maximum »). C'est la plus grande valeur que le type peut avoir.

Voici un programme qui affiche ces propriétés pour int :

 
Sélectionnez
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 :

 
Sélectionnez
Type           : int
Length in bytes: 4
Minimum value  : -2147483648
Maximum value  : 2147483647
Initial value  : 0

8-1-1. size_t

Vous allez également rencontrer le type size_t. size_t n'est pas un type à part entière, mais est un alias d'un type non signé existant. Son nom vient de « size type » (type taille). C'est le meilleur type pour représenter des idées comme la taille ou pour compter. 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 : uint sur un système 32 bits, ulong sur un système 64 bits, etc.

Vous pouvez utiliser l'attribut .stringof pour savoir de quel type size_t est un alias sur votre système :

 
Sélectionnez
import std.stdio;
 
void main()
{
    writeln(size_t.stringof);
}

Sur mon système, cela donne :

 
Sélectionnez
ulong

8-1-2. Exercice

Afficher les propriétés d'autres types.

Vous ne pouvez pas utiliser les types réservés cent et ucent, et void n'a pas les attributs .min, .max et .init.

De plus, la propriété .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 Spécification des propriétés). Si vous utilisez un type à virgule flottante dans cet exercice, le compilateur vous préviendra que .min n'est pas valide pour ce type. À la place, comme nous le verrons plus tard dans le chapitre sur les types à virgule flottante, il faut utiliser le négatif de la propriété .max , par exemple -double.max.

SolutionTypes Fondamentaux - Correction.


précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+