Cours complet pour apprendre à programmer en D

Dans le chapitre précédent, nous venons de parler des limitations de la fonction info(). Mais malgré tout ce que nous venons de voir, la fonction garde au moins un autre inconvénient : bien qu'elle affiche le temps dans un format lisible, le programmeur devra toujours prendre soin d'expliciter le caractère '-' ainsi que le caractère de fin de ligne.

Il serait plus pratique si les objets TempsDuJour pouvaient être utilisés comme des types fondamentaux dans le code ci-après :

writefln("%s-%s", matin, apresmidi);

En plus d'avoir réduit quatre lignes de code en seulement une, cela aurait aussi pour effet de pouvoir écrire l'objet à n'importe quel flux :

auto fichier = File("temps_information", "w");
fichier.writefln("%s-%s", matin, apresmidi);

La méthode toString() des types définis par l'utilisateur est un peu spéciale : elle est automatiquement appelée pour produire la représentation string des objets. toString() doit impérativement retourner la représentation string de l'objet en question.

Avant de plonger dans les détails, étudions d'abord la définition de la fonction toString() :

import std.stdio;
 
struct TempsDuJour
{
    int heure;
    int minute;
 
    string toString()
    {
        return "a_faire";
    }
}
 
void main()
{
    auto matin = TempsDuJour(10, 0);
    auto apresmidi = TempsDuJour(22, 0);
 
    writefln("%s-%s", matin, apresmidi);
}

Pour le moment, toString() ne produit pas grand-chose, mais l'exécution du code ci-avant montre qu'elle a effectivement été appelée à deux reprises par writefln() :

a_faire-a_faire

Remarquez aussi que info() est désormais redondante vu que toString() offre la même fonctionnalité.

La façon la plus simple d'implémenter toString() serait d'appeler la fonction format(), celle-ci est disponible dans le module std.string. Le fonctionnement de format() est similaire à celui des fonctions d'affichage formaté comme writef(). La seule différence réside dans le fait qu'au lieu d'afficher directement les variables, format() retourne le résultat sous la forme d'une string.

toString() peut donc directement retourner le résultat de format() :

import std.string;
// ...
struct TempsDuJour
{
// ...
    string toString()
    {
        return format("%02s:%02s", heure, minute);
    }
}

Remarquez que toString() retourne uniquement la représentation textuelle de l'objet this. writefln() se charge d'afficher le reste : elle appelle la méthode toString() pour chacun des deux objets tout en prenant soin d'afficher le caractère '-' entre les deux appels, puis termine la ligne :

10:00-22:00

La définition de toString() qui a été expliquée ci-avant ne prend aucun paramètre, elle produit simplement une string et la retourne. Cependant, il existe une autre façon de définir toString(), celle-ci prend en paramètre un delegate. Nous étudierons cette définition plus tard dans le chapitre sur les pointeurs de fonctions, les delegates et les lambdas.

Définissons une méthode qui ajoute une certaine durée aux objets TempsDuJour.

Avant d'aller plus loin, corrigeons d'abord un défaut de conception qui était là tout le temps. Dans le chapitre sur des structures, nous avions vu que l'addition de deux objets TempsDuJour dans ajouterDuree n'avait pas de sens :

TempsDuJour ajouterDuree(in TempsDuJour start,
                    in TempsDuJour duree)    // absurde
{
    // ...
}

Il serait plus naturel d'ajouter une durée à un point dans le temps. En ajoutant par exemple la durée d'un voyage à son temps de départ, on obtiendrait le temps d'arrivée.

D'un autre côté, soustraire deux points dans le temps est une opération naturelle, et dans ce cas le résultat serait une durée.

Le programme ci-après définit une structure Duree d'une précision allant à la minute, ainsi qu'une fonction ajouterDuree() qui l'utilise :

struct Duree
{
    int minute;
}
 
TempsDuJour ajouterDuree(in TempsDuJour debut,
                    in Duree duree)
{
    // Commençons par faire une copie de start
    TempsDuJour resultat = debut;
 
    // Ajoutons-y la durée
    resultat.minute += duree.minute;
 
    // Puis prenons soin de régler les débordements
    resultat.heure += resultat.minute / 60;
    resultat.minute %= 60;
    resultat.heure %= 24;
 
    return resultat;
}
 
unittest
{
    // Un test banal
    assert(ajouterDuree(TempsDuJour(10, 30), Duree(10))
        == TempsDuJour(10, 40));
 
    // Un temps à minuit
    assert(ajouterDuree(TempsDuJour(23, 9), Duree(51))
        == TempsDuJour(0, 0));
 
    // Un temps dans le jour suivant
    assert(ajouterDuree(TempsDuJour(17, 45), Duree(8 * 60))
        == TempsDuJour(1, 45));
}

Maintenant, redéfinissons cette fonction sous la forme d'une méthode. Jusqu'à présent, ajouterDuree() retournait un nouvel objet à chaque appel. Définissons donc une méthode incrementer() qui modifiera directement l'objet this :

struct Duree
{
    int minute;
}
 
struct TempsDuJour
{
    int heure;
    int minute;
 
    string toString()
    {
        return format("%02s:%02s", heure, minute);
    }
 
    void $(HILITE incrementer)(in Duree duree)
    {
        minute += duree.minute;
 
        heure += minute / 60;
        minute %= 60;
        heure %= 24;
    }
 
    unittest
    {
        auto temps = TempsDuJour(10, 30);
 
        // Un test banal
        temps$(HILITE .incrementer)(Duree(10));
        assert(temps == TempsDuJour(10, 40));
 
        // 15 heures plus tard devra être dans le jour suivant
        temps$(HILITE .incrementer)(Duree(15 * 60));
        assert(temps == TempsDuJour(1, 40));
 
        // 22 heures et 20 minutes devra être à minuit
        temps$(HILITE .incrementer)(Duree(22 * 60 + 20));
        assert(temps == TempsDuJour(0, 0));
    }
}

incrementer() incrémente la valeur de l'objet dépendamment de la durée qu'on lui passe. Plus tard, nous étudierons comment la surcharge d'opérateur (operator overloading) va nous permettre d'ajouter une durée à l'aide de l'opérateur += :

temps += Duree(10);    // sera expliqué dans un chapitre ultérieur

Notez également que les blocs de tests unitaires unittest peuvent être écrits à l'intérieur des définitions des struct aussi, c'est surtout le cas lorsque l'on souhaite tester ses méthodes. Mais il reste tout de même possible de déplacer de tels blocs unittest en dehors du corps de la structure :

struct TempsDuJour
{
    // ... définition de la structure ...
}
 
unittest
{
    // ... tests de la structure ...
}