D (Programmiersprache)

D Programmiersprache

Paradigma	Multi-Paradigma: funktional, Imperativ, objektorientierter
Entworfen von	Walter hell, Andrei Alexandrescu (seit 2007)
Entwickler	D Sprachgrund
Erstmals erschienen	8. Dezember 2001; vor 20 Jahren[1]
Stabile Version	2.099.1[2]  / 7. April 2022; vor 3 Monaten
Disziplin tippen	Gefolgert, statisch, stark
OS	Freebsd, Linux, Mac OS, Fenster
Lizenz	Schub[3][4][5]
Dateiname -Erweiterungen	.d[6][7]
Webseite	Dlang.org
Haupt Implementierungen
DMD (Referenzimplementierung), GCCAnwesend GDCAnwesend LDC, SDC
Beeinflusst von
C, C ++, C#, Eiffel,[8] Java, Python
Beeinflusst
Genie, Minid, Qore, Schnell,[9] Vala, C ++ 11, C ++ 14, C ++ 17, C ++ 20, gehen, C#, und andere.
D Programmierung bei Wikibooks

D, auch bekannt als Dlang, ist ein Multi-Paradigma Systemprogrammiersprache erstellt von Walter hell bei Digital Mars und im Jahr 2001 veröffentlicht. Andrei Alexandrescu schloss sich dem Design- und Entwicklungsbemühungen im Jahr 2007 an. Obwohl er als Wiederentwicklung von entstand C ++, D ist eine zutiefst unterschiedliche Sprache-Features von D können als optimierte und erweiterte Ideen von C ++ angesehen werden.^[10] D wird jedoch auch von anderen hochrangigen Programmiersprachen inspiriert, insbesondere von anderen Programmiersprachen Java, Python, Rubin, C#, und Eiffel.

D kombiniert die Leistung und Sicherheit von kompilierte Sprachen mit dem Ausdruckskraft von modern dynamisch und funktional^[11] Programmiersprachen. Idiomatisch D -Code ist üblicherweise so schnell wie der äquivalente C ++ - Code und gleichzeitig kürzer.^[12] Die Sprache als Ganzes ist nicht Speichersicher^[13] Enthält jedoch optionale Attribute, mit denen die Speichersicherheit entweder Teilmengen oder des gesamten Programms garantiert werden soll.^[14]

Geben Sie Inferenz ein, Automatische Speicherverwaltung und syntethischer Zucker zum gängige Typen schneller zulassen Entwicklung, während Grenzenprüfung, Entwurf durch Vertrag Finden Sie Bugs früher zur Laufzeit und a Parallelität-bewusst Typ System fängt Fehler zur Kompilierung der Zeit auf.^[15]

Merkmale

D wurde mit Lehren aus praktischem C ++ - eher aus einer rein theoretischen Perspektive gezogen. Obwohl die Sprache viele verwendet C und C ++ - Konzepte, es verwaltet auch einige oder verwendet unterschiedliche Ansätze (und Syntax), um einige Ziele zu erreichen. Als solches ist es nicht Quelle kompatibel (Es ist auch nicht abzielt) mit C- und C ++ - Quellcode im Allgemeinen (einige einfachere Codebasen aus diesen Sprachen können durch Glück mit D funktionieren oder einige benötigen Portierung). D wurde jedoch durch die Regel eingeschränkt, dass sich jeder in C und D legale Kodex auf die gleiche Weise verhalten sollte.

D hat vor C ++ einige Funktionen gewonnen, wie z. Schließungen, Anonyme Funktionen, Kompilierungs-Zeit-Funktionsausführung, Bereiche, integrierte Container-Iterationskonzepte und Geben Sie Inferenz ein. D ergänzt die Funktionalität von C ++, indem auch implementiert wird Entwurf durch Vertrag, Unit -Tests, Stimmt Module, Müllsammlung, erste Klasse Arrays, assoziative Arrays, Dynamische Arrays, Arrayschneide, verschachtelte Funktionen, faule Bewertung, Scoped (aufgeschobene) Codeausführung und eine überarbeitete Schablone Syntax. C ++ Mehrfacherbe wurde durch Java-Stil ersetzt Einzelvererbung mit Schnittstellen und Mischungen. Andererseits Ds Erklärung, Aussage und Ausdruck Syntax Die von C ++ genau übereinstimmt.

D behält die Fähigkeit von C ++ durch, durchzuführen Programmierung mit niedriger Ebene einschließlich Inline -Assembler, was die Unterschiede zwischen D und Anwendungssprachen wie typisiert Java und C#. Inline-Assembler lässt Programmierer maschinenspezifisch eintreten Montagecode Innerhalb von Standard-D-Code, eine Methode, die von Systemprogrammierern verwendet wird, um auf die Merkmale auf niedriger Ebene der von der Ebene zuzugreifen Prozessor benötigt, um Programme auszuführen, die direkt mit dem zugrunde liegenden Schnittstellen durchführen Hardware-, wie zum Beispiel Betriebssysteme und Gerätetreibersowie das Schreiben von Hochleistungscode (d. H. Unter Verwendung von Vektorerweiterungen, Simd) Das ist durch den Compiler automatisch schwer zu erzeugen.

D unterstützt Funktion Überlastung und Bedienerüberlastungsowie dynamische Arrays und assoziative Arrays standardmäßig. Symbole (Funktionen, Variablen, Klassen) können in beliebiger Reihenfolge deklariert werden - Vorwärtsdeklarationen sind nicht erforderlich. In ähnlicher Weise können Importe fast in beliebiger Reihenfolge erfolgen und sogar skopiert werden (d. H. Nur ein Modul oder einen Teil davon in einer Funktion, Klasse oder untestest). D hat integrierte Unterstützung für Dokumentationskommentare, die automatisch ermöglichen Dokumentationsgenerierung.

