Programação D - Módulos

Módulos são os blocos de construção de D. Eles são baseados em um conceito simples. Cada arquivo de origem é um módulo. Conseqüentemente, os arquivos individuais nos quais escrevemos os programas são módulos individuais. Por padrão, o nome de um módulo é igual ao nome do arquivo sem a extensão .d.

Quando especificado explicitamente, o nome do módulo é definido pela palavra-chave do módulo, que deve aparecer como a primeira linha sem comentário no arquivo de origem. Por exemplo, suponha que o nome de um arquivo de origem seja "funcionário.d". Em seguida, o nome do módulo é especificado pela palavra-chave do módulo seguida por funcionário . É como mostrado abaixo.

module employee;

class Employee {
   // Class definition goes here. 
}

A linha do módulo é opcional. Quando não especificado, é igual ao nome do arquivo sem a extensão .d.

Nomes de arquivos e módulos

D suporta Unicode no código-fonte e nomes de módulo. No entanto, o suporte Unicode de sistemas de arquivos varia. Por exemplo, embora a maioria dos sistemas de arquivos Linux suporte Unicode, os nomes dos arquivos nos sistemas de arquivos Windows podem não distinguir entre letras maiúsculas e minúsculas. Além disso, a maioria dos sistemas de arquivos limita os caracteres que podem ser usados em nomes de arquivos e diretórios. Por motivos de portabilidade, recomendo que você use apenas letras ASCII minúsculas nos nomes dos arquivos. Por exemplo, "funcionário.d" seria um nome de arquivo adequado para uma classe chamada funcionário.

Assim, o nome do módulo também consistiria em letras ASCII -

module employee;  // Module name consisting of ASCII letters 

class eëmployëë { }

Pacotes D

Uma combinação de módulos relacionados é chamada de pacote. Os pacotes D também têm um conceito simples: os arquivos-fonte que estão dentro do mesmo diretório são considerados como pertencentes ao mesmo pacote. O nome do diretório se torna o nome do pacote, que também deve ser especificado como as primeiras partes dos nomes dos módulos.

Por exemplo, se "funcionário.d" e "escritório.d" estiverem dentro do diretório "empresa", a especificação do nome do diretório junto com o nome do módulo os torna parte do mesmo pacote -

module company.employee; 
 
class Employee { }

Da mesma forma, para o módulo de escritório -

module company.office; 
 
class Office { }

Como os nomes dos pacotes correspondem aos nomes dos diretórios, os nomes dos pacotes dos módulos que são mais profundos que um nível de diretório devem refletir essa hierarquia. Por exemplo, se o diretório "empresa" incluísse um diretório "filial", o nome de um módulo dentro desse diretório também incluiria a filial.

module company.branch.employee;

Usando Módulos em Programas

A palavra-chave import, que temos usado em quase todos os programas até agora, é para a introdução de um módulo ao módulo atual -

import std.stdio;

O nome do módulo também pode conter o nome do pacote. Por exemplo, o std. parte acima indica que stdio é um módulo que faz parte do pacote std.

Localizações de Módulos

O compilador encontra os arquivos do módulo convertendo os nomes do pacote e do módulo diretamente em nomes de diretório e arquivo.

Por exemplo, os dois módulos funcionário e escritório estariam localizados como "empresa / funcionário.d" e "animal / escritório.d", respectivamente (ou "empresa \ funcionário.d" e "empresa \ escritório.d", dependendo de o sistema de arquivos) para company.employee e company.office.

Nomes de módulos longos e curtos

Os nomes que são usados no programa podem ser escritos com os nomes dos módulos e pacotes conforme mostrado abaixo.

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

Os nomes longos normalmente não são necessários, mas às vezes há conflitos de nomes. Por exemplo, ao se referir a um nome que aparece em mais de um módulo, o compilador não pode decidir a qual deles se refere. O programa a seguir está soletrando os nomes longos para distinguir entre duas estruturas de funcionários separadas que são definidas em dois módulos separados: empresa e faculdade. .

O primeiro módulo de funcionário na pasta company é o seguinte.

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

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

O segundo módulo de funcionário na faculdade de pasta é o seguinte.

module college.employee;
  
import std.stdio;  

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

O módulo principal em hello.d deve ser salvo na pasta que contém as pastas da faculdade e da empresa. É o seguinte.

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

A palavra-chave import não é suficiente para tornar os módulos partes do programa. Ele simplesmente disponibiliza os recursos de um módulo dentro do módulo atual. Isso é necessário apenas para compilar o código.

Para que o programa acima seja construído, "empresa / funcionário.d" e "faculdade / funcionário.d" também devem ser especificados na linha de compilação.

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

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

↰ Previous page Next page ↱