D (Programmiersprache)

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
D
Paradigmen: imperativ, objektorientiert, funktional, parallel, generisch, modular
Erscheinungsjahr: 2007
Entwickler: Walter Bright
Aktuelle Version: 1.076 (D1) und 2.066.1 (D2)  (15. Oktober 2014[1])
Typisierung: Stark, statisch
Wichtige Implementierungen: DMD[2], GDC[3], LDC
Beeinflusst von: C, C++, Java, C#, Python
Beeinflusste: DScript, MiniD, Qore
dlang.org

D ist eine Programmiersprache, die sich äußerlich stark an C++ anlehnt.

D wird seit 1999 von Walter Bright entwickelt und wurde am 3. Januar 2007 in der stabilen Version 1.0 veröffentlicht.[4]

Vom 17. Juni 2007 bis Ende 2010 wurde die Version 2 von D entwickelt, welche neue Features wie Closures und pure Funktionen, sowie das funktionale Paradigma enthält. Zum Release der neuen Version wurde das Buch D Programming Language von Andrei Alexandrescu veröffentlicht.

Im Februar 2012 war die Tango-Bibliothek vollständig verwendbar und als Beta-Version veröffentlicht.

Sprachmittel[Bearbeiten]

D übernimmt die meisten Sprachmittel der Sprache C, verzichtet im Gegensatz zu C++ aber auf die Kompatibilität dazu. Dadurch soll die Übernahme von Entwurfsnachteilen vermieden werden, durch ABI-Kompatibilität sind aber trotzdem alle in C geschriebenen Programme und Bibliotheken nutzbar. Der Aufruf von C++-Code unterliegt dagegen gewissen Einschränkungen.[5]

D ist eine objektorientierte, imperative Programmiersprache, die auch ab D 2.0 Möglichkeiten der funktionalen Programmierung innerhalb einer imperativen Programmiersprache bietet, und verfügt über Klassenvorlagen (templates) und überladbare Operatoren. Gegenüber C++ bietet es außerdem Design by contract, Module und eine integrierte automatische Speicherbereinigung.

Programme können in D ohne Zeiger geschrieben werden. So bestehen Felder transparent sowohl aus dem Ort ihrer Daten als auch aus ihrer Länge, wodurch Zeigerarithmetik überflüssig ist und die Zulässigkeit von Feldzugriffen zur Laufzeit überprüft werden kann. Im Gegensatz zu Java ist es aber dennoch möglich, Zeiger bei Bedarf wie in C zu benutzen und so maschinennah zu programmieren.

Compiler[Bearbeiten]

DMD, der Digital Mars D-Compiler,[2] ist die Referenzimplementierung von Walter Bright und für die x86/x86-64-Versionen von Windows, Linux, Mac OS X und FreeBSD erhältlich. Die 64-Bit-Version für Windows erfordert momentan eine installierte Microsoft-Visual-C++-Toolchain.

Die wichtigsten inoffiziellen Übersetzer mit alternativen Backends sind das auf GCC aufbauende GDC[3] sowie LDC,[6] das sich auf die Qualitäten von LLVM stützt. Neben der hohen Effizienz des generierten Maschinencodes ermöglichen diese Backends außerdem die Bedienung von x86-64- und verschiedener anderer Architekturen.

Inzwischen wurden auch zwei Compiler für D in D selbst programmiert: Dil[7] und Dang,[8] die kompatibel zu LLVM sind. Ein Codegenerator für die .NET-Plattform stellt eher einen Machbarkeitsnachweis dar als einen funktionstüchtigen Übersetzer.[9]

Entwicklungsumgebungen[Bearbeiten]

D wird zunehmend von verschiedenen IDEs unterstützt. Zum Einsatz kommen unter anderen die Editoren Entice Designer, Emacs, Vim, Scite, Scite4D, Smultron, TextMate, Zeus und Geany. Vim und Scite4D unterstützen Syntaxhervorhebung und Autovervollständigung. Für TextMate existiert eine Erweiterung, und Code::Blocks unterstützt D teilweise.

Darüber hinaus gibt es noch Plugins für andere IDEs: Eclipse unterstützt D mit dem Plugin DDT[10], für MonoDevelop gibt es Mono-D.[11]

Zudem gibt es in D geschriebene IDEs, wie Poseidon, das Autovervollständigung sowie Refactoring unterstützt und einen integrierten Debugger hat. Ein Debugger für D ist Ddbg für Windows, das mit den verschiedensten IDEs oder von der Kommandozeile aus benutzt werden kann. Der kommerzielle ZeroBUGS-Debugger für Linux unterstützt D experimentell; er bringt eine eigene GUI mit.

Programmbeispiel[Bearbeiten]

Hallo Welt
Hauptartikel: Hallo Welt in D
Ausgabe der Kommandozeilenparameter
 // Programm, geschrieben in D2, das seine Parameter ausgibt
 import std.stdio;  // importiert die Funktion writefln()
 void main(string[] args)
 {
   foreach(i, arg; args)
     writefln("Parameter %d = '%s'", i, arg); // Jeder Eintrag im Feld args wird ausgegeben.
 }