In D sind Textzeichenketten nur Arrays von Zeichen, und Arrays in D sind im Gegensatz zu C ++ Grenzen überprüft.^[16] Spezifische Operatoren für die Handhabung von Saiten bestehen visuell von mathematischen Korellaren. D hat erstklassige Typen für komplexe und imaginäre Zahlen und bewertet Ausdrücke, die solche Typen effizient betreffen.^[17]

Programmierparadigmen

D unterstützt fünf Hauptstücken Programmierparadigmen:

• gleichzeitig (Schauspielermodell)
• objektorientierter
• Imperativ
• funktional
• Metaprogrammierung

Imperativ

Die imperative Programmierung in D ist fast identisch mit denen in C. Funktionen, Daten, Aussagen, Erklärungen und Ausdrücke funktionieren genauso wie in C, und auf die C -Laufzeitbibliothek kann direkt zugegriffen werden. Andererseits umfassen einige bemerkenswerte Unterschiede zwischen D und C im Bereich der imperativen Programmierung Ds für jeden Schleifenkonstrukt, das es ermöglicht, über eine Sammlung zu schleifen, und verschachtelte Funktionen, die Funktionen sind, die in einem anderen deklariert sind und auf die Entzugfunktion zugreifen können Lokale Variablen.

importieren std.stdio; Leere hauptsächlich() {  int Multiplikator = 10;  int skaliert(int x) { Rückkehr x * Multiplikator; }  für jeden (i; 0 .. 10) {  Writefln("Hallo, Welt %d! Scaled = %d", i, skaliert(i));  } } 

Objektorientierter

Die objektorientierte Programmierung in D basiert auf einer einzelnen Vererbungshierarchie, wobei alle Klassen aus dem Klassenobjekt abgeleitet sind. D unterstützt nicht mehrfache Vererbung; Stattdessen verwendet es Java-Stil Schnittstellen, die vergleichbar mit den reinen abstrakten Klassen von C ++ und vergleichbar sind und Mischungen, was die gemeinsame Funktionalität von der Vererbungshierarchie trennt. D ermöglicht auch die Definition statischer und endgültiger (nicht virtueller) Methoden in Schnittstellen.

Schnittstellen und Vererbung in der D -Unterstützung Kovariante Für Rückgabetypen von überschriebenen Methoden.

D unterstützt die Typ -Weiterleitung sowie optionaler Benutzerdefiniert Dynamischer Versand.

Klassen (und Schnittstellen) in D können enthalten Invarianten die automatisch vor und nach dem Eintritt in öffentliche Methoden gemäß dem überprüft werden Entwurf durch Vertrag Methodik.

Viele Aspekte von Klassen (und Strukturen) können sein gezwungen automatisch zur Kompilierungszeit (eine Form von Betrachtung Verwendung Geben Sie Merkmale ein) und zur Laufzeit (rtti / Typinfo), um den generischen Code oder die automatische Codeerzeugung zu erleichtern (normalerweise mit Kompilierungszeittechniken).

Funktional

D unterstützt Funktionelle Programmierung Funktionen wie Funktionsliterale, Schließungen, rekursiv immutierbare Objekte und die Verwendung von Funktionen höherer Ordnung. Es gibt zwei Syntaxe für anonyme Funktionen, einschließlich einer Multiple-Statement-Form und einer "Shorthand" -Led-Expressions-Notation:^[12]

int Funktion(int) g; g = (x) { Rückkehr x * x; }; // Langhand g = (x) => x * x;  // Shorthand 

Es gibt zwei integrierte Typen für Funktionsliterale. Funktion, was einfach ein Zeiger auf eine stapelgestützte Funktion ist, und delegieren, der auch einen Zeiger auf die Umgebung beinhaltet. Typ -Inferenz kann mit einer anonymen Funktion verwendet werden. In diesem Fall erstellt der Compiler a delegieren Es sei denn, er kann beweisen, dass ein Umgebungszeiger nicht erforderlich ist. Um einen Verschluss zu implementieren, platziert der Compiler auch bei Bedarf lokale Variablen auf dem Haufen (z. B. wenn ein Verschluss durch eine andere Funktion zurückgegeben wird und den Bereich dieser Funktion verlässt). Bei der Verwendung von Typ -Inferenz fügt der Compiler auch Attribute hinzu, wie z. B. rein und Nichts zum Typ einer Funktion, wenn es beweisen kann, dass sie sich bewerben.

Andere funktionale Merkmale wie z. Currying und gemeinsame Funktionen höherer Ordnung wie z. Karte, Filter, und reduzieren sind über die Standardbibliotheksmodule erhältlich Std.Funktional und std.algorithmus.

importieren std.stdio, std.Algorithmus, std.Angebot; Leere hauptsächlich() {  int[] A1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];  int[] A2 = [6, 7, 8, 9];  // muss unveränderlich sein, um Zugriff aus einer reinen Funktion zu ermöglichen  unveränderlich Drehzahl = 5;  int Mysum(int a, int b) rein Nichts // reine Funktion  {  wenn (b <= Drehzahl) // Ref to Entenscope  Rückkehr a + b;  anders  Rückkehr a;  }  // einen Delegierten übergeben (Verschluss)  Auto Ergebnis = reduzieren!Mysum(Kette(A1, A2));  Writeln("Ergebnis: ", Ergebnis); // Ergebnis: 15  // An einem Delegierten buchstäblich vorbeikommen  Ergebnis = reduzieren! (((a, b) => (b <= Drehzahl) ? a + b : a) (Kette(A1, A2));  Writeln("Ergebnis: ", Ergebnis); // Ergebnis: 15 } 

