Programmation D - Littéraux

Les valeurs constantes qui sont saisies dans le programme dans le cadre du code source sont appelées literals.

Les littéraux peuvent être de l'un des types de données de base et peuvent être divisés en nombres entiers, nombres à virgule flottante, caractères, chaînes et valeurs booléennes.

Encore une fois, les littéraux sont traités comme des variables régulières sauf que leurs valeurs ne peuvent pas être modifiées après leur définition.

Littéraux entiers

Un littéral entier peut être l'un des types suivants -

Decimal utilise la représentation numérique normale avec le premier chiffre ne peut pas être 0 car ce chiffre est réservé pour indiquer le système octal. Cela n'inclut pas 0 seul: 0 est zéro.
Octal utilise 0 comme préfixe au nombre.
Binary utilise 0b ou 0B comme préfixe.
Hexadecimal utilise 0x ou 0X comme préfixe.

Un littéral entier peut également avoir un suffixe qui est une combinaison de U et L, pour unsigned et long, respectivement. Le suffixe peut être en majuscules ou en minuscules et peut être dans n'importe quel ordre.

Lorsque vous n'utilisez pas de suffixe, le compilateur lui-même choisit entre int, uint, long et ulong en fonction de l'ampleur de la valeur.

Voici quelques exemples de littéraux entiers -

212         // Legal 
215u        // Legal 
0xFeeL      // Legal 
078         // Illegal: 8 is not an octal digit 
032UU       // Illegal: cannot repeat a suffix

Voici d'autres exemples de divers types de littéraux entiers -

85         // decimal 
0213       // octal
0x4b       // hexadecimal 
30         // int 
30u        // unsigned int 
30l        // long 
30ul       // unsigned long 
0b001      // binary

Littéraux à virgule flottante

Les littéraux à virgule flottante peuvent être spécifiés soit dans le système décimal comme dans 1.568 ou dans le système hexadécimal comme dans 0x91.bc.

Dans le système décimal, un exposant peut être représenté en ajoutant le caractère e ou E et un nombre après cela. Par exemple, 2,3e4 signifie «2,3 fois 10 à la puissance 4». Un caractère «+» peut être spécifié avant la valeur de l'exposant, mais il n'a aucun effet. Par exemple, 2.3e4 et 2.3e + 4 sont identiques.

Le caractère «-» ajouté avant la valeur de l'exposant change le sens pour être «divisé par 10 en puissance de». Par exemple, 2,3e-2 signifie «2,3 divisé par 10 à la puissance 2».

Dans le système hexadécimal, la valeur commence par 0x ou 0X. L'exposant est spécifié par p ou P au lieu de e ou E. L'exposant ne signifie pas «10 à la puissance de», mais «2 à la puissance de». Par exemple, le P4 dans 0xabc.defP4 signifie "abc.de fois 2 à la puissance 4".

Voici quelques exemples de littéraux à virgule flottante -

3.14159       // Legal 
314159E-5L    // Legal 
510E          // Illegal: incomplete exponent 
210f          // Illegal: no decimal or exponent 
.e55          // Illegal: missing integer or fraction 
0xabc.defP4   // Legal Hexa decimal with exponent 
0xabc.defe4   // Legal Hexa decimal without exponent.

Par défaut, le type d'un littéral à virgule flottante est double. Le f et F signifient float, et le spécificateur L signifie réel.

Littéraux booléens

Il existe deux littéraux booléens et ils font partie des mots-clés D standard -

Une valeur de true représentant vrai.
Une valeur de false représentant faux.

Vous ne devez pas considérer la valeur de true égale à 1 et la valeur de false égale à 0.

Littéraux de caractères

Les caractères littéraux sont placés entre guillemets simples.

Un littéral de caractère peut être un caractère simple (par exemple, 'x'), une séquence d'échappement (par exemple, '\ t'), un caractère ASCII (par exemple, '\ x21'), un caractère Unicode (par exemple, '\ u011e') ou comme caractère nommé (par exemple '\ ©', '\ ♥', '\ €').

Il y a certains caractères dans D lorsqu'ils sont précédés d'une barre oblique inverse, ils auront une signification spéciale et ils sont utilisés pour représenter comme une nouvelle ligne (\ n) ou une tabulation (\ t). Ici, vous avez une liste de certains de ces codes de séquence d'échappement -

Séquence d'échappement	Sens
\\	\ personnage
\ '	' personnage
\ "	" personnage
\?	? personnage
\une	Alerte ou cloche
\ b	Retour arrière
\F	Saut de formulaire
\ n	Nouvelle ligne
\ r	Retour chariot
\ t	Onglet horizontal
\ v	Onglet vertical

L'exemple suivant montre quelques caractères de séquence d'échappement -

import std.stdio;
  
int main(string[] args) { 
   writefln("Hello\tWorld%c\n",'\x21'); 
   writefln("Have a good day%c",'\x21'); 
   return 0; 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Hello   World!

Have a good day!

Littéraux de chaîne

Les chaînes littérales sont placées entre guillemets. Une chaîne contient des caractères similaires aux littéraux de caractères: caractères simples, séquences d'échappement et caractères universels.

Vous pouvez diviser une longue ligne en plusieurs lignes à l'aide de chaînes littérales et les séparer en utilisant des espaces.

Voici quelques exemples de littéraux de chaîne -

import std.stdio;

int main(string[] args) {
   writeln(q"MY_DELIMITER
      Hello World
      Have a good day
      MY_DELIMITER");

   writefln("Have a good day%c",'\x21'); 
   auto str = q{int value = 20; ++value;}; 
   writeln(str); 
}

Dans l'exemple ci-dessus, vous pouvez trouver l'utilisation de q "MY_DELIMITER MY_DELIMITER" pour représenter des caractères multi-lignes. De plus, vous pouvez voir q {} pour représenter une instruction en langage D elle-même.