Programmazione D - Moduli

I moduli sono gli elementi costitutivi di D. Si basano su un concetto semplice. Ogni file sorgente è un modulo. Di conseguenza, i singoli file in cui scriviamo i programmi sono singoli moduli. Per impostazione predefinita, il nome di un modulo è lo stesso del suo nome file senza l'estensione .d.

Quando specificato esplicitamente, il nome del modulo è definito dalla parola chiave module, che deve apparire come la prima riga non di commento nel file di origine. Ad esempio, supponiamo che il nome di un file di origine sia "dipendente.d". Quindi il nome del modulo viene specificato dalla parola chiave del modulo seguita da dipendente . È come mostrato di seguito.

module employee;

class Employee {
   // Class definition goes here. 
}

La linea del modulo è opzionale. Quando non specificato, è uguale al nome del file senza l'estensione .d.

Nomi di file e moduli

D supporta Unicode nel codice sorgente e nei nomi dei moduli. Tuttavia, il supporto Unicode dei file system varia. Ad esempio, sebbene la maggior parte dei file system Linux supporti Unicode, i nomi dei file nei file system Windows potrebbero non distinguere tra lettere maiuscole e minuscole. Inoltre, la maggior parte dei file system limita i caratteri che possono essere utilizzati nei nomi di file e directory. Per motivi di portabilità, ti consiglio di utilizzare solo lettere ASCII minuscole nei nomi dei file. Ad esempio, "dipendente.d" sarebbe un nome file adatto per una classe denominata dipendente.

Di conseguenza, il nome del modulo sarebbe composto anche da lettere ASCII -

module employee;  // Module name consisting of ASCII letters 

class eëmployëë { }

Pacchetti D.

Una combinazione di moduli correlati è chiamata pacchetto. Anche i pacchetti D sono un concetto semplice: i file sorgente che si trovano all'interno della stessa directory sono considerati appartenenti allo stesso pacchetto. Il nome della directory diventa il nome del pacchetto, che deve essere specificato anche come prime parti dei nomi dei moduli.

Ad esempio, se "dipendente.d" e "ufficio.d" si trovano all'interno della directory "azienda", specificare il nome della directory insieme al nome del modulo li rende parte dello stesso pacchetto -

module company.employee; 
 
class Employee { }

Allo stesso modo, per il modulo ufficio -

module company.office; 
 
class Office { }

Poiché i nomi dei pacchetti corrispondono ai nomi delle directory, i nomi dei pacchetti dei moduli che sono più profondi di un livello di directory devono riflettere quella gerarchia. Ad esempio, se la directory "azienda" include una directory "filiale", il nome di un modulo all'interno di quella directory includerà anche la filiale.

module company.branch.employee;

Utilizzo dei moduli nei programmi

La parola chiave import, che abbiamo utilizzato finora in quasi tutti i programmi, è per introdurre un modulo nel modulo corrente -

import std.stdio;

Il nome del modulo può contenere anche il nome del pacchetto. Ad esempio, il file std. la parte sopra indica che stdio è un modulo che fa parte del pacchetto std.

Posizioni dei moduli

Il compilatore trova i file del modulo convertendo i nomi del pacchetto e del modulo direttamente in nomi di directory e file.

Ad esempio, i due moduli dipendente e ufficio si trovano rispettivamente come "azienda / impiegato.d" e "animale / ufficio.d" (o "azienda \ impiegato.d" e "azienda \ ufficio.d", a seconda il file system) per company.employee e company.office.

Nomi dei moduli lunghi e brevi

I nomi utilizzati nel programma possono essere indicati con i nomi dei moduli e dei pacchetti come mostrato di seguito.

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

I nomi lunghi normalmente non sono necessari, ma a volte ci sono conflitti di nome. Ad esempio, quando si fa riferimento a un nome che appare in più di un modulo, il compilatore non può decidere quale si intende. Il seguente programma sta spiegando i nomi lunghi per distinguere tra due strutture dipendenti separate che sono definite in due moduli separati: azienda e college. .

Il primo modulo dipendente nella cartella azienda è il seguente.

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

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

Il secondo modulo dipendente nella cartella college è il seguente.

module college.employee;
  
import std.stdio;  

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

Il modulo principale in ciao.d dovrebbe essere salvato nella cartella che contiene le cartelle del college e dell'azienda. È il seguente.

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(); 
}

La parola chiave import non è sufficiente per far diventare i moduli parte del programma. Rende semplicemente disponibili le funzionalità di un modulo all'interno del modulo corrente. Questo è necessario solo per compilare il codice.

Affinché il programma sopra possa essere costruito, è necessario specificare anche "azienda / dipendente.d" e "college / dipendente.d" nella riga di compilazione.

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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