Alternativ können die obigen Funktionszusammensetzungen mithilfe der UFCs (Uniform Function Call Syntax) für eine natürlichere Lektüre von Links nach rechts ausgedrückt werden:

  Auto Ergebnis = A1.Kette(A2).reduzieren!Mysum();  Writeln("Ergebnis: ", Ergebnis);  Ergebnis = A1.Kette(A2).reduzieren! (((a, b) => (b <= Drehzahl) ? a + b : a) ();  Writeln("Ergebnis: ", Ergebnis); 

Parallelität

Parallele Programmierkonzepte werden in der Bibliothek implementiert und erfordern keine zusätzliche Unterstützung vom Compiler. Das D -Typ -System und der Compiler stellen jedoch sicher, dass die Datenfreigabe transparent erkannt und verwaltet werden kann.

importieren std.stdio : Writeln; importieren std.Angebot : Jota; importieren std.Parallelität : parallel; Leere hauptsächlich() {  für jeden (i; Jota(11).parallel) {  // Der Körper der Foreach -Schleife wird für jedes i parallel ausgeführt  Writeln("wird bearbeitet ", i);  } } 

iota (11) .Parallel ist äquivalent zu Std.Parallelism.Parallel (IOTA (11)) durch Verwendung von UFCs.

Das gleiche Modul unterstützt auch Taskpool Dies kann zur dynamischen Erstellung paralleler Aufgaben sowie zur Map-Filter-Reduce- und Faltstil-Operationen auf Bereichen (und Arrays) verwendet werden, was in Kombination mit Funktionsvorgängen nützlich ist. std.algorithm.map Gibt einen trägen bewerteten Bereich und nicht ein Array zurück. Auf diese Weise werden die Elemente von jeder Worker -Aufgabe automatisch parallel berechnet.

importieren std.stdio : Writeln; importieren std.Algorithmus : Karte; importieren std.Angebot : Jota; importieren std.Parallelität : Taskpool; /* Auf Intel i7-3930x und GDC 9.3.0:  * 5140 ms mit std.algorithm.Reduce  * 888ms mit std.parallelism.taskpool.Reduce  *  * Auf AMD Threadripper 2950x und GDC 9.3.0:  * 2864 ms mit std.algorithm.Reduce  * 95 ms mit std.parallelism.taskpool.Reduce  */ Leere hauptsächlich() {  Auto nums = Jota(1.0, 1_000_000_000.0);  Auto x = Taskpool.reduzieren!"A + B"(  0,0, Karte!"1.0 / (a ​​* a)"(nums)  );  Writeln("Summe: ", x); } 

Parallelität

Die Parallelität ist in der Bibliothek vollständig implementiert und erfordert keine Unterstützung vom Compiler. Alternative Implementierungen und Methoden des Schreibens gleichzeitiger Code sind möglich. Die Verwendung von D -Schreibsystem sorgt für die Speichersicherheit.

importieren std.stdio, std.Parallelität, std.Variante; Leere Foo() {  bool Fortsetzung = Stimmt;  während (Fortsetzung)  {  erhalten( // Delegierte werden verwendet, um den Nachrichtentyp zu entsprechen.  (int Nachricht) => Writeln("Int erhalten:", Nachricht),  (Tid Absender) { Fortsetzung = FALSCH; Absender.senden(--1); },  (Variante v) => Writeln("Huh?") // Variante entspricht jedem Typ  );  } } Leere hauptsächlich() {  Auto tid = laichen(& &Foo); // laich einen neuen Thread, der foo () läuft  für jeden (i; 0 .. 10)  tid.senden(i);  // einige ganze Zahlen senden  tid.senden(1.0f);  // einen Schwimmer senden  tid.senden("hallo"); // eine Zeichenfolge senden  tid.senden(Thistid); // eine Struktur senden (TID)  erhalten((int x) => Writeln("Hauptdhreopempfehlung:", x)); } 

Metaprogrammierung

Metaprogrammierung wird durch Vorlagen unterstützt, die Ausführung der Kompilierungszeitfunktion, Tupelund String -Mixins. Die folgenden Beispiele zeigen einige der Kompilierungszeitfunktionen von D.

Vorlagen in D können im Vergleich zum C ++ - Funktionsstil für Vorlagen in einem imperativeren Stil geschrieben werden. Dies ist eine reguläre Funktion, die die berechnet Fakultät einer Zahl:

Ulong Fakultät(Ulong n) {  wenn (n < 2)  Rückkehr 1;  anders  Rückkehr n * Fakultät(n-1); } 

Hier die Verwendung von statisch, wennEs wird gezeigt, dass Ds Kompilierungszeit-Konstrukt eine Vorlage konstruiert, die dieselbe Berechnung unter Verwendung von Code ausführt, die der obigen Funktion ähnlich ist:

Schablone Fakultät(Ulong n) {  statisch wenn (n < 2)  Auflauf Fakultät = 1;  anders  Auflauf Fakultät = n * Fakultät! (n-1); } 

In den folgenden beiden Beispielen werden die oben definierten Vorlage und Funktion zum Berechnen von Faktorien verwendet. Die Arten von Konstanten müssen nicht explizit als Compiler spezifiziert werden färbt ihre Typen Von den rechten Seiten der Aufgaben:

Auflauf fakten_7 = Fakultät! (7); 

Dies ist ein Beispiel für Kompilierungs-Zeit-Funktionsausführung (CTFE). Gewöhnliche Funktionen können in ständigen Ausdrücken für Kompilierzeit verwendet werden, vorausgesetzt, sie erfüllen bestimmte Kriterien:

Auflauf fakten_9 = Fakultät(9); 

Das std.string.format Funktion wird ausgeführt printf-ähnliche Datenformatierung (auch bei Kompilierungszeit, über CTFE) und "MSG" Pragma Zeigt das Ergebnis zur Kompilierungszeit an:

importieren std.Saite : Format; Pragma(Nachricht, Format("7! = %S", fakten_7)); Pragma(Nachricht, Format("9! = %S", fakten_9)); 

String-Mixins, kombiniert mit der Ausführung der Kompilierungszeitfunktion, ermöglichen die Erzeugung von D-Code mithilfe von String-Operationen zur Kompilierungszeit. Dies kann verwendet werden, um zu analysieren Domänenspezifische Sprachen, die als Teil des Programms zusammengestellt werden:

importieren Footod; // hypothetisches Modul, das eine Funktion enthält, die den Foo -Quellcode analysiert  // und gibt den äquivalenten D -Code zurück Leere hauptsächlich() {  mischen(footod(importieren("Beispiel.foo"))); } 

Speicherverwaltung

Speicher wird normalerweise mit verwaltet mit Müllsammlung, aber bestimmte Objekte können sofort abgeschlossen sein, wenn sie aus dem Zielfernrohr gehen. Dies ist, was die meisten Programme und Bibliotheken in D verwendet haben.

Falls mehr Kontrolle über das Speicherlayout und eine bessere Leistung erforderlich sind, ist eine explizite Speicherverwaltung möglich mit der überlastete Operatoren Neu und löschen, durch Anruf C's Malloc und kostenlos direkt oder implementieren benutzerdefinierte Allocator -Schemata (d. H. Auf Stack mit Fallback, Raii -Stilzuweisung, Referenzzählung, gemeinsamer Referenzzählung). Die Müllsammlung kann kontrolliert werden: Programmierer können Speicherbereiche hinzufügen und ausschließen, von dem Kollektor beobachtet werden, den Kollektor deaktivieren und aktivieren und entweder einen Generations- oder einen vollständigen Sammelzyklus erzwingen können.^[18] Das Handbuch enthält viele Beispiele für die Implementierung verschiedener hochoptimierter Speicherverwaltungsschemata für die Inszenierung der Müllsammlung in einem Programm.^[19]

In Funktionen, Struktur Instanzen werden standardmäßig auf dem Stapel zugewiesen Klasse standardmäßig auf dem Heap zugewiesene Instanzen (unter Bezugnahme auf die Klasseninstanz auf dem Stapel). Dies kann jedoch für Klassen geändert werden, beispielsweise unter Verwendung der Standardbibliotheksvorlage std.typecons.Scopedoder durch Verwendung Neu für Strukturen und Zuweisen eines Zeigers anstelle einer wertbasierten Variablen.^[20]

In Funktionen werden statische Arrays (von bekannter Größe) auf dem Stapel zugewiesen. Für dynamische Arrays kann man die verwenden core.stdc.stdlib.alloca Funktion (ähnlich wie Alloca in c), um dem Stapel Speicher zuzuweisen. Der zurückgegebene Zeiger kann in einem (typisierten) dynamischen Array mithilfe eines Slice verwendet werden (wie auch immer die Größenänderung, einschließlich Anhängen, vermieden werden muss; und aus offensichtlichen Gründen dürfen sie nicht aus der Funktion zurückgegeben werden).^[20]

A Umfang Das Schlüsselwort kann sowohl zum Annotieren von Teilen des Codes als auch zum Anmerkungen von Code, als auch von Variablen und Klassen/Strukturen verwendet werden, um anzuzeigen, dass sie sofort beim Ausgangsbereich zerstört werden sollten (Destruktor genannt). Was auch immer der Gedächtnis ist, abhängt auch von Unterschieden implementiert und der Klassen-VS-Struktur.^[21]

std.experimental.alocator Enthält ein modulares und komponierbares Allocator -Vorlagen, um benutzerdefinierte Hochleistungs -Allokatoren für besondere Anwendungsfälle zu erstellen.^[22]

Sicher

Sicher^[23] ist der Name, der der Teilmenge von D gegeben wird und der garantiert Speichersicherheit ist (keine Schreibvorgänge für Speicher, die nicht zugeteilt oder recycelt wurde). Funktionen markiert @sicher werden zur Kompilierung Zeit überprüft, um sicherzustellen, dass sie keine Funktionen verwenden, die zu einer Korruption des Speichers führen können, z. @sicher oder @Vertrauenswürdige. Funktionen können markiert werden @Vertrauenswürdige In den Fällen, in denen der Compiler nicht zwischen der sicheren Verwendung eines in SAFED deaktivierten Merkmals und einem potenziellen Fall von Speicherbeschäftigung unterscheiden kann.^[24]

SCOPE LEBENDIME SICHERHEIT

Anfangs unter den Bannern von DIP1000^[25] und Dip25^[26] (Jetzt Teil der Sprachspezifikation^[27]), D bietet Schutz vor bestimmten schlecht geformten Konstruktionen, die die Lebensdauer von Daten betreffen.

Die aktuellen Mechanismen befassen sich in erster Linie mit Funktionsparametern und dem Stapelgedächtnis. Es ist jedoch ein festgelegter Ehrgeiz der Führung der Programmiersprache, eine gründlichere Behandlung von Lebenszeiten innerhalb der D -Programmiersprache zu bieten^[28] (beeinflusst von Ideen von Rost -Programmiersprache).

Lebensdauer Sicherheit von Aufgaben

Innerhalb @Safe Code die Lebensdauer einer Aufgabe mit a Referenztyp wird überprüft, um sicherzustellen, dass die Lebensdauer des Beauftragten länger ist als die der zugewiesenen.

Zum Beispiel:

@sicher Leere Prüfung() {  int TMP = 0; // #1  int* rad;  // #2  rad = &TMP;  // Wenn die Reihenfolge der Erklärungen von #1 und #2 umgekehrt ist, schlägt dies fehl.  {     	int Schlecht = 45; // Lebensdauer von "schlecht" erstreckt sich nur auf den Umfang, in dem es definiert ist.  *rad = Schlecht;  // Das ist koscher.  rad = &Schlecht;  // Lebensdauer von rad länger als schlecht, daher ist dies überhaupt nicht koscher.  } } 

Funktionsparameter Lebensdauer Annotationen im @Safe -Code

Wenn Sie auf den Funktionsparameter angewendet werden, der entweder Zeigertyp oder Referenzen ausmacht, sind die Schlüsselwörter die Schlüsselwörter Rückkehr und Umfang Beschränken Sie die Lebensdauer und Verwendung dieses Parameters.

Der Sprachstandard bestimmt das folgende Verhalten:^[29]

Ein kommentiertes Beispiel ist unten angegeben.

@sicher: int* GP; Leere Thorin(Umfang int*); Leere Gloin(int*); int* Balin(Rückkehr Umfang int* p, Umfang int* q, int* r) {  GP = p; // Fehler entkommt PS zum globalen GP  GP = q; // Fehler, q entkommt zum globalen GP  GP = r; // OK  Thorin(p); // ok, P entkommt nicht Thorin ()  Thorin(q); // OK  Thorin(r); // OK  Gloin(p); // Fehler, Gloin () entkommt p  Gloin(q); // Fehler, Gloin () entkommt q  Gloin(r); // ok, dass Gloin () rung res  Rückkehr p; // OK  Rückkehr q; // Fehler, kann 'Scope' q nicht zurückgeben  Rückkehr r; // OK } 

Interaktion mit anderen Systemen

C's Anwendung Binärschnittstelle (ABI) wird unterstützt sowie alle grundlegenden und abgeleiteten Typen von C, wodurch der direkte Zugriff auf vorhandene C -Code und Bibliotheken ermöglicht wird. D Bindungen sind für viele beliebte C -Bibliotheken erhältlich. Zusätzlich, Cs Standard Bibliothek ist Teil von Standard D.

Auf Microsoft Windows kann D zugreifen Komponentenobjektmodell (Com) Code.

Solange die Speicherverwaltung ordnungsgemäß betreut wird, können viele andere Sprachen in einer einzigen Binärdatei mit D gemischt werden. Zum Beispiel erlaubt der GDC -Compiler, C, C ++ und andere unterstützte Sprachcodes zu verknüpfen. D -Code (Funktionen) kann auch als Verwendung von C, C ++, Pascal ABIS markiert und somit an die in diesen Sprachen geschriebenen Bibliotheken übergeben werden Rückrufe. In ähnlicher Weise können Daten zwischen den in diesen Sprachen geschriebenen Codes in beide Richtungen austauscht werden. Dies schränkt normalerweise die Verwendung von primitiven Typen, Zeigern, einigen Formen von Arrays ein. Gewerkschaften, Strukturen und nur einige Arten von Funktionszeiger.

Da viele andere Programmiersprachen häufig die C -API zum Schreiben von Erweiterungen oder zum Ausführen des Interpreters der Sprachen bereitstellen, kann D auch mit diesen Sprachen mit Standard -C -Bindungen (mit einer dünnen D -Schnittstellendatei) direkt mit diesen Sprachen eingestuft werden. Zum Beispiel gibt es bidirektionale Bindungen für Sprachen wie Python,^[30] Lua^[31][32] und andere Sprachen, die häufig mit Compiles-Time-Codegenerierung und Kompilierungs-Zeit-Reflexionsmethoden verwendet werden.

Interaktion mit C ++ - Code

D verfolgt einen zulässigen, aber realistischen Ansatz für die Interoperation mit C ++ Code.^[33]

Für D -Code als markiert als extern (c ++)Die folgenden Funktionen werden angegeben:

• Der Name Mangling -Konventionen stimmen mit denen von C ++ über dem Ziel überein.
• Bei Funktionsaufrufen ist der ABI gleichwertig.
• Die VTABLE wird mit einer einzigen Vererbung abgestimmt (die einzige Ebene, die durch die D -Sprachspezifikation unterstützt wird).

C ++ - Namespaces werden über die Syntax verwendet extern (c ++, Namespace) wo Namespace ist der Name des C ++ - Namespace.

Ein Beispiel für C ++ Interoperation

Die C ++ - Seite

#enthalten  Verwendung Namespace std; Klasse Base {   Öffentlichkeit:   virtuell Leere print3i(int a, int b, int c) = 0; }; Klasse Abgeleitet : Öffentlichkeit Base {   Öffentlichkeit:   int aufstellen;   Abgeleitet(int aufstellen) : aufstellen(aufstellen) {}   Leere print3i(int a, int b, int c)   {   Cout << "a =" << a << Endl;   Cout << "B =" << b << Endl;   Cout << "C =" << c << Endl;   }   int Mul(int Faktor); }; int Abgeleitet :: Mul(int Faktor) {   Rückkehr aufstellen * Faktor; } Abgeleitet *CreateInstance(int i) {   Rückkehr Neu Abgeleitet(i); } Leere Deleteinstanz(Abgeleitet *&d) {   löschen d;   d = 0; } 

Die D -Seite

extern(C++) {  abstrakt Klasse Base  {  Leere print3i(int a, int b, int c);  }  Klasse Abgeleitet : Base  {  int aufstellen;  @deaktivieren Dies();  überschreiben Leere print3i(int a, int b, int c);  Finale int Mul(int Faktor);  }  Abgeleitet CreateInstance(int i);  Leere Deleteinstanz(Ref Abgeleitet d); } Leere hauptsächlich() {  importieren std.stdio;  Auto D1 = CreateInstance(5);  Writeln(D1.aufstellen);  Writeln(D1.Mul(4));  Base B1 = D1;  B1.print3i(1, 2, 3);  Deleteinstanz(D1);  behaupten(D1 ist Null);  Auto D2 = CreateInstance(42);  Writeln(D2.aufstellen);  Deleteinstanz(D2);  behaupten(D2 ist Null); } 

Besser c

Die D -Programmiersprache hat eine offizielle Untergruppe als "als" bekannt "Besser c".^[34] Diese Untergruppe verbietet den Zugriff auf D -Funktionen, die andere Laufzeitbibliotheken als die von C erfordern, die von C.

Aktiviert über die Compiler-Flags "-betterc" auf DMD und LDC und "-fno-druntime" auf GDC, Besser c darf nur in den D -Code aufrufen, der unter demselben Flag zusammengestellt wurde (und mit einem anderen verknüpften Code als D), aber Code ohne die kompiliert wurde Besser c Die Option kann mit dem Code erfasst werden, der damit zusammengestellt wurde: Dies führt jedoch zu geringfügigem Verhalten aufgrund von Unterschieden in der Umgangszahlen von C und D.

Funktionen in Better C enthalten

• Die uneingeschränkte Verwendung von Kompilierungszeitfunktionen (z. B. können Ds dynamische Zuordnungsfunktionen zum Kompilierungszeit verwendet werden, um D-Daten vorzuplanen)
• Vollständige Metaprogrammieranlagen
• Verschachtelte Funktionen, verschachtelte Strukturen, Delegierte und Lambdas
• Mitgliederfunktionen, Konstrukteure, Zerstörer, Betriebsüberlastung usw.
• Das vollständige Modulsystem
• Array -Schnitt- und Array -Grenzensprüfung
• Raii
• Umfang (Ausgang)
• Speicherschutzschutz für Speicher
• Schnittstelle mit C ++
• COM -Klassen und C ++ - Klassen
• behaupten Fehler werden in die C -Laufzeitbibliothek gerichtet
• Schalter mit Saiten
• Endschalter
• Gerätetest Blöcke
• printf Formatvalidierung

Features ausgeschlossen von besser c

• Müllsammlung
• Typinfo und ModulEnfo
• Eingebaute Gewinde (z. Core.Thread)
• Dynamische Arrays (obwohl Scheiben statischer Arrays funktionieren) und assoziative Arrays
• Ausnahmen
• synchronisiert und Core.Sync
• Statische Modulkonstrukteure oder -Destruktoren

Geschichte

Walter hell begann 1999 an einer neuen Sprache zu arbeiten. D wurde erstmals im Dezember 2001 veröffentlicht^[1] und erreichte Version 1.0 im Januar 2007.^[35] Die erste Version der Sprache (D1) konzentrierte sich auf die imperativen, objektorientierten und metaprogrammierenden Paradigmen,^[36] Ähnlich wie C ++.

Einige Mitglieder der D -Gemeinschaft, die mit Phobos, Ds Beamter, unzufrieden waren Laufzeit und Standardbibliothekerstellte eine alternative Laufzeit und eine Standardbibliothek namens Tango. Die erste Ankündigung der öffentlichen Tango fand innerhalb von Tagen nach der Veröffentlichung von D 1.0 statt.^[37] Tango übernahm einen anderen Programmierstil, der OOP und hohe Modularität umfasste. Als von Community geführter Projekt war Tango offener für Beiträge, was es ihm ermöglichte, schneller als die offizielle Standardbibliothek voranzukommen. Zu dieser Zeit waren Tango und Phobos aufgrund unterschiedlicher Laufzeit -APIs (dem Müllsammler, Fadenunterstützung usw.) unvereinbar. Dies machte es unmöglich, beide Bibliotheken im selben Projekt zu verwenden. Das Vorhandensein von zwei in hohem Maße verwendeten Bibliotheken hat aufgrund einiger Pakete, die Phobos und andere mit Tango verwenden, zu erheblichem Streit geführt.^[38]

Im Juni 2007 wurde die erste Version von D2 veröffentlicht.^[39] Der Beginn der Entwicklung von D2 signalisierte die Stabilisierung von D1. Die erste Version der Sprache wurde in Wartung platziert, wobei nur Korrekturen und Implementierungsfehler empfangen werden. D2 eingeführt Veränderungen brechen zur Sprache, beginnend mit seinem ersten experimentellen Const System. D2 fügte später zahlreiche andere Sprachmerkmale hinzu, wie z. Schließungen, Reinheitund Unterstützung für funktionale und gleichzeitige Programmierparadigmen. D2 löste auch die Standardbibliotheksprobleme, indem sie die Laufzeit von der Standardbibliothek trennen. Die Fertigstellung eines D2 -Tango -Hafens wurde im Februar 2012 bekannt gegeben.^[40]

Die Freisetzung von Andrei Alexandrescu's Buch Die D -Programmiersprache Am 12. Juni 2010 markierte die Stabilisierung von D2, die heute allgemein als "D" bezeichnet wird.

Im Januar 2011 wechselte die D-Entwicklung von einer Bugtracker / Patch-Submission-Basis auf GitHub. Dies hat zu einem signifikanten Anstieg der Beiträge zum Compiler, zur Laufzeit und zur Standardbibliothek geführt.^[41]

Im Dezember 2011 kündigte Andrei Alexandrescu an, dass D1, die erste Version der Sprache, am 31. Dezember 2012 eingestellt werden würde.^[42] Die endgültige D1 -Veröffentlichung, D v1.076, fand am 31. Dezember 2012 statt.^[43]

Code für den offiziellen D -Compiler, der Digital Mars D Compiler von Walter Bright wurde ursprünglich unter einem Brauch veröffentlicht Lizenz, Qualifying als source available aber nicht an die entsprechen Open Source Definition.^[44] 2014 der Compiler Frontend war neu lizenziert wie Open Source unter dem Boost Software Lizenz.^[3] Dieser neu lizenzierte Code schloss das Back-End aus, das teilweise entwickelt worden war Symantec. Am 7. April 2017 wurde der gesamte Compiler im Rahmen der Boost-Lizenz zur Verfügung gestellt, nachdem Symantec auch die Erlaubnis erteilt hatte, das Back-End erneut zu lizenzieren.^{[4][45][46][47]} Am 21. Juni 2017 wurde die D -Sprache zur Aufnahme in GCC angenommen.^[48]

Implementierungen

Die meisten aktuellen D -Implementierungen kompilieren direkt in Maschinensprache für eine effiziente Ausführung.

Produktionsbereit -Compiler:

• DMD - Das Digital Mars D Compiler von Walter Bright ist der offizielle D -Compiler; offen bezogen unter dem Boost Software Lizenz.^[3][4] Das DMD -Frontend wird von GDC (jetzt in GCC) und LDC geteilt, um die Kompatibilität zwischen Compilern zu verbessern. Zunächst wurde das Frontend in C ++ geschrieben, aber jetzt ist das meiste davon jetzt in D selbst geschrieben (Selbsthosting). Die Optimierer des Backend- und Maschinencode -Optimierers basieren auf dem Symantec Compiler. Zuerst unterstützte es nur 32-Bit-X86, wobei die Unterstützung für 64-Bit AMD64 und Powerpc von Walter Bright hinzugefügt wurde. Später wurde das Backend und fast der gesamte Compiler für vollständige Selbsthosting von C ++ nach D portiert.
• GCC - Das GNU Compiler -Sammlung, fusioniert GDC^[49] In GCC 9 am 29. Oktober 2018.^[50] Die ersten Arbeitsversionen von GDC mit GCC, basierend auf GCC 3.3 und GCC 3.4 auf 32-Bit X86 unter Linux und MacOS^[51] Wurde am 22. März 2004 veröffentlicht. Seitdem hat GDC zusätzliche Plattformen, verbesserte Leistung und Fehler bei der Verfolgung von DMD -Code für die Frontend- und Sprachspezifikation erhalten.^[52]
• LDC -Ein Compiler, der auf dem DMD-Front-End basiert, das verwendet Llvm als Compiler Back-End. Die erste Version von Release-Qualität wurde am 9. Januar 2009 veröffentlicht.^[53] Es unterstützt Version 2.0.^[54]

Spielzeug- und Proof-of-Concept-Compiler:

• D Compiler für .NET -Ein Back-End für die D-Programmiersprache 2.0 Compiler.^[55][56] Es kompilt den Code zu Gemeinsame Zwischensprache (CIL) Bytecode und nicht an Maschinencode. Der CIL kann dann über a ausgeführt werden Gemeinsame Sprachinfrastruktur (CLI) virtuelle Maschine. Das Projekt wurde seit Jahren nicht aktualisiert und der Autor gab an, dass das Projekt nicht mehr aktiv ist.
• SDC - Das Dummes D -Compiler verwendet ein benutzerdefiniertes Front-End und Llvm als Compiler Back-End. Es ist in D geschrieben und verwendet einen Scheduler, um die Symbolauflösung zu verarbeiten, um die Kompilierzeitfunktionen von D gleich zu verarbeiten. Dieser Compiler unterstützt derzeit eine begrenzte Untergruppe der Sprache.^[57][58]

Mit den obigen Compilern und Toolchains ist es möglich, D -Programme zu kompilieren, um viele verschiedene Architekturen anzusprechen, einschließlich x86, AMD64, Aarch64, Powerpc, MIPS64, Dec Alpha, Motorola M68K, Sparc, S390, WebAssembly. Die primären unterstützten Betriebssysteme sind Fenster und Linux, aber verschiedene Compiler unterstützen auch Mac OS X, Freebsd, Netbsd, AIX, Solaris/OpenSolaris und Androidentweder als Host oder Ziel oder beides. WebAssembly Ziel (unterstützt über LDC und LLVM) kann in jeder WebAssembly -Umgebung wie dem modernen Webbrowser (Google Chrome, Mozilla Firefox, Microsoft Edge, Apfelsafari) oder dedizierte WASM -virtuelle Maschinen.

Entwicklungswerkzeuge

Herausgeber und Integrierte Entwicklungsumgebungen (IDES) Unterstützung Satzstellung markieren und teilweise Code -Abschluss Für die Sprache beinhalten Slickedit, EMACs, Vim, Schießen, Smultron, Zeus,^[59] und Geany unter anderen.^[60]

• Dexed (ehemals Coedit),^[61] A d fokussierte grafische Ideen geschrieben in Objekt Pascal
• Mono-d^[62] ist eine feature-reichhalter plattform d-fokussierte grafische IDE basierend auf Monode entwickelt / Xamarin Studio, hauptsächlich in C Sharp geschrieben.^[63]
• Finsternis Plug-Ins für D enthalten DDT^[64] und Abstammung (Dead Project).^[65]
• Die Visual Studio -Integration wird von Visuald bereitgestellt.^[66][67]
• Visual Studio -Code Integration mit Erweiterungen als Dlang-VSCODE^[68] oder Code-D.^[69]
• Ein Bündel ist für verfügbar Textkamerad, und die Code :: Blöcke IDE beinhaltet teilweise Unterstützung für die Sprache. Standard -IDE -Funktionen wie jedoch wie z. Code -Abschluss oder Refactoring sind noch nicht verfügbar, obwohl sie teilweise in Code :: Blöcken arbeiten (aufgrund von Ds Ähnlichkeit mit C).
• Das Xcode 3 Plugin "D for Xcode" ermöglicht D-basierte Projekte und Entwicklung.^[70]
• KDevelop (sowie sein Texteditor -Backend, Kate) Autoperationsplugin ist verfügbar.^[71]

Open Source D ides für Fenster existieren, einige in d geschrieben, wie Poseidon,^[72] D-ide,^[73] und Designer verführen.^[74]

D -Anwendungen können mit einem beliebigen C/C ++ - Debugger debuggen werden, wie GDB oder WindbgObwohl die Unterstützung für verschiedene D-spezifische Sprachmerkmale extrem begrenzt ist. Unter Windows können D -Programme verwendet werden Ddbgoder Microsoft -Debugging -Tools (WINDBG und Visual Studio), nachdem die Debug -Informationen verwendet wurden CV2PDB. Das Zerobugs Debugger für Linux hat experimentelle Unterstützung für die D -Sprache. DDBG kann mit verschiedenen IDEs oder aus der Befehlszeile verwendet werden. Zerobugs hat seine eigene grafische Benutzeroberfläche (GUI).

Hausstaubmilbe ist ein leistungsstarkes Tool zum Minimieren von D -Quellcode, das nützlich ist, wenn er Compiler findet oder Probleme testet.^[75]

Dub ist ein beliebtes Paket- und Build -Manager für D -Anwendungen und Bibliotheken und wird häufig in die IDE -Unterstützung integriert.^[76]

Beispiele

Beispiel 1

Dieses Beispielprogramm druckt seine Befehlszeilenargumente. Das hauptsächlich Funktion ist der Einstiegspunkt eines D -Programms, und Args ist eine Reihe von Zeichenfolgen, die die Befehlszeilenargumente darstellen. EIN Saite in d ist eine Reihe von Zeichen, dargestellt durch Unveränderlich (char) [].

importieren std.stdio: Writefln;  Leere hauptsächlich(Saite[] Args) {   für jeden (i, arg; Args)   Writefln("args [%d] = '%s'" ", i, arg); } 

Das für jeden Die Aussage kann über jede Sammlung iterieren. In diesem Fall erzeugt es eine Abfolge von Indizes (i) und Werte (arg) aus dem Array Args. Der Index i und der Wert arg Lassen Sie ihre Typen aus dem Typ des Arrays abgeleitet Args.

Beispiel 2

Im Folgenden werden mehrere Kompromisse für D-Funktionen und D-Design in einem kurzen Programm angezeigt. Es iteriert die Zeilen einer Textdatei mit dem Namen Words.txt, das ein anderes Wort in jeder Zeile enthält und alle Wörter druckt, die Anagramme anderer Wörter sind.

importieren std.stdio, std.Algorithmus, std.Angebot, std.Saite;  Leere hauptsächlich() {   Dstring[] [Dstring] Signature2Words;    für jeden (dchar[] w; Linien(Datei("Words.txt"))) {   w = w.Chomp().zu senken();   unveränderlich Unterschrift = w.DUP.Sortieren().Veröffentlichung().IDUP;   Signature2Words[Unterschrift] ~ = w.IDUP;   }    für jeden (Wörter; Signature2Words) {   wenn (Wörter.Länge > 1) {   Writeln(Wörter.beitreten("" "));   }   } } 

1. Signature2Words ist ein integriertes assoziatives Array, das DString-Tasten (32-Bit / Char) auf Arrays von DStrings kartiert. Das ist vergleichbar mit Standarddict (Liste) in Python.
2. Zeilen (Datei ()) liefert die Linien träge, mit der Newline. Es muss dann kopiert werden IDUP um eine Zeichenfolge zu erhalten, die für die assoziativen Arraywerte verwendet werden soll (die IDUP Eigenschaften von Arrays gibt ein unveränderliches Duplikat des Arrays zurück, was seit dem erforderlich ist Dstring Typ ist eigentlich Unveränderlich (DCHAR) []). Integrierte assoziative Arrays erfordern unveränderliche Schlüssel.
3. Das ~ = Der Bediener wendet eine neue DString an die Werte des assoziierten Dynamikarrays an.
4. zu senken, beitreten und Chomp sind String -Funktionen, die D die Verwendung mit einer Methodensyntax ermöglichen. Der Name solcher Funktionen ähnelt häufig den Python -String -Methoden. Das zu senken Konvertiert eine Zeichenfolge in den Fall, den Fall, beitreten(" ") verbindet eine Reihe von Saiten in eine einzelne Zeichenfolge mit einem einzelnen Raum als Trennzeichen, und Chomp Entfernt eine neue Linie vom Ende der Zeichenfolge, wenn einer vorhanden ist. Das W.dup.sort (). Release (). IDUP ist lesbarer, aber gleichwertig zu Release (sortieren (W.dup)). IDUP zum Beispiel. Diese Funktion wird als UFCS (Uniform Function Call Syntax) bezeichnet und ermöglicht die Erweiterung integrierter oder Dritter-Pakettypen mit methodischer Funktionalität. Der Stil des Schreibens von Code wie diesen wird oft als bezeichnet als Pipeline (insbesondere wenn die verwendeten Objekte träge berechnet werden, zum Beispiel Iteratoren / Bereiche) oder Fließende Schnittstelle.
5. Das Sortieren ist eine std.algorithmus -Funktion, die das Array sortiert und eine einzigartige Signatur für Wörter erstellt, die Anagramme voneinander sind. Das Veröffentlichung() Methode für den Rückgabewert von Sortieren() ist praktisch, um den Code als einzelne Ausdruck zu halten.
6. Der Zweite für jeden Iteriert die Werte des assoziativen Arrays, kann es den Typ von schließen Wörter.
7. Unterschrift wird einer unveränderlichen Variablen zugeordnet, sein Typ wird abgeleitet.
8. UTF-32 DCHAR [] wird anstelle von normal verwendet UTF-8 verkohlen[] Andernfalls Sortieren() weigert sich, es zu sortieren. Es gibt effizientere Möglichkeiten, dieses Programm mit nur UTF-8 zu schreiben.

Verwendet

Bemerkenswerte Organisationen, die die D -Programmiersprache für Projekte verwenden Facebook,^[77] Ebay,^[78] und Netflix.^[79]

D wurde erfolgreich für verwendet AAA -Spiele,^[80] Sprachdolmetscher, virtuelle Maschinen,^[81][82] ein Betriebssystem Kernel,^[83] GPU Programmierung,^[84] Web Entwicklung,^[85][86] numerische Analyse,^[87] GUI -Anwendungen,^[88][89] a Passagierinformationssystem,^[90] maschinelles Lernen,^[91] Textverarbeitung, Web- und Anwendungsserver und Forschung.

Siehe auch

• DDOC
• D Sprachgrund

Verweise

Weitere Lektüre

• Alexandrescu, Andrei (4. Januar 2010). Die D -Programmiersprache (1 ed.). Addison-Wesley Professional. ISBN 978-0-321-63536-5.
• Alexandrescu, Andrei (15. Juni 2009). "Der Fall für D". Dr. Dobbs Journal.
• Bright, Walter (8. April 2014). "Wie ich gekommen bin, um D zu schreiben". Dr. Dobbs Journal.
• Çehreli, Ali (1. Februar 2012). "Programmierung in D". (verteilt unter CC-by-NC-SA-Lizenz). Dieses Buch lehrt die Programme für Anfänger, deckt jedoch auch viele fortgeschrittene D -Themen ab.
• Metz, Cade (7. Juli 2014). "Die nächste große Programmiersprache, von der Sie noch nie gehört haben". Verdrahtet.
• Ruppe, Adam (Mai 2014). D Kochbuch (1 ed.). Packt Publishing. ISBN 978-1-783-28721-5.

Externe Links

• Offizielle Website
• Digital Mars
• Türkisches Forum
• Dlang an GitHub