Programmation D - Compilation conditionnelle

La compilation conditionnelle est le processus de sélection du code à compiler et du code à ne pas compiler, similaire à #if / #else / #endif en C et C ++. Toute instruction qui n'est pas compilée doit être syntaxiquement correcte.

La compilation conditionnelle implique des vérifications de condition qui sont évaluables au moment de la compilation. Les instructions conditionnelles d'exécution telles que if, for, while ne sont pas des fonctionnalités de compilation conditionnelle. Les fonctionnalités suivantes de D sont destinées à la compilation conditionnelle -

• debug
• version
• statique si

Déclaration de débogage en D

Le débogage est utile lors du développement du programme. Les expressions et instructions marquées comme débogage sont compilées dans le programme uniquement lorsque le commutateur de compilateur -debug est activé.

debug a_conditionally_compiled_expression;
   
debug { 
   // ... conditionally compiled code ... 
} else { 
   // ... code that is compiled otherwise ... 
}

La clause else est facultative. L'expression unique et le bloc de code ci-dessus sont compilés uniquement lorsque le commutateur de compilateur -debug est activé.

Au lieu d'être complètement supprimées, les lignes peuvent être marquées comme débogage à la place.

debug writefln("%s debug only statement", value);

Ces lignes sont incluses dans le programme uniquement lorsque le commutateur de compilateur -debug est activé.

dmd test.d -oftest -w -debug

Instruction de débogage (balise) en D

Les instructions de débogage peuvent recevoir des noms (balises) à inclure dans le programme de manière sélective.

debug(mytag) writefln("%s not found", value);

Ces lignes sont incluses dans le programme uniquement lorsque le commutateur de compilateur -debug est activé.

dmd test.d -oftest -w -debug = mytag

Les blocs de débogage peuvent également avoir des balises.

debug(mytag) { 
   //  
}

Il est possible d'activer plus d'une balise de débogage à la fois.

dmd test.d -oftest -w -debug = mytag1 -debug = mytag2

Instruction de débogage (niveau) en D

Parfois, il est plus utile d'associer des instructions de débogage par niveaux numériques. Des niveaux croissants peuvent fournir des informations plus détaillées.

import std.stdio;  

void myFunction() { 
   debug(1) writeln("debug1"); 
   debug(2) writeln("debug2");
}

void main() { 
   myFunction(); 
}

Les expressions de débogage et les blocs inférieurs ou égaux au niveau spécifié seraient compilés.

$ dmd test.d -oftest -w -debug = 1 
$ ./test 
debug1

Déclarations de version (balise) et de version (niveau) en D

La version est similaire au débogage et est utilisée de la même manière. La clause else est facultative. Bien que la version fonctionne essentiellement de la même manière que le débogage, le fait d'avoir des mots-clés séparés permet de distinguer leurs utilisations non liées. Comme pour le débogage, plusieurs versions peuvent être activées.

import std.stdio;  

void myFunction() { 
   version(1) writeln("version1"); 
   version(2) writeln("version2");     
}
  
void main() { 
   myFunction(); 
}

Les expressions de débogage et les blocs inférieurs ou égaux au niveau spécifié seraient compilés.

$ dmd test.d -oftest -w -version = 1 
$ ./test 
version1

Statique si

Static if est l'équivalent à la compilation de l'instruction if. Tout comme l'instruction if, static if prend une expression logique et l'évalue. Contrairement à l'instruction if, static if ne concerne pas le flux d'exécution; il détermine plutôt si un morceau de code doit être inclus dans le programme ou non.

L'expression if n'est pas liée à l'opérateur is que nous avons vu précédemment, à la fois syntaxiquement et sémantiquement. Il est évalué au moment de la compilation. Il produit une valeur int, soit 0 ou 1; selon l'expression spécifiée entre parenthèses. Bien que l'expression prise ne soit pas une expression logique, l'expression is elle-même est utilisée comme expression logique lors de la compilation. Il est particulièrement utile dans les conditions statiques et les contraintes de modèle.

import std.stdio;

enum Days { 
   sun, 
   mon, 
   tue, 
   wed, 
   thu, 
   fri, 
   sat 
}; 
 
void myFunction(T)(T mytemplate) {
   static if (is (T == class)) { 
      writeln("This is a class type"); 
   } else static if (is (T == enum)) { 
      writeln("This is an enum type"); 
   } 
}
  
void main() { 
   Days day; 
   myFunction(day); 
}

Lorsque nous compilons et exécutons, nous obtiendrons une sortie comme suit.

This is an enum type