D/Moduły

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.