Podstawy działania Moduły są osobnymi plikami o rozszerzeniu .d, domyślnie wraz z kompilatorem D otrzymujemy duży zestaw modułów podzielonych na kategorie etc, std oraz core.

Importujemy je znanym już poleceniem import:import nazwa_modulu;D pozwala na tworzenie tylko jednego modułu na plik, oraz wymusza zmieszczenie modułu w jednym pliku, można więc (zgodnie z pierwszym akapitem) przyjąć że 1 moduł = 1 plik.

Deklaracja modułu wygląda następująco:module nazwa_modulu;

/* Kod modułu - klasy, metody itp. */Przykładowym wykorzystaniem modułów może być oddzielenie implementacji stosu (niedostępnego domyślnie w D na dzień dzisiejszy, tj. 24 czerwiec 2016) od właściwego programu.

//stack.d module stack;

class Stack(T) { private: T[] tab; public: void push(T val)

tab ~= val;

void pop()

assert(!empty()); tab.length--;

T top()

assert(!empty()); return tab[tab.length - 1];

bool empty()

return tab.length == 0;

//main.d module main;

import std.stdio; import stack;

int main(string[] args) { auto s1 = new Stack!ulong;

long sum = 0;

for(int i = 0; i < 12; i++) s1.push(i * i);

/* Inne operacje na stosie */

while(!s1.empty())

sum += s1.top(); s1.pop();

writeln("Suma elementów ze stosu: ", sum);

return 0; }

Rozwiązywanie konfliktów Język D nie udostępnia rozbudowanych przestrzeni nazw jak C++, co za tym idzie po zaimportowaniu 2 modułów definiujących tą samą metodę (itp.) wywołanie nie będzie jednoznaczne i kompilator poinformuje o konflikcie. By ujednoznacznić obiekt do którego się odwołujemy należy poprzedzić go nazwą modułu i kropką. modul.funkcja();

Prosty przykład:

//add.d module add;

int calculate(int a, int b) { return a + b; }

//sub.d module sub;

int calculate(int a, int b) { return a - b; }

//main.d module main;

import std.stdio; import add; import sub;

int main(string[] args) { int a = 5, b = 3; writefln("a + b = %d\na - b = %d", add.calculate(a, b), sub.calculate(a, b)); return 0; }

Pakiety Dobrą praktyką jest utrzymywanie porządku w modułach z wykorzystaniem pakietów. Są to zwyczajne katalogi, nazwa folderu pełni funkcję nazwy pakietu a by dostać się do modułu należy poprzedzić go nazwą pakietu i kropką. Składnia: import pakiet.modul;

Przykład zastosowania:

// matematyka/add.d module add;

int calculate(int a, int b) { return a + b; }

// matematyka/sub.d module sub;

int calculate(int a, int b) { return a - b; }

//main.d module main;

import std.stdio; import matematyka.add; import matematyka.sub;

int main(string[] args) { /* Wskaźniki na funkcje skracające zapis */ auto add = &matematyka.add.calculate; auto sub = &matematyka.sub.calculate;

int a = 5, b = 3; writefln("a + b = %d\na - b = %d", add(a, b), sub(a, b)); return 0; }

Importowanie pojedynczych klas / funkcji Jak zapewne zauważyłeś mimo sporych nakładów pracy może dojść do konfliktu nazw a wykorzystywanie konkretniejszych wersji (poprzedzonych nazwą modułu i ew. pakietu) lub ich aliasów nie zawsze jest wygodne. Można temu zapobiec korzystając z operatora : w kontekście modułu – dzięki niemu można zaimportować jedynie najpotrzebniejsze funkcjonalności. import pakiet.modul : cos_potrzebnego;

Dobre praktyki Kilka rzeczy (niewymienionych wcześniej) umilających innym programistom korzystanie z naszych modułów i pakietów: Tworzenie modułu o nazwie pakietu, importującego wszystkie moduły z danego pakietu. Komentarze, nazwy klas, funkcji, metod itd. po angielsku. Wszystkie nazwy zwięzłe i jednoznaczne, lepiej nie wzorować się na calculate z przykładów. Zawieranie w jednym module jednej funkcjonalności.