imported>Invisigoth67: form

2025-11-21T14:08:33Z

form

Neue Seite

{{Infobox Programmiersprache
| Name = D
| Logo = [[Datei:D Programming Language logo.svg|120px]]
| Beschreibung =
| Paradigma = [[Imperative Programmierung|imperativ]], [[Objektorientierte Programmierung|objektorientiert]], [[Funktionale Programmierung|funktional]], [[Parallele Programmierung|parallel]], [[Generische Programmierung|generisch]], [[Modulare Programmierung|modular]]
| Erscheinungsjahr = 2007
| Designer =
| Entwickler = Walter Bright,<br />Andrei Alexandrescu (ab D 2.0)
| AktuelleVersion =
| AktuelleVersionFreigabeDatum =
| AktuelleVorabVersion =
| AktuelleVorabVersionFreigabeDatum =
| Typisierung = [[Starke Typisierung|Stark]], [[Statische Typisierung|statisch]]
| Implementierung = [https://dlang.org/download.html DMD], [https://gdcproject.org/ GDC], [https://github.com/ldc-developers/ldc/releases LDC]
| Dialekte =
| Standardisierungen =
| Beeinflusst_von = [[C (Programmiersprache)|C]], [[C++]], [[Eiffel (Programmiersprache)|Eiffel]], [[Java (Programmiersprache)|Java]], [[Python (Programmiersprache)|Python]], [[Ruby (Programmiersprache)|Ruby]]<ref>[https://www.digitalmars.com/d/1.0/ D Programming Language 1.0, Intro.] Digital Mars</ref>
| Beeinflusste = DScript, Genie, MiniD, Qore, [[Swift (Programmiersprache)|Swift]], [[Vala (Programmiersprache)|Vala]]
| Betriebssystem = Plattformunabhängig
| Lizenz = [https://www.boost.org/users/license.html Boost Software License]<ref name="bsl">[https://dlang.org/faq.html#q5 FAQ – Is D open source?]</ref><ref name="bsl2">[https://github.com/dlang/dmd/blob/master/LICENSE.txt Lizenz im Compiler-Quellcode]</ref><ref name="bsl3">[https://github.com/dlang/druntime/blob/master/LICENSE.txt Lizenz der Laufzeitbibliothek]</ref><ref name="bsl4">[https://github.com/dlang/phobos/blob/master/LICENSE_1_0.txt Lizenz der Standardbibliothek]</ref>
| Website = [https://dlang.org/ dlang.org]
}}

'''D''' ist eine seit 1999 von Walter Bright entwickelte [[Programmiersprache]] mit [[Objektorientierte Programmierung|objektorientierten]], [[Imperative Programmierung|imperativen]] sowie [[Deklarative Programmierung|deklarativen]] Sprachelementen. D wurde am 3. Januar 2007 in der stabilen Version 1.0 veröffentlicht.<ref>Heise Online: ''[https://www.heise.de/newsticker/meldung/Eleganter-programmieren-D-ist-da-130475.html Eleganter programmieren: D ist da]'', 3. Januar 2007 – 14:52</ref> Sie lehnt sich äußerlich stark an [[C++]] an, jedoch ohne vollständige sprachliche [[Kompatibilität (Technik)|Kompatibilität]] dazu.

Vom 17. Juni 2007 bis Ende 2010 wurde die Version 2 von D entwickelt, die neue Funktionalität wie [[Closure (Funktion)|Closures]] und dem Begriff [[Referentielle Transparenz|referentiell transparenter]] [[Funktion (Programmierung)|Funktionen]] sowie das funktionale Paradigma ergänzt, aber nicht kompatibel zum Vorgänger ist. Mit der Freigabe der neuen Version wurde auch das Buch ''The D Programming Language'' von [[Andrei Alexandrescu]] veröffentlicht, der entscheidend beim Design der Sprache mitwirkte.

== Sprachmittel ==
D übernimmt die meisten Sprachmittel der Sprache [[C (Programmiersprache)|C]], verzichtet im Gegensatz zu C++ aber auf die Kompatibilität dazu. Dadurch soll die Übernahme von Entwurfsnachteilen vermieden werden. Durch [[Binärschnittstelle|ABI]]-Kompatibilität sind aber trotzdem alle in C geschriebenen Programme und Bibliotheken nutzbar. Die Anbindung von C++-Code unterliegt dagegen Einschränkungen.<ref>[https://dlang.org/spec/cpp_interface.html Interfacing to C++]</ref>

D ist eine objektorientierte, imperative Programmiersprache, die ab D 2.0 auch Möglichkeiten der [[Funktionale Programmierung|funktionalen Programmierung]] innerhalb einer imperativen Programmiersprache bietet, und verfügt über [[Template (C++)|Klassenvorlagen]] und [[Überladen|überladbare]] Operatoren. D bietet [[Design by contract]] und [[Modul (Software)|Module]]. [[Garbage Collection|Automatische Speicherbereinigung]] ist im Gegensatz zu z. B. C/C++ fester, wenn auch prinzipiell optionaler Bestandteil der Sprache, wobei geplant ist, die Laufzeitumgebung selbst insoweit von dieser zu entkoppeln, dass ein Arbeiten mit D auch in Situationen möglich ist, wo der Einsatz eines Garbage Collectors unmöglich oder unerwünscht ist.<ref>[https://dlang.org/spec/garbage.html ''Garbage Collection''.] dlang.org, abgerufen am 21. September 2019.</ref><ref>Michael Parker: [https://dlang.org/blog/2017/03/20/dont-fear-the-reaper/ ''Don’t Fear the Reaper''] The D Blog, 20. März 2017, abgerufen am 21. September 2019.</ref> Automatische [[Referenzzählung]] wird hingegen nicht unterstützt.<ref>[https://wiki.dlang.org/Memory_Management ''Memory Management''.] im D Wiki, abgerufen am 21. September 2019.</ref>

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

=== Konstante und schreibgeschützte Werte ===

In D werden schreibgeschützte Werte mit <code>const</code>-Datentypen ausgezeichnet. Schreibgeschützt heißt, dass ''über diese Variable'' der Wert nicht verändert werden kann. Das bedeutet jedoch nicht, dass es keine andere Variable gibt, über die eine Änderung stattfinden kann. Dem gegenüber stehen (wirklich) konstante Werte, die mit <code>immutable</code>-Datentypen ausgezeichnet werden. Ist ein Wert <code>immutable</code>, gibt es ''überhaupt keine'' schreibbare Variable auf den Wert.

=== Funktionsattribute ===

In D werden Funktionen mit Funktionsattributen versehen, um anzuzeigen, dass die entsprechende Funktion gewisse Garantien macht (oder auch nicht).
Folgende Attribute stellen Garantien dar:
* <code>pure</code> zeigt an, dass die Funktion referentiell transparent ist.
* <code>nothrow</code> zeigt an, dass die Funktion keine <code>Exception</code> wirft (möglicherweise aber einen <code>Error</code>).
* <code>@nogc</code> zeigt an, dass die Funktion keinen Speicher von der automatischen Speicherverwaltung anfordert und daher keine automatische Speicherbereinigung (Garbage Collection) auslösen kann.
* <code>@safe</code> zeigt an, dass die Funktion keine [[Schutzverletzung|Speicherzugriffsverletzung]] auslösen kann, die zu [[Undefiniertes Verhalten|undefiniertem Verhalten]] führt.<ref>
{{Internetquelle
|titel=Function Safety
|sprache=en
|url=https://dlang.org/spec/function.html#function-safety
|abruf=2021-01-03
}}</ref>
* <code>@live</code> zeigt an, dass die Funktion das Ownership-Borrowing-Modell für die Speicherverwaltung verwendet.<ref>
{{Internetquelle
|titel=Live Functions
|sprache=en
|url=https://dlang.org/spec/ob.html
|abruf=2021-01-03
}}</ref>

Zu <code>@safe</code> gehören die Attribute <code>@system</code> und <code>@trusted</code>.
Unter anderem unterliegen mit <code>@safe</code> gekennzeichnete Funktionen der Beschränkung, nur andere solche Funktionen aufrufen zu dürfen, sowie solche mit <code>@trusted</code>.
Mit <code>@trusted</code> oder <code>@system</code> gekennzeichnete Funktionen dürfen jedoch beliebige Anweisungen ausführen.
Nicht explizit gekennzeichnete Funktionen sind implizit <code>@system</code>.

Normalerweise arbeitet ein Großteil des Programms innerhalb der Grenzen von <code>@safe</code>. Da sich D als Systemprogrammiersprache versteht, wird dem Programmierer nicht die Möglichkeit verwehrt, Anweisungen auszuführen, deren Freiheit von möglichen Speicherzugriffsverletzungen sich der Prüfung durch den Compiler entzieht.
Typischerweise ist eine Funktion <code>@system</code>, wenn sie Speicherzugriffsverletzungen auslöst, wenn sie falsch benutzt wird.
Mit <code>@trusted</code> ausgezeichnete Funktionen bilden eine Zwischenschicht, die <code>@system</code> Code nutzt, aber auf eine Weise, die bekanntermaßen keine Speicherzugriffsverletzungen auslöst. Das wird vom Compiler jedoch nicht maschinell geprüft und es obliegt dem Programmierer oder der [[Qualitätssicherung]], nachzuweisen, dass der <code>@system</code> korrekt verwendet wird.<ref>{{Internetquelle
|titel=SafeD
|sprache=en
|url=https://dlang.org/articles/safed.html
|abruf=2021-01-03
}}</ref>

Ein Beispiel dafür ist die C-Funktion <code>memcpy</code>, die ''n'' Bytes von ''A'' nach ''B'' kopiert. Ist der Puffer ''B'' nicht groß genug, die ''n'' Bytes aufzunehmen, ist eine Speicherzugriffsverletzung möglich. Daher ist Anbindung von <code>memcpy</code> in D <code>@system</code>. Ein geeigneter D-Wrapper nimmt zwei sog. Slices an statt zweier Zeiger und einer Anzahl. Slices bestehen aus einem Zeiger und einer Länge; es kann also überprüft werden, ob der annehmende Puffer groß genug ist. Ein Wrapper, der einen geordneten Programmabsturz herbeiführt, darf somit mit <code>@trusted</code> annotiert werden. Bei Testläufen sollten Falschverwendungen des Wrappers sofort ersichtlich werden.

Ein weiteres Beispiel sind Funktionen mit [[Inline-Assembler]]-Blöcken, da diese sich grundsätzlich einer Überprüfung durch den Compiler entziehen. Möglicherweise ist jedoch offensichtlich, dass ein solcher Block keine unsicheren Speicheroperationen durchführt. Auch dann ist die Annotation <code>@trusted</code> korrekt und sinnvoll.

== Compiler ==
DMD, der [[Digital Mars]] D-Compiler,<ref name="DMD">DMD (Digital Mars D): [https://www.digitalmars.com/d/dcompiler.html DMD]</ref> ist die [[Referenzimplementierung]] von Walter Bright und für die [[x86-Prozessor|x86]]/[[x64|x86-64]]-Versionen von [[Windows]], [[Linux]], [[macOS]] und [[FreeBSD]] erhältlich.

Die wichtigsten Übersetzer mit alternativen [[Compiler#Backend (auch „Synthesephase“)|Backends]] sind der auf [[GNU Compiler Collection|GCC]] aufbauende GDC<ref name="GDC">GDC (GNU D Compiler): [https://gdcproject.org/ GDC]</ref> sowie LDC,<ref>[https://github.com/ldc-developers/ldc ''LDC'' auf GitHub]</ref> das sich auf die Qualitäten von [[LLVM]] stützt. Neben der hohen Geschwindigkeit des generierten Maschinencodes ermöglichen diese [[Front-End und Back-End|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<ref>[http://code.google.com/p/dil/ DIL-Projektseite]</ref> und [[Dang (Compiler)|Dang]],<ref>[http://www.dsource.org/projects/dang Dang-Projektseite]</ref> die kompatibel zu LLVM sind. Ein [[Codegenerator]] für die [[.Net-Framework|.NET]]-Plattform stellt eher einen Machbarkeitsnachweis dar als einen funktionstüchtigen Übersetzer.<ref>{{Webarchiv|url=http://dnet.codeplex.com/ |wayback=20180126042332 |text=D Compiler for .NET |archiv-bot=2022-10-20 19:41:48 InternetArchiveBot }}</ref> Seit Version 9.1 des GCC wird die Sprache D unterstützt.<ref>[http://gcc.gnu.org/gcc-9/changes.html#d GCC 9 Release Series Changes, New Features, and Fixes]</ref>

== Entwicklungsumgebungen ==
D wird zunehmend von verschiedenen [[Integrierte Entwicklungsumgebung|IDEs]] unterstützt. Zum Einsatz kommen unter anderen die Editoren Entice Designer, [[Emacs]], [[Vim]], [[Scite]], Scite4D, [[Smultron]], [[TextMate]], Zeus, [[Geany]] und [[Visual Studio Code]]. Vim und Scite4D unterstützen [[Syntaxhervorhebung]] und [[Autovervollständigen|Autovervollständigung]]. Für TextMate und Visual Studio Code existiert jeweils eine Erweiterung, auch [[Code::Blocks]] unterstützt D teilweise.

Darüber hinaus gibt es noch [[Plug-in]]s für andere IDEs:
[[Eclipse (IDE)|Eclipse]] unterstützt D mit dem Plug-in DDT,<ref>[https://github.com/DDT-IDE/DDT/ ''DDT auf Github'']</ref> für [[MonoDevelop]] gibt es Mono-D.<ref>[https://wiki.dlang.org/Mono-D ''Mono-D'']</ref>

Zudem gibt es in D geschriebene IDEs, wie ''Poseidon'', das Autovervollständigung sowie [[Refactoring]] unterstützt und einen integrierten [[Debugger]] hat. [[WinDbg]] und der [[GNU Debugger]] unterstützen D rudimentär.<ref>[https://dlang.org/windbg.html ''windbg Debugger''] auf dlang.org, abgerufen am 14. Februar 2019.</ref><ref>[https://sourceware.org/gdb/current/onlinedocs/gdb/D.html#D ''Debugging with GDB: D''], abgerufen am 13. Februar 2019.</ref>

== Programmbeispiele ==
; Hallo Welt
{{Hauptartikel|Liste von Hallo-Welt-Programmen/Höhere Programmiersprachen#D|titel1=Hallo Welt in D}}

;Ausgabe der Kommandozeilenparameter
<syntaxhighlight lang="d">
// Programm, geschrieben in D2, das seine Parameter ausgibt
void main(string[] args) @safe
{
// Importiert writefln aus dem Modul std.stdio
import std.stdio : writefln;
// In D können Imports auch in Funktionen stattfinden.

// Jeder Eintrag im Feld args wird ausgegeben.
foreach(i, arg; args)
writefln!"Parameter %d = '%s'"(i, arg);
// Der Format-String wird zur Compilezeit geprüft,
// sodass nur passende Parameter verwendet werden können.
// Werden i und arg vertauscht, kompiliert das Programm nicht.
}
</syntaxhighlight>
Die Annotation <code>@safe</code> bedeutet, dass die Funktion frei von Speicherzugriffsverletzungen ist und der Compiler das überprüfen wird. Sie ist nicht notwendig, aber sinnvoll.


Der <code>main</code>-Funktion werden die [[Kommandozeilenparameter]] als ein Feld von [[Zeichenkette]]n (Strings) übergeben. Ruft man dieses Programm unter Windows mit <code>beispiel.exe -win -s</code> auf, dann gibt es diesen Text in einem [[Kommandozeile|Konsolen-Fenster]] aus:
Parameter 0 = 'beispiel.exe'
Parameter 1 = '-win'
Parameter 2 = '-s'

; Unittests
[[Modultest|Unittests bzw. Modultests]]<ref>[https://dlang.org/unittest.html dlang.org-unittests]</ref> 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<ref>[https://dlang.org/ddoc.html dlang.org-DDOC]</ref> generierten Dokumentation aufgeführt werden.
In D werden die Unittests unmittelbar vor der Main-Funktion ausgeführt.
<syntaxhighlight lang="d">
/++
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) pure
{
if (a <= 1)
return false;

// falls a keine Primzahl ist und a restlos durch n teilbar ist
for (long n = 2; n*n <= a; ++n)
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).
// Sonst 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);

// Hier wird erwartet, dass der Test fehlschlägt, da 11 prim ist.
// Fehlerhafter Code: Assert schlägt immer fehl!
assert(isPrime(11) == false);
}
</syntaxhighlight>
Die Annotation <code>pure</code> bedeutet, dass <code>isPrime</code> eine referentiell transparente Funktion ist, ihr Ergebnis also nur von den Eingaben, aber nicht von globalen Variablen abhängt. Der Compiler überprüft die Korrektheit der Annotation.

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 ===
Zusätzlich zu [[Mixin]]-Templates<ref>[https://dlang.org/template-mixin.html dlang.org-Mixin-Templates]</ref> implementiert die Programmiersprache D alle gängigen [[Template (C++)|Templatearten]].<ref>[https://dlang.org/template.html dlang.org-Templates]</ref>

; Funktionstemplates
<syntaxhighlight lang="d">
// 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");
}
</syntaxhighlight>

; Meta-Programmierung
<syntaxhighlight lang="d">
// 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;
}

void main() {
import std.stdio;

// Da pow ein Template ist, wird das Ergebnis zur Compilezeit bestimmt
// und steht zur Laufzeit als Konstante zur Verfügung
writeln("2.7182^3 = ", Pow!(2.7182, 3));
writeln("3.1415^5 = ", Pow!(3.1415, 5));
}
</syntaxhighlight>
Ausgabe:
<syntaxhighlight lang="text">
2.7182^3 = 20.0837
3.1415^5 = 305.975
</syntaxhighlight>

; Compile Time Function Execution

Mit noch während der Kompilierung ausgeführten Funktionen (CTFE) können Initialisierungslisten, Lookup-Tables u. Ä. erstellt<ref>[https://dlang.org/function.html#interpretation dlang.org-CTFE]</ref> und durch sog. Mixins bei der Übersetzung aus [[Zeichenkette|Strings]] generierter D-Code eingebunden werden.<ref>[https://dlang.org/mixin.html dlang.org-mixins]</ref> Diese beiden Features bieten eine Möglichkeit für die Realisierung [[Domänenspezifische Sprache|domänenspezifischer Sprachen]] in D.

<syntaxhighlight lang="d">
T sum(T)(T[] elems) {
T result = T(0);

foreach (elem; elems)
result += elem;

return result;
}

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;
</syntaxhighlight>

Die Initialisierung von <code>result</code> mit null ist notwendig, falls <code>T</code> durch einen Fließkomma-Datentyp wie <code>double</code> belegt wird, denn uninitialisierte Fließkommazahlen-Variablen werden mit [[NaN]] initialisiert, statt mit null.

== Literatur ==
* Ali Çehreli: ''[http://ddili.org/ders/d.en/index.html Programming in D: Tutorial and Reference].'' 1. Auflage. [[CreateSpace.com|CreateSpace]], 2015, ISBN 978-1-5150-7460-1.
* Adam D. Ruppe: ''D Cookbook.'' 1. Auflage. Packt Publishing, 2014, ISBN 978-1-78328-721-5.
* [[Andrei Alexandrescu]]: ''The D Programming Language.'' 1. Auflage. [[Addison-Wesley]], 2010, ISBN 978-0-321-63536-5.
* Tobias Wassermann, Christian Speer: ''Programmieren in D.'' 1. Auflage. entwickler.press, 2007, ISBN 978-3-939084-69-3.
* Manfred Hansen: [http://www.steinmole.de/d/d_buch.pdf ''D-Buch – Programmiersprache D.''] 2009.

== Weblinks ==
* [https://dlang.org/ Offizielle Website]
* [https://www.digitalmars.com/ Die Programmiersprache D] bei Digital Mars
* [http://rainers.github.io/visuald/visuald/StartPage.html Visual D] D-Integration für Visual Studio 2005, 2008 und 2010 (englisch)
* [https://archive.codeplex.com/?p=dnet D.NET] D-Compiler für .NET (englisch)

== Einzelnachweise ==
<references />

{{Normdaten|TYP=s|GND=7606805-5}}

[[Kategorie:Imperative Programmiersprache]]
[[Kategorie:Objektorientierte Programmiersprache]]

D (Programmiersprache) - Versionsgeschichte

imported>Invisigoth67: form