Cours complet pour apprendre à programmer en D

Les valeurs des types qui sont dans la colonne de gauche du tableau suivant ne font jamais partie d'expressions arithmétiques en tant que telles. Chaque type est d'abord promu vers le type de la colonne à droite du tableau.

Les promotions entières sont également appliquées aux valeurs enum.

Les raisons d'être des promotions entières sont aussi historiques (où les règles viennent du C) que techniques, le type arithmétique naturel du processeur étant int. Par exemple, même si les deux variables suivantes sont ubyte, l'opération d'addition n'est effectuée qu'après que les deux valeurs ont été promues en int :

ubyte a = 1;
ubyte b = 2;
writeln(typeof(a + b).stringof);  // l'addition ne se fait pas en ubyte

La sortie :

int

Notez que les types respectifs des variables a et b ne changent pas ; seules leurs valeurs sont temporairement promues en int pour la durée de l'opération d'addition.

Il y a d'autres règles de conversions qui sont appliquées pour les opérations arithmétiques. En général, les conversions arithmétiques automatiques sont appliquées dans la direction sûre : du type le plus étroit au type le plus large. Même si cette règle est facile à retenir et est correcte dans la plupart des cas, les règles de conversions automatiques sont très compliquées et, dans les cas de conversion signé vers non signé, sont de potentielles causes de bogues.

Les règles de conversions arithmétiques sont les suivantes :

1. Si l'une des valeurs est real, alors l'autre valeur est convertie en real ;
2. Sinon, si l'une des valeurs est double, alors l'autre valeur est convertie en double ;
3. Sinon, si l'une des valeurs est float, alors l'autre valeur est convertie en float ;

4. Sinon, les promotions entières sont appliquées selon le tableau de la section précédente, et les règles suivantes sont ensuite appliquées :

   1. Si les deux types sont les mêmes, alors aucune autre étape n'est nécessaire,
   2. Si le type signé est plus large que le type non signé, alors la valeur non signée est convertie vers le type signé,
   3. Sinon le type signé est converti vers le type non signé.

Malheureusement, cette dernière règle peut être à l'origine de bogues subtils :

int    a = 0;
int    b = 1;
size_t c = 0;
writeln(a - b + c);  // Résultat surprenant !

Étonnement, le résultat n'est pas -1 mais size_t.max :

0

Même si l'on s'attendrait à ce que 0 - 1 + 0 donne -1, selon les règles ci-avant, le type de l'expression entière est size_t et non int ; et comme size_t ne peut pas représenter des valeurs négatives, le résultat soupasse et devient size_t.max.

Comme nous l'avons vu précédemment dans le chapitre sur les paramètres de fonctionsLes paramètres de fonction. les types référence peuvent être automatiquement convertis vers le const du même type. Les conversions vers const sont sûres parce que la largeur du type ne change pas et const est une promesse de ne pas modifier la variable :

dchar[] entre_accolades(const dchar[] texte)
{
    return "{" ~ texte ~ "}";
}
 
void main()
{
    dchar[] bienvenue;
    bienvenue ~= "bonjour le monde";
    entre_accolades(bienvenue);
}

La variable mutable bienvenue est automatiquement convertie vers un const dchar[] lorsqu'elle est passée à la fonction entre_accolades.

Comme nous l'avons aussi vu précédemment, la conversion inverse n'est pas automatique. Une référence const n'est pas automatiquement convertie vers une référence mutable :

dchar[] entre_accolades(const dchar[] texte)
{
    dchar[] argument = texte;  // ERREUR de compilation
    // ...
}

Notez que cette partie concerne uniquement les références ; comme les variables de types valeur sont copiées, il n'est de toute façon pas possible d'assigner l'original à travers la copie :

const int nombreDeCoins = 4;
int laCopie = nombreDeCoins;      // compile (type valeur)

Cette conversion de const vers mutable est légale parce que la copie n'est pas une référence vers l'original.

immutable indiquant qu'une variable ne peut jamais changer, aucune conversion depuis ou vers immutable n'est automatique :

string a = "salut";    // caractères immuables
char[] b = a;          // Erreur de compilation
string c = b;          // Erreur de compilation

Comme pour la section précédente (conversions de const), cette partie ne concerne que les types référence. Comme les variables de types valeur sont de toute façon copiées, les conversions depuis et vers immutable sont valides :

immutable a = 10;
int b = a;           // compile (type valeur)

Comme nous l'avons vu dans le chapitre sur les énumérationsLes énumérations (enum) enum définit des constantes nommées :

enum Couleur { pique, coeur, carreau, trefle }

Souvenez-vous que comme aucune valeur n'est spécifiée explicitement, les valeurs des membres de l'énumération commencent par zéro et sont automatiquement incrémentées de 1 en 1. Ainsi, la valeur de Couleur.trefle est 3.

Les valeurs enum sont automatiquement converties vers des types entiers. Par exemple, la valeur de Couleur.coeur est comprise comme 1 dans le calcul suivant et le résultat est 11 :

int resultat = 10 + Couleur.coeur;
assert(resultat == 11);

