Cours complet pour apprendre à programmer en D

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) :

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▲

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);
}

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

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

ulong