Programación D - Módulos

Los módulos son los componentes básicos de D. Se basan en un concepto simple. Cada archivo fuente es un módulo. En consecuencia, los archivos individuales en los que escribimos los programas son módulos individuales. De forma predeterminada, el nombre de un módulo es el mismo que su nombre de archivo sin la extensión .d.

Cuando se especifica explícitamente, el nombre del módulo se define mediante la palabra clave del módulo, que debe aparecer como la primera línea sin comentarios en el archivo fuente. Por ejemplo, suponga que el nombre de un archivo fuente es "employee.d". Luego, el nombre del módulo se especifica mediante la palabra clave del módulo seguida de empleado . Es como se muestra a continuación.

module employee;

class Employee {
   // Class definition goes here. 
}

La línea de módulos es opcional. Cuando no se especifica, es el mismo que el nombre del archivo sin la extensión .d.

Nombres de archivos y módulos

D admite Unicode en el código fuente y los nombres de los módulos. Sin embargo, el soporte Unicode de los sistemas de archivos varía. Por ejemplo, aunque la mayoría de los sistemas de archivos de Linux admiten Unicode, es posible que los nombres de los archivos en los sistemas de archivos de Windows no distingan entre mayúsculas y minúsculas. Además, la mayoría de los sistemas de archivos limitan los caracteres que se pueden usar en los nombres de archivos y directorios. Por razones de portabilidad, le recomiendo que utilice solo letras ASCII minúsculas en los nombres de los archivos. Por ejemplo, "employee.d" sería un nombre de archivo adecuado para una clase llamada employee.

En consecuencia, el nombre del módulo también constaría de letras ASCII:

module employee;  // Module name consisting of ASCII letters 

class eëmployëë { }

Paquetes D

Una combinación de módulos relacionados se denomina paquete. Los paquetes D también son un concepto simple: se considera que los archivos fuente que están dentro del mismo directorio pertenecen al mismo paquete. El nombre del directorio se convierte en el nombre del paquete, que también debe especificarse como las primeras partes de los nombres de los módulos.

Por ejemplo, si "employee.d" y "office.d" están dentro del directorio "empresa", especificar el nombre del directorio junto con el nombre del módulo los convierte en parte del mismo paquete:

module company.employee; 
 
class Employee { }

Del mismo modo, para el módulo de oficina:

module company.office; 
 
class Office { }

Dado que los nombres de los paquetes corresponden a los nombres de los directorios, los nombres de los paquetes de módulos que son más profundos que un nivel de directorio deben reflejar esa jerarquía. Por ejemplo, si el directorio "empresa" incluye un directorio "sucursal", el nombre de un módulo dentro de ese directorio también incluiría sucursal.

module company.branch.employee;

Uso de módulos en programas

La palabra clave de importación, que hemos estado usando en casi todos los programas hasta ahora, es para introducir un módulo en el módulo actual:

import std.stdio;

El nombre del módulo también puede contener el nombre del paquete. Por ejemplo, el std. la parte anterior indica que stdio es un módulo que forma parte del paquete std.

Ubicaciones de módulos

El compilador encuentra los archivos del módulo convirtiendo los nombres de los módulos y paquetes directamente en nombres de archivos y directorios.

Por ejemplo, los dos módulos empleado y oficina se ubicarían como "empresa / empleado.d" y "animal / oficina.d", respectivamente (o "empresa \ empleado.d" y "empresa \ oficina.d", según el sistema de archivos) para company.employee y company.office.

Nombres de módulos largos y cortos

Los nombres que se utilizan en el programa se pueden deletrear con los nombres del módulo y del paquete como se muestra a continuación.

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

Los nombres largos normalmente no son necesarios, pero a veces hay conflictos de nombres. Por ejemplo, cuando se hace referencia a un nombre que aparece en más de un módulo, el compilador no puede decidir a cuál se refiere. El siguiente programa está deletreando los nombres largos para distinguir entre dos estructuras de empleados separadas que se definen en dos módulos separados: empresa y universidad. .

El primer módulo de empleados en la empresa de carpetas es el siguiente.

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

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

El segundo módulo de empleados en la carpeta de la universidad es el siguiente.

module college.employee;
  
import std.stdio;  

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

El módulo principal de hello.d debe guardarse en la carpeta que contiene las carpetas de la universidad y la empresa. Es como sigue.

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 palabra clave de importación no es suficiente para que los módulos se conviertan en parte del programa. Simplemente pone a disposición las características de un módulo dentro del módulo actual. Eso es necesario solo para compilar el código.

Para que se cree el programa anterior, también se deben especificar "empresa / empleado.d" y "colegio / empleado.d" en la línea de compilación.

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

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