D (programovací jazyk)

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)[].

Můžou 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;
}