Cours complet pour apprendre à programmer en D

Les programmes sont toujours démarrés par une entité dans un environnement particulier. L'entité qui démarre le programme peut être l'interpréteur de commandes (shell) où l'utilisateur tape le nom du programme et appuie sur la touche Entrée, ou ça peut être un environnement de développement où le programmeur clique sur le bouton Exécuter, etc.

Le programme communique son code de retour à son environnement par la valeur de retour de main().

Une valeur de retour de 0 veut dire que tout s'est bien passé et n'importe quelle autre valeur indique un certain type d'échec. Bien que le choix de la valeur de retour appartienne au programmeur, la valeur 0 veut toujours dire réussite, par convention.

Les valeurs autres que 0 peuvent avoir différents sens en fonction de chaque programme. Par exemple, le programme Unix ls, qui est utilisé pour lister le contenu des répertoires, retourne 1 pour les erreurs mineures et 2 pour les erreurs sérieuses. Dans beaucoup d'environnements, la valeur de retour du programme qui a été exécuté le plus récemment dans la console peut être vu à travers la variable d'environnement $?. Par exemple, quand on demande à ls de lister un fichier qui n'existe pas, sa valeur de retour non nulle peut être vue avec $? comme ci-dessous.

De plus, même si les exemples suivants affichent des interactions dans une console Linux, elles seraient similaires, mais pas exactement les mêmes dans des consoles d'autres systèmes d'exploitation.