La conversion inverse n'est pas automatique : les valeurs entières ne sont pas automatiquement converties vers les valeurs enum correspondantes. Par exemple, on pourrait s'attendre que la variable couleur ci-dessous prenne pour valeur Couleur.carreau, mais le code ne peut pas être compilé :

Couleur couleur = 2;    // ERREUR de compilation

Comme nous le verrons juste après, les conversions depuis les entiers vers les valeurs enum sont néanmoins possibles, mais elles doivent être explicites.

false et true sont automatiquement convertis vers 0 et 1, respectivement :

int a = false;
assert(a == 0);
 
int b = true;
assert(b == 1);

La conversion inverse est également automatique, mais seulement pour deux valeurs spéciales. Les littéraux 0 et 1 sont convertis automatiquement vers false et true, respectivement :

bool a = 0;
assert(!a);     // false
 
bool b = 1;
assert(b);      // true

Les autres valeurs littérales ne peuvent pas être converties vers bool automatiquement :

bool b = 2;    // ERREUR de compilation

Certaines instructions utilisent des expressions logiques : if, while, etc. Pour les expressions logiques de telles instructions, en plus de bool, la plupart des autres types peuvent également être utilisés. La valeur zéro est automatiquement convertie vers false et les valeurs non nulles sont automatiquement converties vers true.

int i;
// ...
 
if (i) {    // ← valeur int utilisée comme une expression logique
    // ... 'i' ne vaut pas zéro
 
} else {
    // ... 'i' vaut zero
}

De manière similaire, les références nulles (null) sont automatiquement converties vers false et les références non nulles sont automatiquement converties vers true. Cela facilite la vérification qu'une référence n'est pas nulle avant de s'en servir :

int[] a;
// ...
 
if (a) {    // ← conversion booléenne automatique
    // ... non null; 'a' peut être utilisé...
 
} else {
    // ... null; 'a' ne peut pas être utilisé...
}

Comme nous venons de le voir, il y a des cas où les conversions automatiques ne sont pas possibles :

• les conversions depuis des types plus larges vers des types plus restreints ;
• les conversions depuis const vers mutable ;
• les conversions immutables ;
• les conversions depuis les entiers vers les valeurs enum.

S'il sait qu'une telle conversion est sûre, le programmeur peut explicitement demander une conversion de types avec l'une des trois méthodes suivantes :

• en appelant la fonction std.conv.to ;
• en appelant la fonction std.exception.assumeUnique ;
• en utilisant l'opérateur cast.

50-1-8-1. La fonction to pour la plupart des conversions▲

to!(TypeDestination)(valeur)

to!TypeDestination(valeur)

void main()
{
    double d = -1.75;
 
    short s = d;     // ERREUR de compilation
    int i = "42";    // ERREUR de compilation
}

import std.conv;
 
void main()
{
    double d = -1.75;
 
    short s = to!short(d);
    assert(s == -1);
 
    int i = to!int("42");
    assert(i == 42);
}

50-1-8-2. assumeUnique() pour des conversions immutables rapides▲

int[] tranche = [ 10, 20, 30 ];
auto trancheImmuable = to!(immutable int[])(tranche);

assert(&(tranche[0]) != &(trancheImmuable[0]));

void calculer(immutable int[] coordonnees)
{
    // ...
}
 
void main()
{
    int[] nombres;
    nombres ~= 10;
    // ... autres diverses modifications ...
    nombres[0] = 42;
 
    calculer(nombres);    // ERREUR de compilation
}

import std.conv;
// ...
    auto nombresImmuables = to!(immutable int[])(nombres);
    calculer(nombresImmuables);    // ← maintenant, compile

import std.exception;
// ...
    auto nombresImmuables = assumeUnique(nombres);
    calculer(nombresImmuables);
    assert(nombres is null);    // La tranche originale devient nulle

50-1-8-3. L'opérateur cast ▲

cast(TypeDestination)valeur

Couleur couleur = to!Couleur(2);    // ERREUR de compilation
bool b = to!bool(2);       //ERREUR de compilation

Couleur couleur = cast(Couleur)2;
assert(couleur == Couleur.carreau);
 
bool b = cast(bool)2;
assert(b);

size_t valeurPointeurSauvée = cast(size_t) p;
// ...
int * p2 = cast(int*)valeurPointeurSauvée;

• Les conversions de types automatiques sont principalement celles qui se font dans le sens sûr : du type le plus restreint au type le plus large et de mutable vers const.
• Cependant, les conversions vers les types non signés peuvent avoir des effets surprenants parce que les types non signés ne peuvent pas avoir de valeur négative.
• Les types enum peuvent automatiquement être convertis vers des valeurs entières, mais la conversion inverse n'est pas automatique.
• false et true sont automatiquement convertis vers 0 et 1, respectivement. De manière similaire, les valeurs nulles (dans le sens « zéro ») sont automatiquement converties vers false et les valeurs non nulles sont automatiquement converties vers true.
• Les références nulles sont automatiquement converties vers false et les références non nulles sont automatiquement converties vers true.
• La fonction to couvre la plupart des conversions explicites.
• La fonction assumeUnique convertit vers immutable sans copier.
• L'opérateur cast est l'outil de conversion le plus puissant.