D (programovací jazyk)

D

Paradigma	multiparadigmatický: aspektově orientovaný, objektově orientovaný, imperativní, funkcionální, generický, paralelní
Vznik	8. prosince 2001[1]
Vývojář	Walter Bright, Andrei Alexandrescu (od roku 2006)
Poslední verze	2.109.0[2][3] (1. června 2024[3])
Typová kontrola	statická, silná, inferentní
Hlavní implementace	DMD (referenční implementace), GDC, LDC
Ovlivněn jazyky	C++, C#, Java, Eiffel, Python, Ruby
Ovlivnil jazyky	MiniD, DScript, Vala, Qore
OS	DMD: Linux, FreeBSD, Windows, macOS, GDC, LDC: UN*X
Licence	GPL/Artistic (DMD frontend), Boost (standardní knihovna a runtime), Dostupný kód (DMD backend), Plně open-source (LDC a GDC)[4]
Web	dlang.org
Přípona souboru	.d

D je multiparadigmatický, aspektově a objektově orientovaný, imperativní a systémový programovací jazyk. Jeho autoři jsou Walter Bright z firmy Digital Mars a Andrei Alexandrescu. Vychází z jazyka C++, ale zároveň se liší. Jazyk D přestavěl některé rysy C++ a je ovlivněn jazyky Java, C#, Eiffel a Python. Stabilní verze 1.0 byla vydána 2. ledna 2007.

Designové cíle jazyka D jsou zkombinovat výkon kompilovaných jazyků s bezpečností a expresivní silou moderních dynamických jazyků. Idiomatický kód v D je obvykle stejně rychlý jako ekvivalentní kód C++, ale zároveň je kratší a paměťově bezpečný. Automatické odvození typu a automatická správa paměti umožňují rychlejší vývoj, přičemž kontrola mezí, design by contract a typový systém připravený na paralelní programování, pomáhají omezit počet chyb.

Programovací jazyk D se poučil tam, kde má v praxi C++ problémy. I když používá mnoho konceptů jazyka C++, tak zároveň se některých zbavuje, a tudíž není kompatibilní se zdrojovým kódem C++. Přidává do funkcionality C++ implementací design by contract, unit testy, pravé moduly, mixiny, automatická správa paměti, first class pole, asociativní pole, dynamická pole, rozdělování polí, vnořené funkce, vnořené třídy, closures a lambda funkce, anonymní funkce, interpretaci jazyka při kompilaci, pozdní inicializace a změněnou syntaxi šablon. D může být stejně jako C++ použit pro nízkoúrovňové programování díky zabudované podpoře inline assembleru. Vícenásobná dědičnost je podobně jako v Javě realizována pomocí rozhraní. Syntaxe deklarace, příkazů a výrazů je stejná, jako v C++.

Vestavěný inline assembler představuje zásadní rozdíl mezi převážně systémovým D a aplikačními jazyky jako Java a C#. Inline assembler umožňuje programátorovi vkládat v podstatě strojový kód příslušného procesoru, což je technika používaná zejména programátory píšící systémový software pro přímý přístup k hardware. To je zapotřebí zejména při programování operačních systémů a ovladačů zařízení.

D má zabudovanou podporu dokumentačních komentářů a podporuje automatické generování dokumentace k programu.

byte (8 bitů)

short (16 bitů)

int (32 bitů)

long (64 bitů)

Bezznaménkové typy se deklarují pomocí prefixu u (například uint)

void (žádný typ ani hodnota)

bool (buď true nebo false)

float (32 bitů)

double (64 bitů)

real (největší možný rozsah na dané platformě)

Pomocí prefixů c a i lze deklarovat imaginární nebo komplexní čísla (například ifloat, cfloat). Literály imaginárních čísel mají sufix i, například 1.0i.

char (8 bitů)

wchar (16 bitů)

dchar (32 bitů)

Indexují se od nuly.

Statická: mají konstantní velikost. Deklarují se takto: datový_typ[velikost].

Dynamická: mají proměnnou velikost. Deklarují se takto: datový_typ[].

Řetězce jsou aliasy na dynamická pole neměnných znaků: string je totéž jako immutable(char)[].

Mohou být indexována čímkoli, nejen číslem. Deklarují se takto: datový_typ[indexovací_typ].

Datové typy mají vlastnosti. Přistupuje se k nim takto: typ.atribut, nebo proměnná.atribut.

Atributy, které mají všechny typy:

.init implicitní hodnota neinicializované proměnné

.sizeof velikost v bajtech

.alignof zarovnání v paměti

byte a;
int b;
float c;
a.sizeof;//1
b.sizeof;//4
c.sizeof;//4

Atributy celočíselných typů:

.init nula

.max nejvyšší možná hodnota

