Programmation D - Modules

Les modules sont les éléments de base de D. Ils sont basés sur un concept simple. Chaque fichier source est un module. En conséquence, les fichiers uniques dans lesquels nous écrivons les programmes sont des modules individuels. Par défaut, le nom d'un module est le même que son nom de fichier sans l'extension .d.

Lorsqu'il est explicitement spécifié, le nom du module est défini par le mot-clé module, qui doit apparaître comme la première ligne sans commentaire dans le fichier source. Par exemple, supposons que le nom d'un fichier source est "employee.d". Ensuite, le nom du module est spécifié par le mot-clé module suivi de l' employé . C'est comme indiqué ci-dessous.

module employee;

class Employee {
   // Class definition goes here. 
}

La ligne de module est facultative. Lorsqu'il n'est pas spécifié, il est identique au nom de fichier sans l'extension .d.

Noms des fichiers et des modules

D prend en charge Unicode dans le code source et les noms de module. Cependant, la prise en charge Unicode des systèmes de fichiers varie. Par exemple, bien que la plupart des systèmes de fichiers Linux prennent en charge Unicode, les noms de fichiers dans les systèmes de fichiers Windows peuvent ne pas faire la distinction entre les lettres minuscules et majuscules. En outre, la plupart des systèmes de fichiers limitent les caractères pouvant être utilisés dans les noms de fichiers et de répertoires. Pour des raisons de portabilité, je vous recommande de n'utiliser que des lettres ASCII minuscules dans les noms de fichiers. Par exemple, «employé.d» serait un nom de fichier approprié pour une classe nommée employé.

En conséquence, le nom du module serait également composé de lettres ASCII -

module employee;  // Module name consisting of ASCII letters 

class eëmployëë { }

Forfaits D

Une combinaison de modules associés est appelée un package. Les packages D sont également un concept simple: les fichiers source qui se trouvent dans le même répertoire sont considérés comme appartenant au même package. Le nom du répertoire devient le nom du package, qui doit également être spécifié comme première partie des noms de module.

Par exemple, si "employee.d" et "office.d" se trouvent dans le répertoire "société", alors la spécification du nom du répertoire avec le nom du module les fait faire partie du même package -

module company.employee; 
 
class Employee { }

De même, pour le module bureau -

module company.office; 
 
class Office { }

Étant donné que les noms de package correspondent aux noms de répertoire, les noms de package des modules qui sont plus profonds qu'un niveau de répertoire doivent refléter cette hiérarchie. Par exemple, si le répertoire "entreprise" incluait un répertoire "branche", le nom d'un module à l'intérieur de ce répertoire inclurait également la branche.

module company.branch.employee;

Utilisation de modules dans les programmes

Le mot-clé import, que nous avons utilisé dans presque tous les programmes jusqu'à présent, sert à introduire un module dans le module actuel -

import std.stdio;

Le nom du module peut également contenir le nom du package. Par exemple, le fichier std. ci-dessus indique que stdio est un module qui fait partie du package std.

Emplacements des modules

Le compilateur trouve les fichiers de module en convertissant directement les noms de package et de module en noms de répertoire et de fichier.

Par exemple, les deux modules employé et bureau se trouveraient respectivement sous la forme «entreprise / employé.d» et «animal / bureau.d» (ou «entreprise \ employé.d» et «entreprise \ bureau.d», selon le système de fichiers) pour company.employee et company.office.

Noms de modules longs et courts

Les noms utilisés dans le programme peuvent être épelés avec les noms de module et de package comme indiqué ci-dessous.

import company.employee; 
auto employee0 = Employee(); 
auto employee1 = company.employee.Employee();

Les noms longs ne sont normalement pas nécessaires, mais il y a parfois des conflits de noms. Par exemple, lorsqu'il se réfère à un nom qui apparaît dans plus d'un module, le compilateur ne peut pas décider lequel il s'agit. Le programme suivant épelle les noms longs pour faire la distinction entre deux structures d' employés distinctes qui sont définies dans deux modules distincts: entreprise et collège. .

Le premier module employé dans la société de dossier est le suivant.

module company.employee; 
 
import std.stdio;
  
class Employee {
   public: 
      string str; 

   void print() {
      writeln("Company Employee: ",str); 
   } 
}

Le deuxième module employé dans le collège de dossiers est le suivant.

module college.employee;
  
import std.stdio;  

class Employee {
   public: 
      string str;
	
   void print() {
      writeln("College Employee: ",str); 
   } 
}

Le module principal de hello.d doit être enregistré dans le dossier qui contient les dossiers collège et entreprise. C'est comme suit.

import company.employee; 
import college.employee; 
 
import std.stdio;  

void main() {
   auto myemployee1 = new company.employee.Employee();
   myemployee1.str = "emp1"; 
   myemployee1.print();
   
   auto myemployee2 = new college.employee.Employee(); 
   myemployee2.str = "emp2"; 
   myemployee2.print(); 
}

Le mot-clé import n'est pas suffisant pour que les modules deviennent des parties du programme. Il met simplement à disposition les fonctionnalités d'un module à l'intérieur du module actuel. Cela est nécessaire uniquement pour compiler le code.

Pour que le programme ci-dessus soit créé, «entreprise / employé.d» et «collège / employé.d» doivent également être spécifiés sur la ligne de compilation.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

$ dmd hello.d company/employee.d college/employee.d -ofhello.amx 
$ ./hello.amx 
Company Employee: emp1 
College Employee: emp2