# ls un_fichier_qui_nexiste_pas
ls: impossible `'accéder à un_fichier_qui_n'existe_pas: Aucun fichier ou dossier de ce type
# echo $?
2          ← La valeur de retour de ls

41-1-1. main retourne toujours une valeur▲

void main()
{
    throw new Exception("Il y a eu une erreur.");
}

# ./essai
object.Exception: Il y a eu une erreur.
# echo $?
1

import std.stdio;
 
void main()
{
    writeln("Fait !");
}

# ./essai
Fait !
# echo $?
0

41-1-2. Spécifier la valeur de retour▲

import std.stdio;
 
int main()
{
    int nombre;
    write("Veuillez saisir un nombre entre 3 et 6 : ");
    readf(" %s", &nombre);
 
    if ((nombre < 3) || (nombre > 6)) {
        stderr.writefln("ERREUR : %s n'est pas valide !", nombre);
        return 111;
    }
 
    writefln("Merci d'avoir saisi %s.", nombre);
 
    return 0;
}

# ./essai
Veuillez saisir un nombre entre 3 et 6 : 5
Merci d'avoir saisi 5.
# echo $?
0

# ./essai
Veuillez saisir un nombre entre 3 et 6 : 10
ERREUR : 10 n'est pas valide !
# echo $?
111

Le programme ci-avant utilise le flux stderr. Il est utilisé pour écrire des messages d'erreur. Ce flux est un des trois flux standards :

• stdin : flux d'entrée standard ;
• stdout : flux de sortie standard ;
• stderr : flux d'erreur standard.

Quand un programme est lancé dans une console, normalement les messages qui sont écrits dans stdout et stderr apparaissent tous dans la console. Quand c'est nécessaire, il est possible de rediriger ces sorties individuellement. Ceci est hors du programme de ce chapitre et les détails peuvent varier pour chaque shell.

Il est courant que les programmes prennent des paramètres depuis l'environnement qui les a démarrés. Par exemple, nous venons de passer un nom de fichier en option en ligne de commande à ls. Il y a deux options en ligne de commande dans la ligne suivante :

# ls -l essai
-rwxr-xr-x 1 acehreli users 460668 Nov  6 20:38 essai

L'ensemble des paramètres en ligne de commande et leurs significations sont entièrement définis par le programme. Chaque programme documente son usage, dont la signification de chaque paramètre.

Les arguments qui sont utilisés lors du démarrage d'un programme D sont passés à la fonction main() de ce programme sous la forme d'une tranche de strings. Il suffit de définir main() comme prenant un paramètre de type string[] pour avoir accès aux arguments du programme. Le nom de ce paramètre est souvent appelé args. Le programme suivant affiche tous les arguments qui ont été passés au programme :

import std.stdio;
 
void main(string[] args)
{
    foreach (i, arg; args) {
        writefln("Argument %-3s: %s", i, arg);
    }
}

Lançons ce programme avec des arguments arbitraires :

# ./essai des arguments en ligne de commande 42 --une-option
Argument 0  : ./essai
Argument 1  : des
Argument 2  : arguments
Argument 3  : en
Argument 4  : ligne
Argument 5  : de
Argument 6  : commande
Argument 7  : 42
Argument 8  : --une-option

Le premier argument est toujours le nom du programme, tel que l'utilisateur l'a écrit. Les autres arguments apparaissent dans l'ordre dans lequel ils ont été saisis.

La manière d'utiliser les arguments est complètement du ressort du programme. Le programme suivant affiche ses deux arguments dans l'ordre inverse :

import std.stdio;
 
int main(string[] args)
{
    if (args.length != 3) {
        stderr.writefln("ERREUR ! Utilisation correcte :\n"
                        "  %s mot1 mot2", args[0]);
        return 1;
    }
 
    writeln(args[2], ' ', args[1]);
 
    return 0;
}

Le programme affiche aussi son utilisation correcte s'il n'y a pas exactement deux mots :

# ./essai
ERREUR ! Utilisation correcte :
  ./essai mot1 mot2
# ./essai mot salut
salut mot

C'est tout ce qu'il y a à savoir sur les paramètres et la valeur de retour de main(). Cependant, analyser les arguments est une tâche répétitive. Le module std.getopt est conçu pour aider à analyser les options en lignes de commande du programme.

Certains paramètres comme « mot » et « salut » dans l'exemple précédent sont purement des données utilisées par le programme. D'autres types de paramètres sont appelés options en ligne de commande, et sont là pour changer le comportement du programme. Un exemple d'une option en ligne de commande qu'on a déjà rencontré est -l, qui a été passé à ls.

Les options en ligne de commande rendent les programmes plus utiles en supprimant le besoin qu'un utilisateur humain interagisse avec le programme pour obtenir de lui un comportement particulier. Avec les options en ligne de commande, les programmes peuvent être lancés à partir de scripts et leurs comportements peuvent être spécifiés à travers les options en ligne de commande.

Même si la syntaxe et le sens des arguments en ligne de commande de chaque programme sont spécifiques à ce programme, leur format est plus ou moins standard. Par exemple, en POSIX, les options en ligne de commande commencent par « --» suivi par le nom de l'option, et les valeurs viennent après des caractères « = » :

# ./essai --an-option=17

Le module std.getopt simplifie l'analyse de telles options. Il offre plus de possibilités que celles qui vont être couvertes dans cette section.

Concevons un programme qui affiche des nombres aléatoires. Prenons le minimum, le maximum et le nombre total de ces nombres en arguments du programme. On s'attendra à la syntaxe suivante pour obtenir ces valeurs depuis la ligne de commande :

# ./essai --nombre=7 --minimum=10 --maximum=1

La fonction getopt() analyse et affecte ces valeurs aux variables. Comme quand on utilise readf(), on doit spécifier les adresses des variables au moyen de l'opérateur & :

import std.stdio;
import std.getopt;
import std.random;
 
void main(string[] args)
{
    int nombre;
    int minimum;
    int maximum;
 
    getopt(args,
           "nombre", &nombre,
           "minimum", &minimum,
           "maximum", &maximum);
 
    foreach (i; 0 .. nombre) {
        write(uniform(minimum, maximum + 1), ' ');
    }
 
    writeln();
}

Sortie :

# ./essai --nombre=7 --minimum=10 --maximum=15
11 11 13 11 14 15 10

La plupart des options en ligne de commande de la plupart des programmes ont aussi des syntaxes plus courtes. Par exemple, -c peut avoir le même sens que --nombre. Une syntaxe alternative pour chaque option peut être spécifiée après un caractère « | ». Il peut y avoir plus d'un raccourci par option :

getopt(args,
       "nombre|c", &nombre,
       "minimum|n", &minimum,
       "maximum|x", &maximum);

Il est commun d'utiliser un seul tiret pour la version courte et le caractère « = » est généralement omis.

# ./essai -c7 -n10 -x15
11 13 10 15 14 15 14

getopt() convertit les arguments depuis le type string vers le type de chaque variable. Par exemple, comme la variable nombre ci-dessus est un int, getopt() convertit la valeur spécifiée avec l'argument --nombre en int. Lorsque cela est nécessaire, de telles conversions peuvent aussi être faites explicitement avec to.

Jusqu'à maintenant, nous avons utilisé std.conv.to seulement vers string. to peut en fait convertir depuis n'importe quel type vers n'importe quel type pourvu que cette conversion soit possible. Par exemple, le programme suivant utilise to pour convertir ses arguments vers size_t :

import std.stdio;
import std.conv;
 
void main(string[] args)
{
    // Le nombre par défaut est 10
    size_t nombre = 10;
 
    if (args.length > 1) {
        // Il y a un argument
        nombre = to!size_t(args[1]);
    }
 
    foreach (i; 0 .. nombre) {
        write(i * 2, ' ');
    }
 
    writeln();
}

Le programme produit 10 nombres quand il n'y a pas d'argument spécifié :

# ./essai
0 2 4 6 8 10 12 14 16 18
# ./essai 3
0 2 4

L'environnement dans lequel le programme est démarré fournit des variables que le programme peut utiliser. On peut accéder aux variables d'environnement avec std.process.getenv. Le programme suivant affiche la variable d'environnement PATH.

import std.stdio;
import std.process;
 
void main()
{
    writeln(getenv("PATH"));
}

La sortie :

# ./essai
/usr/local/bin:/usr/bin:/home/acehreli/dmd/linux/bin

std.process.environment donne accès aux variables d'environnement à travers la syntaxe des tableaux associatifs :

import std.process;
// ...
    writeln(environment["PATH"]);

Cependant, environment n'est en réalité pas un tableau associatif. Lorsque c'est nécessaire, environment peut être converti vers un tableau associatif avec toAA() :

string[string] envVars = environment.toAA();

Les programmes peuvent lancer d'autres programmes et devenir l'environnement de ces programmes. La fonction executeShell de module std.process permet cela.

executeShell exécute son paramètre comme s'il avait été saisi dans le terminal. Elle retourne aussi bien le code de retour que la sortie de cette commande dans un n-uplet. Les n-uplets (tuples) sont des structures qui ressemblent aux tableaux ; nous les verrons plus tard dans le chapitre sur les n-upplets.

import std.stdio;
import std.process;
 
void main()
{
    const resultat = executeShell("ls -l deneme");
    const codeRetour = resultat[0];
    const sortie = resultat[1];
 
    writefln("ls a retourné %s.", codeRetour);
    writefln("Sa sortie:\n%s", sortie);
}

Le résultat :

# ./deneme
ls a retourné 0.
Sa sortie:
-rwxrwxr-x. 1 acehreli acehreli 1359178 Apr 21 15:01 deneme

• Même quand elle est définie avec un type de retour void, main() retourne automatiquement 0 en cas de réussite et 1 en cas d'échec.
• stderr est approprié pour afficher des messages d'erreur.
• main() peut prendre des paramètres string[].
• std.getopt facilite l'analyse des options en ligne de commande.
• std.process facilite l'accès aux variables d'environnement et le lancement d'autres programmes.

1. Écrivez une calculatrice qui prend un opérateur et deux opérandes en arguments de la ligne de commande. Le programme doit prendre en charge l'utilisation suivante :

    

   Sélectionnez

   # ./essai 3.4 x 7.8
   26.52

   Parce que le caractère « * » a une signification spéciale sur la plupart des shells, j'ai utilisé « x ». Vous pouvez toujours utiliser « * » tant qu'il est échappé ainsi : « \* » (NDT Ou ainsi : « "*" »).

2. Écrivez un programme qui demande à l'utilisateur quel programme lancer, démarre ce programme et retourne sa valeur de retour.

Les solutionsEnvironnement du Programme - Correction.