.min nejnižší možná hodnota

int.init;//0
int a=int.max;
int b=int.min;
int c=123;
int d=a+c;//Přetečení, D nekontroluje, zda se hodnota vejde
int e=b-c;//Podtečení, D nekontroluje, zda se hodnota vejde

Atributy desetinných čísel:

.init to samé co .nan

.nan neplatná hodnota, výsledek dělení nuly nulou

.infinity nekonečno, výsledek dělení nenulového čísla nulou

.dig přesnost v desetinných číslech

.re reálná část

.im imaginární část

float.init;//float.nan
cfloat a=5.0+2.0i;
ifloat b=a.im;//2.0i
float c=a.re;//5.0
float d=c/0.0;//float.inf
float e=0.0/0.0;//float.nan

Atributy polí:

.length délka pole (u dynamického ji lze měnit: pole.length=nová_délka)

.ptr ukazatel na první prvek pole

.dup vrátí nově vytvořené dynamické pole, do něhož překopíruje současné pole

.idup to samé co .dup, ale nové pole bude neměnné

.sort seřadí pole

.reverse převrátí pole

int[5] a=[1,2,3,4,5];
a.length;//5
int[] b=a.dup;//Dynamické pole, kopie pole a
b.length;//5
b.length=12;//Změna velikosti pole
a.ptr;//Ukazatel na počátek pole
b.reverse;//b==[5,4,3,2,1]
immutable(int)[] c=b.idup;//Neměnná kopie

Deklarují se klíčovým slovem struct za které se napíše jméno struktury a pak ve složených závorkách všechny členské proměnné a metody. Struktury v D mohou obsahovat i statické proměnné a metody.

Příklad:

import std.conv;

struct Osoba
{
    int vek;
    string jmeno;
    static Osoba nejstarsi;
    string predstav_se()
    {
        //Textove retezce a pole se spojuji operatorem ~
        //to!string je funkce která převede vek na string
        return "Jsem "~jmeno~" a mám "~to!string(vek)~" let.";
    }
    void zestarni()
    {
        ++vek;
        if(vek>nejstarsi.vek)
        {
            nejstarsi=this;
        }
    }
    static string predstav_nejstarsiho()
    {
        return "Jmenuje se " ~ nejstarsi.jmeno ~ " a je starý " ~ nejstarsi.vek.to!string ~ " let.";
    }
}

//Když jsou uvedeny jména členů, může být inicializace v jiném pořadí, než v deklaraci struktury
Osoba pepa={jmeno:"Josef Novák", vek: 20};
//Pokud se to inicializuje C-stylem, musí být prvky v daném pořadí
Osoba petr={26, "Petr Pupík"};
//Při inicializaci pomocí strukturového literálu musí být inicializace vyhodnotitelná v čase kompilace
Osoba alena=Osoba(65, "Alena Dvořáková");
//Také nemusíme uvést inicializátor vůbec
Osoba jana;//jana.vek==0, jana.jmeno==null
//Potom to můžeme kdykoli inicializovat takto:
jana.jmeno="Jana Svobodová";
jana.vek=15;

Všechny struktury mají vlastnost .tupleof, která vrátí n-tici prvků struktury.

Unie na rozdíl od struktur mají velikost největší položky a jednotlivé členy se v paměti překrývají (statické se nepřekrývají). Deklarují se stejně jako struktury ale místo struct se použije union.

union MojeUnie
{
    byte a;
    int b;
    double c;
}

//Tak:
MojeUnie x={c:0.0};
//Nebo tak:
MojeUnie y;
y.b=0;

Tento program vytiskne předané parametry. Funkce main je vstupní bod programu, a args je pole řetězců obsahující parametry příkazové řádky.

Smyčka foreach projde postupně všechny řetězce v poli args a vypíše je pomocí funkce writefln (formátovaný výstup s odřádkováním). Jednotlivým argumentům ve foreach je automaticky přiřazen datový typ podle kontextu; i datový typ int, line typ string. i slouží jako automatický index určující kolikátým prvkem je právě iterováno.

import std.stdio : writefln;

void main(string[] args)
{
    foreach (i, arg; args)
        writefln("args[%d] = '%s'", i, arg);
}

V tomto článku byl použit překlad textu z článku D (programming language) na anglické Wikipedii.

• Obrázky, zvuky či videa k tématu D na Wikimedia Commons
• D Programming Language – oficiální stránky jazyka D (anglicky)
• Oficiální dokumentace (anglicky)
• Programovací jazyk D – článek na abclinuxu.cz v českém jazyce
• wiki4D – neoficiální wiki zabývající se D (anglicky)
• The D Language LLVM Compiler Updated With Numerous Changes – článek na Phoronix (anglicky)