Programmation D/Outils
Compilation et débogage en ligne de commande.
Compilation.
Pour compiler un programme D, il vous aurez besoin du compilateur ldc et de la bibliothèque standard tango.
Le compilateur ldc offre de nombreuses options de compilation. Vous pouvez lister toutes ces options en tapant :
 $ ldc --help
Je vous présente l'usage courant que j'ai du compilateur :
 ldc -w -g -O2 src/*.d -od build/ -of build/monProgramme -D -Dd doc/
Ne vous inquiétez pas, les différents arguments sont très simples :
Debogage.
Pour déboguer une application écrite en D, vous pouvez utiliser gdb, tout simplement !
Il existe deux cas de figure de l'utilisation de gdb :
 $ gdb --args <ligne de commande pour compiler>
 (gdb) run
soit d'après l'exemple précédent :
 $ gdb --args ldc -w -g -O2 src/*.d -od build/ -of build/monProgramme -D -Dd doc/
 (gdb) run
 $ gdb monProgramme
 (gdb) run
La documentation.
Je vous ai déjà donné un aperçu dans Les commentaires. Le compilateur ldc offre la possibilité de générer de la documentation et de la formater pour avoir une belle mise en page html.
La syntaxe.
La documentation est structurée en sections.
Qu'est-ce qu'une section ?
Sémantiquement parlant, une section est une chaîne de caractères suivie par ':' (attention, les sections sont sensibles à la casse).
Résumé.
La section « résumé » est une section n'étant pas soumise à une chaîne de caractères suivie par ':'. Cette section correspond simplement au premier paragraphe et est optionnelle.
 * Ceci est un résumé qui 
 * tient sur un paragraphe
Description.
La section « description » est une section n'étant pas soumise à une chaîne de caractères suivie par ':'. Cette section correspond au paragraphe qui suit la section « résumé », tant qu'il ne rencontre aucune section spécifiée par une chaîne de caractères suivie par ':'.
 * Ceci est un résumé qui 
 * tient sur un paragraphe
 * Ceci est une description
 * paragraphe n°1
 * Ceci est une description
 * paragraphe n°2
Auteurs.
Cette section liste les auteurs de la manière suivante :
 * Authors: bioinfornatics J. Mercier, bioinfornatics@gmail.com
Bogues.
Cette section liste les bogues connus de la manière suivante :
 * Bugs: aucun bogue signalé.
Date.
 * Date: September 25, 2010
Dépréciation.
 * Deprecated: cette fonction est dépréciée. Utilisez maintenant la nouvelle fonction foo().
Exemples.
Cette section permet de documenter avec des exemples. Un exemple d'utilisation de cette section :
 * Examples:
 * Stdout.formatln("3"); // Écrit "3" sur la sortie standard
Historique.
Cette section permet d'écrire les différentes modifications effectuées sur la portion de code à la manière d'un « changelog ».
 * History:
 * version 1 est la version initiale
 * version 2 ajoute les fonctionnalités suivantes : support de la 3D, utilisation d'un nouveau moteur graphique
Licence.
Cette section permet d'écrire la licence sous laquelle est publiée le code.
 * License: GPLv3+
Retour.
Cette section détaille la valeur retournée par la fonction. Cette section est évidement inutile pour les fonctions de type void.
 * Returns: Le contenu du fichier
Voir aussi.
Cette section décrit les choses se rapprochant du code documenté. Il peut notamment contenir des liens (URL).
 * See_Also:
 * foo, bar, http://www.dsource.org/projects/tango/docs/stable/
Standards.
Cette section permet de spécifier si la partie documentée est en accord avec un quelconque standard que l'on aura défini.
 * Standards: Conforme avec DSPEC-1234
Exception.
Cette section permet de lister les exceptions et les circonstances qui les déclenchent.
 * Throws: EcritException est déclenché si l'execution rencontre un echec
Version.
Cette section permet de spécifier la version courante du bloc documenté.
 * Version: 1.6a
Mise en évidence.
Avec du code HTML.
La documentation autorise l'écriture de portions de code html
 * <ul>
 * <li> <a href="http://www.dsource.org/projects/tango/">Tango</a></li>
 * <li> <a href="http://www.dsource.org/projects/tango/docs/stable/">Tango Documentation</a></li>
 * </ul>
Sections spéciales.
Copyright.
Cette section informe sur le copyright. La macro COPYRIGHT prend la valeur de la section quand cette dernière est renseignée. Ce comportement particulier apparaît seulement quand cette section est utilisée pour documenter un module.
 * Copyright: Domaine Publique
module foo;
Params.
Cette section permet de documenter les paramètres que prend une fonction. Pour cela, on doit lister chaque paramètre. Chaque ligne commence par le nom de la variable suivi de "=" puis de sa description. La description peut s'étendre sur plusieurs lignes.
 * foo fait plein de choses
 * Params:
 * x = est utilisé
 * pour un truc
 * y = est utilisé pour d'autres choses
void foo (int x, int y){
Macros.
La section macros suit la même logique que la section params, soit une suite de nom = valeur. Le nom est le nom de la macro et la valeur est le texte de remplacement.
 * Macros:
 * FOO = maintenant il est temps
 * de faire de bonnes choses
 * BAR = bar
 * MAGENTA = &lt;font color=magenta&gt;&lt;/font&gt;

Programmation D/Annexes
Programme D pour connaitre la taille des types.
import tango.io.Stdout;
void main() 
 Stdout.formatln("byte\t{}\t\t\t\t{}\t\t\t{}\t{}" , byte.min , byte.max , byte.sizeof , byte.alignof);
 Stdout.formatln("ubyte\t{}\t\t\t\t{}\t\t\t{}\t{}" , ubyte.min , ubyte.max , ubyte.sizeof , ubyte.alignof);
 Stdout.formatln("short\t{}\t\t\t\t{}\t\t\t{}\t{}" , short.min , short.max , short.sizeof , short.alignof);
 Stdout.formatln("ushort\t{}\t\t\t\t{}\t\t\t{}\t{}" , ushort.min , ushort.max , ushort.sizeof , ushort.alignof);
 Stdout.formatln("int\t{}\t\t\t{}\t\t{}\t{}" , int.min , int.max , int.sizeof , int.alignof);
 Stdout.formatln("uint\t{}\t\t\t\t{}\t\t{}\t{}" , uint.min , uint.max , uint.sizeof , uint.alignof);
 Stdout.formatln("long\t{}\t\t{}\t{}\t{}" , long.min , long.max , long.sizeof , long.alignof);
 Stdout.formatln("ulong\t{}\t\t\t\t{}\t{}\t{}" , ulong.min , ulong.max , ulong.sizeof , ulong.alignof);
 Stdout.formatln("float\t{}\t\t\t{}\t\t{}\t{}" , float.min , float.max , float.sizeof , float.alignof);
 Stdout.formatln("ifloat\t{}\t\t\t{}\t\t{}\t{}" , ifloat.min , ifloat.max , ifloat.sizeof , ifloat.alignof);
 Stdout.formatln("double\t{}\t\t\t{}\t\t{}\t{}" , double.min , double.max , double.sizeof , double.alignof);
 Stdout.formatln("idouble\t{}\t\t\t{}\t\t{}\t{}" , idouble.min , idouble.max , idouble.sizeof, idouble.alignof);
 Stdout.formatln("real\t{}\t\t\t{}\t\t{}\t{}" , real.min , real.max , real.sizeof , real.alignof);
 Stdout.formatln("ireal\t{}\t\t\t{}\t\t{}\t{}" , ireal.min , real.max , ireal.sizeof , ireal.alignof);
 Stdout.formatln("cfloat\t{}\t\t{}\t\t\t{}\t{}" , cfloat.min , real.max , cfloat.sizeof , cfloat.alignof);
 Stdout.formatln("cdouble\t{}\t\t{}\t\t{}\t{}" , cdouble.min , real.max , cdouble.sizeof, cdouble.alignof);
 Stdout.formatln("creal\t{}\t{}\t\t{}\t{}" , creal.min , real.max , creal.sizeof , creal.alignof);
pour le compiler simplement :
 $ ldc test.d
puis ensuite lancez-le :
 $ ./test.d
Exemple du pattern Singleton en D.
Voici un patron de classe ("class template") écrit en D du patron Singleton :
class Singleton(T) 
 public
 static T getSingleton() // La méthode static qui retourne une instance 
 if(_instance is null) // Si il n'y a pas encore d'instance 
 _instance = new T;
 return _instance;
 private
 this()
 _instance = cast(T) this;
 ~this()