Der main-Funktion werden die Kommandozeilenparameter als ein Feld von Zeichenketten (Strings) übergeben. Ruft man dieses Programm unter Windows mit beispiel.exe -win -s auf, dann gibt es diesen Text in einem Konsolen-Fenster aus:

Parameter 0 = 'beispiel.exe'
Parameter 1 = '-win'
Parameter 2 = '-s'
Unittests

Unittests[12] sind Blöcke, die Programmcode enthalten welcher eine Funktion auf unterschiedliche Fälle testen soll. Zusätzlich kann der in Unittest-Code als Beispiel in der von DDOC[13] generierten Dokumentation aufgeführt werden.[14] In D werden die unittests unmittelbar vor der Main-Funktion ausgeführt [15]

/++
    Ermittelt, ob eine Zahl eine Primzahl ist.
    Hinweis: Das Verfahren ist nicht optimal.
Params:
    a: die zu testende Zahl
Returns:
    true, falls die Zahl eine Primzahl ist;
    false, ansonsten
+/
bool isPrime(long a)
{
    if (a <= 1) 
        return false;

    for (long n = 2; n <= a / 2; ++n)
        // a ist keine Primzahl, da a restlos durch n teilbar ist
        if (a % n == 0)
            return false;
    // a war nicht teilbar -> a muss eine Primzahl sein
    return true;
}
 
unittest
{
    // Die Bedingung in dem assert Aufruf muss erfüllt werden (wahr sein). 
    // Ansonsten ist ein Fehler aufgetreten und das Programm bricht ab.
    assert(isPrime( 0) == false);
    assert(isPrime( 1) == false);
    assert(isPrime( 2) == true);
    assert(isPrime( 7) == true);
    assert(isPrime( 4) == false);
    assert(isPrime(10) == false);
}

Unittests sind Testfunktionen, die das Verhalten einer Funktion auf alle Möglichkeiten testen sollen. Damit unittests ausgeführt werden, muss ein Compiler-Flag gesetzt werden (-unittest bei DMD)

Generische Programmierung[Bearbeiten]

Zusätzlich zu Mixin-Templates und Mixins[16] implementiert die Programmiersprache D alle gängigen Templatearten[17].

Funktionstemplates
 // Diese Funktion liefert als Return-Wert das Maximum der beiden Parameter
 // Der Template Datentyp T wird dabei automatisch (falls möglich) erkannt
 T max(T)(T a, T b)
 {
     if( a < b )
         return b;
     else
         return a;
 }

 unittest 
 {
     assert(max(2, 3) == 3);
     assert(max('a','c') == 'c');
     assert(max(3.1415, 2.61) == 3.1415);
     assert(max("Hallo", "Abc") == "Hallo");
 }
Meta-Programmierung
// Berechnet das Ergebnis von basis^exp
template Pow(double basis, uint exp)
{
    static if( exp > 0 ) 
        enum Pow = basis * Pow!(basis, exp-1);
    else  
        enum Pow = 1;
}

import std.stdio;
void main()
{
    // Da pow ein Template ist wird das Ergebnis zur Compilezeit bestimmt
    // und steht zur Laufzeit als Konstante zur Verfuegung
    
    writeln("2.7182^3 = ", Pow!(2.7182, 3));
    writeln("3.1415^5 = ", Pow!(3.1415, 5));
}

Ausgabe:

2.7182^3 = 20.0837
3.1415^5 = 305.975
Compile Time Function Execution

Die Funktionsausführung zur Kompilierungszeit (CTFE), kann Initialierungslisten, Lookup-Tables usw. zur Kompilierungszeit erstellen. Zudem kann der generierte Programmcode einer CTFE[18] Funktion in das Programm mithilfe von Mixins[19] eingebunden werden.

T sum(T)(T[] elems)
{
    T res;
    foreach(elem; elems)
        res += elem;
    return res;
}

enum arr = [10, 13, 14, 15, 18, 19, 22, 24, 25, 36];
// summeVonArr ist zur Kompilierungszeit bekannt.
enum summeVonArr = sum(arr); // == 196

// Statisches integer Array mit der Laenge 196 
int[summeVonArr] staticArray;

Literatur[Bearbeiten]

Weblinks[Bearbeiten]

Einzelnachweise[Bearbeiten]

  1. D 2.0 Change Log
  2. a b DMD (Digital Mars D): DMD
  3. a b GDC (GNU D Compiler):GDC
  4. Heise Online: Eleganter programmieren: D ist da, 3. Januar 2007 – 14:52
  5. Interfacing to C++
  6. LDC-Projektseite
  7. DIL-Projektseite
  8. Dang-Projektseite
  9. D Compiler for .NET
  10. DDT-Projektseite
  11. Mono-D
  12. http://dlang.org/unittest.html
  13. http://dlang.org/ddoc.html
  14. http://dlang.org/unittest.html#documented-unittests
  15. http://dlang.org/unittest.html.
  16. http://dlang.org/template-mixin.html
  17. http://dlang.org/template.html
  18. http://dlang.org/function.html#interpretation
  19. http://dlang.org/mixin.html