Let's D

Druckbare Version

26.09.2009, 19:52
Kyuu

Let's D
Was ist D?

D ist eine neue Programmiersprache, die seit 1999 von Walter Bright (Digital Mars) entwickelt wird und erstmals 2007 in einer stabilen 1.0 Version erschien. In der vorerst experimentellen 2.0 Version, wird D weiter ausgebaut und erweitert.
Die Sprache lehnt sich syntaktisch stark an C/C++ an und weist Ähnlichkeiten mit weiteren Sprachen wie zum Beispiel Java auf. Außerdem ist sie performant wie C - eignet sich also hervorragend als Systemsprache - und gleichzeitig komfortabel und produktiv wie Ruby und Python.

Was bietet D?

D versucht in erster Linie dem Programmierer so viel (fehleranfällige) Arbeit abzunehmen wie es möglich ist, durch Features wie dem automatischen Garbage Collector, als Systemsprache verbietet sie aber nicht und erlaubt sowohl Low-Level Programmierung mit Zeigern, Inline Assembly, etc, als auch den Lebenszyklus von Objekten komplett selbst zu steuern durch Support von Konstruktoren und Destruktoren (essentiell für RAII), falls Determinismus gewünscht wird.

D bietet eine Reihe mächtiger DbC-Konstrukte (Design by Contract) an, die zur Qualitätsverbesserung der Software verwendet verden können.

D ist C-linkfähig, es ist also möglich C-Funktionen aus D aufzurufen. Damit stehen D-Entwicklern alle Bibliotheken zur Verfügung, die in C geschrieben wurden.
Um auf C++-Bibliotheken zugreifen zu können, ist eine C-Abstraktionsschicht erforderlich.

D erlaubt Programmierparadigmen wie imperative, objektorientierte und Metaprogrammierung.

D automatisiert Unit Testing, Documentation Generation, Profiling und Debugging.

Ds Standardbibliothek Phobos, sowie die Community-gewartete Bibliothek Tango bieten eine riesige Palette an Funktionalität, wie Higher-Order Programming, I/O, Multithreading (Synchronisation ist bereits in der Sprache integriert), Networking, Internationalization Support, Compressing/Decompressing Algorithmen, etc.

Ich könnte so weitermachen, aber stattdessen verweise ich auf die offizielle Webseite, die bereits einen ausführlichen Überblick über Ds Umfang gibt.

Beispiele?
Code (D):
```
 
import std.stdio;
void main {
    writeln("Hello MMX!");
}
 
```
Das obligatorische "Hello World", nur mit "MMX" statt "World".
D kennt echte Packages und Module! Header Files fallen in D weg und damit auch Undinge wie Include Guards, Forward Declarations und redundanter Code.
Ein Package in D ist ein Verzeichnis und ein Modul ist eine *.d Datei. In diesem Fall ist also std das Package und stdio das zu importierende Modul. Module können übrigens eigene Konstruktoren und Destruktoren haben und werden garantiert immer in der richtigen Reihenfolge initialisiert und zerstört, falls es Abhängigkeiten zwischen Modulen gibt.
Code (D):
```
 
import std.stdio;
void main {
    int var;
    writefln("%d", var);
}
 
```
In D werden alle Variablen automatisch mit den Standardwerten ihrer Datentypen initialisiert. var wird also mit 0 initialisiert und entsprechend sieht dann die Ausgabe aus. Das hat den entscheidenden Vorteil, dass subtile Bugs, ausgelöst durch nicht initialisierte Variablen, erst gar nicht entstehen können.
Variablen besitzen übrigens statische Attribute, unterschiedlich je nach Datentyp. Man könnte zum Beispiel vor einer Zuweisung mit wert >= var.min && wert <= var.max prüfen, ob wert überhaupt in var dargestellt werden kann.
Code (D):
```
 
import std.stdio;
 
interface Eatable {
    void eat();
}
 
interface Flyable {
    void fly();
}
 
class Creature {
}
 
class Bird : Creature, Eatable, Flyable {
    this() {
        writeln("Bird created...");
    }
 
    ~this() {
        writeln("Bird destroyed...");
    }
 
    void eat() {
        writeln("Bird is being eaten!");
    }
 
    void fly() {
        writeln("Bird flies!");
    }
}
 
void main() {
    Flyable flyable_bird = new Bird;
    flyable_bird.fly();
    Eatable eatable_bird = new Bird;
    eatable_bird.eat();
}
 
```
D kennt neben Klassen auch Interfaces (in C++ vergleichbar mit abstrakten Basisklassen). Während von Klassen nur einfach geerbt werden kann, gibt es bei Interfaces keine Grenzen. Mehrfaches Erben von Klassen ist schwierig zu implementieren, weswegen viele Sprachen klugerweise nur einfaches Erben erlauben und darüber hinaus Interfaces anbieten.
Methoden sind in D standardmäßig virtuell und der Compiler entscheidet darüber, ob es Sinn macht, eine Methode nicht-virtuell zu machen. Wieder eine nervige Fehlerquelle beseitigt.
Code (D):
```
 
import std.stdio;
 
class Number {
    void value(int val) {
        value_ = val;
    }
 
    int value() {
        return value_;
    }
 
    private int value_;
}
 
void main() {
    Number num = new Number;
    num.value = 123;
    writefln("num's value: %d", num.value);
}
 
```
D erlaubt Attribute auch als solche zu behandeln. Nie wieder stupide Getter und Setter!

Da dies kein Tutorial werden soll, denke ich, reicht es fürs Erste. Sollte noch jemand Fragen haben, werde ich darauf natürlich eingehen.

Welche Plattformen werden unterstützt?

Windows - DMD | GDC (über MinGW oder Cygwin)
Mac OS X - DMD | GDC
Linux - DMD | GDC
FreeBSD - DMD | GDC
AIX - GDC

Unterstützung für weitere Plattformen folgt in der Zukunft.

Links:

Digital Mars D - Offizielle Webseite.

D 1.0 Language - Offizielle Sprachreferenz zu D1.

D 2.0 Language - Offizielle Sprachreferenz zu D2.

Tango - Community-eigene Standardbibliothek, die Phobos in Sachen Umfang weit überbietet.

dsource - Zentrale Anlaufstelle für Source Code und Projekte. Enthält auch Tutorials.

The Case For D - Ein Artikel geschrieben von Andrei Alexandrescu, der sich aktiv an Ds Entwicklung beteiligt und in dem er kurz einige der wichtigsten Aspekte der Programmiersprache D aus einer professionellen Perspektive erläutert.

Wiki4D - Verschiedene Tutorials.

IDEs/Editoren findet ihr hier.

Literatur:

Es gibt leider noch nicht viele Bücher zu D. Persönlich habe ich bereits zwei gelesen und kann sie dementsprechend empfehlen oder nicht empfehlen.

Programmieren in D - Dieses Buch kratzt nur an der Oberfläche und ist, soweit ich mich erinnere, stellenweise fehlerhaft. Es ist allerdings in Deutsch geschrieben und wäre vielleicht angenehmer zu lesen. Wer ausreichende Englischkenntnisse besitzt, ist mit einem der folgenden Bücher besser bedient.

Learn To Tango With D - Ein ausführliches Buch, das sowohl die Sprache beschreibt - also auch für Einsteiger nützlich, die Phobos verwenden, als auch sich auf die Bibliothek Tango konzentriert. Sehr preiswert und empfehlenswert.

The D Programming Language - Dieses Buch ist leider noch in Arbeit und wird von Andrei Alexandrescu verfasst, bekannt beispielsweise für sein Buch Modern C++ Design. Man kann bereits vorbestellen und da ich vom Autor Qualität gewohnt bin, kann ich es nur jedem empfehlen. Es wird übrigens das erste Buch sein, das auch die D 2.0-Spezifikation behandelt.
27.09.2009, 18:06
DFYX

Im Prinzip also die Vorteile von C, C++ und Java vereint, ohne sich (wie bei C#) an eine VM zu fesseln, sehe ich das richtig?

Über ein Tutorial würd ich mich übrigens dann doch freuen.
27.09.2009, 18:39
drunken monkey

Zitat:

Zitat von DFYX

Im Prinzip also die Vorteile von C, C++ und Java vereint, ohne sich (wie bei C#) an eine VM zu fesseln, sehe ich das richtig?

Ja, das versucht sie zumindest. Imo hat sie sich dabei zwar doch auch einige der Nachteile, speziell bei C++ (die Erlernbarkeit z.B. ^^") eingefangen, aber ein paar Blicke ist sie auf jeden Fall wert. :D Vor allem mit höherer Verbreitung könnte die Sprache echt stark werden, auch wenn das wohl unwahrscheinlich ist.

Und hast du bei den bestehenden Tutorials im Netz (sind ja auch welche im Anfangspost verlinkt) echt nichts gefunden?
27.09.2009, 19:04
Kyuu

Zitat:

Zitat von DFYX

Im Prinzip also die Vorteile von C, C++ und Java vereint, ohne sich (wie bei C#) an eine VM zu fesseln, sehe ich das richtig?

Allgemein kann man duchaus sagen, dass D viele der Vorteile anderer Sprachen vereint. Allerdings bietet D doch viel eigenes und sollte nicht nur als ein Mix anderer Sprachen bezeichnet werden, falls es so gemeint war.
Ansonsten, ja, du siehst es richtig. :)

Zitat:

Zitat von DFYX

Über ein Tutorial würd ich mich übrigens dann doch freuen.

Ich habe anfangs überlegt, ob ich besser ein Tutorial schreiben sollte, es aber dann doch verworfen, weil ein gutes Tutorial Zeit braucht, die ich im Moment nicht habe und ein unausgereiftes Tutorial kommt für mich nicht in Frage. Ein deutschsprachiges Tutorial reizt mich aber schon, eventuell kommt da was in einigen Wochen.

Englischsprachige Tutorials findest du zum Beispiel hier und hier.

Persönlich würde ich aber doch eher zu einem guten Buch raten, wenn es dir ernst ist.

Zitat:

Zitat von drunken monkey

Imo hat sie sich dabei zwar doch auch einige der Nachteile, speziell bei C++ (die Erlernbarkeit z.B. ^^") [...]

Abgesehen davon, dass Ds Zielgruppe offiziell als intermediate und advanced bezeichnet wird (Who D Is Not For), die Sprache sich aber dennoch viel besser für Neulinge eignet als C++, da viel konsistenter und fehlersicherer, würde mich dann doch interessieren, welche Nachteile sich D bei C++ sonst abgeguckt haben soll? :)

Zitat:

Zitat von drunken monkey

Vor allem mit höherer Verbreitung könnte die Sprache echt stark werden, auch wenn das wohl unwahrscheinlich ist.

Du scheinst da mehr zu wissen als ich. Darf ich fragen wieso es unwahrscheinlich ist?
27.09.2009, 19:05
Mog

Also, wir haben damals noch D gelernt, in dem wir die BNF gelesen haben und die feature-list duchgeblaettert sind.
27.09.2009, 19:05
DFYX

Zitat:

Zitat von drunken monkey

Und hast du bei den bestehenden Tutorials im Netz (sind ja auch welche im Anfangspost verlinkt) echt nichts gefunden?

Das hab ich nicht behauptet :p Ich sagte, ich würde mich über eins freuen, mehr nicht.

Edit: außerdem hab ich momentan wegen Klausurstress ohnehin keine Zeit, mich durch mehr als ein oder zwei Tutorials zu wühlen.
27.09.2009, 20:47
drunken monkey

Zitat:

Zitat von Kyuu

Abgesehen davon, dass Ds Zielgruppe offiziell als intermediate und advanced bezeichnet wird (Who D Is Not For), die Sprache sich aber dennoch viel besser für Neulinge eignet als C++, da viel konsistenter und fehlersicherer, würde mich dann doch interessieren, welche Nachteile sich D bei C++ sonst abgeguckt haben soll? :)

Naja, "besser geeignet als C++" ist nicht wirklich so schwierig. XD Aber ja, sonst fällt mir eh nicht wirklich was ein. ^^" Von Java kommend hat mich wohl einfach gestört, dass sich die Sprache mehr an C++ als an Java hält. Und aufgrund der Einstiegsschwierigkeiten habe ich mich dann auch nicht so sonderlich lang damit beschäftigt.

Zitat:

Du scheinst da mehr zu wissen als ich. Darf ich fragen wieso es unwahrscheinlich ist?

Frag' mal Mog, der hat mir damals einen halbstündigen Vortrag darüber gehalten. XD
Aber grundsätzlich imo einfach, weil die Informatik so nicht funktioniert, "es kommt eine bessere Sprache und wird benutzt". Vielleicht bei Skript-Sprachen noch eher, aber in dem Feld? C ist in sehr vielen Bereichen noch immer am weitesten verbreitet, selbst außerhalb von Systemprogrammierung, obwohl mit C++ schon längst eine deutliche bessere Alternative verfügbar ist.
Aber ist natürlich nur mein Tipp. *shrug*
27.09.2009, 22:34
Kyuu

Zitat:

Zitat von drunken monkey

Naja, "besser geeignet als C++" ist nicht wirklich so schwierig. XD Aber ja, sonst fällt mir eh nicht wirklich was ein. ^^" Von Java kommend hat mich wohl einfach gestört, dass sich die Sprache mehr an C++ als an Java hält. Und aufgrund der Einstiegsschwierigkeiten habe ich mich dann auch nicht so sonderlich lang damit beschäftigt.

Um nochmal den Unsinn deines Argumentes zu betonen (ohne dich persönlich angreifen zu wollen ;)), kann man es folgendermaßen zusammenfassen: "D hat sich bei C++ abgeguckt keine Einstiegssprache zu sein!"
Also bitte...

Mich würde aber trotzdem noch interessieren wieso D "von Java kommend" ist und was du in D vermisst, was in Java vorhanden ist. Ich möchte pauschale Aussagen soweit es geht vermeiden, deshalb solltest du schon konkreter werden, damit die Leser auch wissen was genau du meinst.

Zitat:

Zitat von drunken monkey

Frag' mal Mog, der hat mir damals einen halbstündigen Vortrag darüber gehalten. XD

Na dann leite ich die Frage weiter an Mog. :)

Zitat:

Zitat von drunken monkey

Aber grundsätzlich imo einfach, weil die Informatik so nicht funktioniert, "es kommt eine bessere Sprache und wird benutzt". Vielleicht bei Skript-Sprachen noch eher, aber in dem Feld? C ist in sehr vielen Bereichen noch immer am weitesten verbreitet, selbst außerhalb von Systemprogrammierung, obwohl mit C++ schon längst eine deutliche bessere Alternative verfügbar ist.
Aber ist natürlich nur mein Tipp. *shrug*

Erstens: Ich denke nicht, dass jede neue Sprache sofort zum Standard erklärt wird, da gibt es wohl ein Missverständnis.
Fakt ist, dass D bis jetzt sehr gut ankam, was nicht selbstverständlich ist.
Fakt ist, dass eine neue Sprache gewünscht wird, die C++ ersetzen kann und da bietet sich D in jedem Aspekt an.
Fakt ist, dass D als eine ernstgemeinte, moderne, industriefähige Systemsprache entwickelt wird und kein Gag ist.
Fakt ist, dass D bereits eine stabile Version erreicht hat, was wiederum essentiell ist, um die Sprache überhaupt professionell gesehen zu erwägen.
Fakt ist, dass schon zum jetzigen Zeitpunkt Interesse gezeigt wird. An meiner Hochschule gibt es bereits interessierte Professoren, die es erwägen D bei ihren Arbeiten einzusetzen. Ich denke, dass es an anderen ähnlich ist.
C++ ist veraltet (und selbst C++0x wird nicht dauerhaft zufriedenstellen) und kann ohne viel Erfahrung sehr grauenhaft werden. Es gibt Leute, die halten die Sprache sogar für einen Rückschritt im Vergleich zu C.
All das berücksichtigt, denke ich, dass D sehr gute Chancen hat C++ als Industriestandard zu ersetzen. Wann das passieren wird, können ich und du und Mog nicht sagen, da ein Wechsel von C++ zu D nicht von einem Tag auf den anderen passieren kann und Interessenten erst gut abwägen werden, ob sich ein Wechsel so schnell lohnt. Wahrscheinlich werden sie erst noch einige Jahre abwarten, bis D sich noch weiter etabliert hat und es die ersten kommerziellen Präzedenzfälle gibt. Ds Entwickler räumen selbst ein, dass es realistisch gesehen Unsinn ist Millionen Zeilen C/C++-Code nach D zu konvertieren, alte Projekte also kaum davon profitieren werden. Bis genügend neue Projekte komplett in D entstehen, kann noch eine Weile dauern.

Zweitens: C++ lohnt sich nicht in allen Bereichen, weswegen heute noch C stattdessen eingesetzt wird, ist also nicht wirklich eine "deutlich bessere Alternative". Dann ist da noch das Wartungsproblem: Einmal C, immer C. Das gleiche Problem findest du auch bei anderen Programmiersprachen.
C komplett zu ersetzen ist also ein weitaus schwierigeres Unterfangen, als es vergleichsweise bei C++ der Fall ist. Glücklicherweise versucht D aber nicht C vom Thron zu stürzen, im Gegenteil, D hat absolut kein Problem damit, mit C zu koexistieren.

Ach übrigens: Wie funktioniert denn die Informatik? Mit ein Bisschen Glück hat dir Mog hier auch einen halbstündigen Vortrag gehalten. ;)
27.09.2009, 22:38
Mog

Wenn schon habe ich erklaert, warum der Markt D mit hoher Wahrscheinlichkeit nicht akzeptieren wird, und warum ich als Projektleiter D lange keine Chance geben wuerde. ;)

Nicht alles, was in einer Plauderrei technisch und durchdacht toent, ist eine Prognose ....
27.09.2009, 23:13
drunken monkey

Zitat:

Zitat von Kyuu

Um nochmal den Unsinn deines Argumentes zu betonen (ohne dich persönlich angreifen zu wollen ;)), kann man es folgendermaßen zusammenfassen: "D hat sich bei C++ abgeguckt keine Einstiegssprache zu sein!"
Also bitte...

Äh, ja, möglicherweise. XD
Gut, ich gebe zu, ich habe mich mit D nicht genug beschäftigt, um fundiert mitreden zu können. ^^" Mir hat die Sprache eigentlich auch ziemlich gefallen, von der Feature-Liste, aber so richtig warm geworden bin ich dann doch nicht mit ihr.
Muss wohl jeder für sich probieren. *shrug*

Zitat:

Mich würde aber trotzdem noch interessieren wieso D "von Java kommend" ist und was du in D vermisst, was in Java vorhanden ist.

Nicht D ist von Java kommend (eben ganz im Gegenteil), sondern ich. ;) Daher liegt mir die C++-artigere Herangehensweise eben nicht so, also auch bloßer Geschmack.
Beispiel wären Templates, grauenhafte Templates…x__X

Zitat:

Ach übrigens: Wie funktioniert denn die Informatik? Mit ein Bisschen Glück hat dir Mog hier auch einen halbstündigen Vortrag gehalten. ;)

Man gibt ein paar Nullen und Einsen in eine Maschine, drückt auf Start, flucht, werkelt – unterbrochen von einigen Schlägen und Tritten auf die Maschine – einen halben Tag und hat am Ende mit ein bisschen Glück etwas das zwar nicht wirklich funktional, aber zumindest interessant ist. ^^

Zitat:

Zitat von Mog

Wenn schon habe ich erklaert, warum der Markt D mit hoher Wahrscheinlichkeit nicht akzeptieren wird, und warum ich als Projektleiter D lange keine Chance geben wuerde. ;)

Nicht alles, was in einer Plauderrei technisch und durchdacht toent, ist eine Prognose ....

Wenn du sagst, dass etwas mit hoher Wahrscheinlichkeit passiert, ist das doch eine Prognose. o_O"

Aber gut, ich verabschiede mich hier wohl besser wieder, bevor ich meinen ganzen imaginären Ruf verliere. XD
27.09.2009, 23:24
Kyuu

Zitat:

Zitat von drunken monkey

Nicht D ist von Java kommend (eben ganz im Gegenteil), sondern ich. ;) Daher liegt mir die C++-artigere Herangehensweise eben nicht so, also auch bloßer Geschmack.
Beispiel wären Templates, grauenhafte Templates…x__X

Ah, da habe ich wohl etwas falsch verstanden, sorry. :D

Aber ich gebe zu, es ist nachvollziehbar, wenn du nach Java Sprachen wie C++ oder D als unangenehm oder schwierig empfindest. Java hat nunmal eine ganz andere Philosophie.
27.09.2009, 23:37
DFYX

Das kann man auch umgekehrt sehen. Ich halte es dafür für furchtbar umständlich, dass in Java selbst main eine statische Methode einer Klasse ist. Objektorientierung ist schön und gut, aber manchmal einfach unlogisch. Genau deshalb finde ich eigentlich, dass C++ und D in einigen Punkten doch sehr intuitiv sind (auch wenn ich die Syntax von C++ und besonders einige Neuerungen von C++0x äußerst verwirrend und kryptisch finde)
28.09.2009, 02:12
drunken monkey

Zitat:

Zitat von DFYX

Das kann man auch umgekehrt sehen. Ich halte es dafür für furchtbar umständlich, dass in Java selbst main eine statische Methode einer Klasse ist. Objektorientierung ist schön und gut, aber manchmal einfach unlogisch. Genau deshalb finde ich eigentlich, dass C++ und D in einigen Punkten doch sehr intuitiv sind (auch wenn ich die Syntax von C++ und besonders einige Neuerungen von C++0x äußerst verwirrend und kryptisch finde)

Ja, gut, das mit main() ist echt sowohl unlogisch als auch nervig, aber beides nur etwas, und im Sinne einer einheitlichen Sicht der Dinge (-> eine Datei enthält als oberste Ebene nur Klassen) ist das imo doch vertretbar.
Und Generezität ist imo in Java viel besser gelöst, oder zumindest simpler/intuitiver. Womit wir natürlich bloß wieder bei Einsteigerfreundlichkeit wären.

(Jetzt geht's um Java, da kann ich wieder reden. XD)
28.09.2009, 06:51
Ineluki

Ich hab die Tutorials aus Zeitmangel noch nicht angesehen, aber ersteinmal schon sehr vielen Dank fuer deine Muehen und die Zusammenfassung:

Trotzdem hab ich ein paar sehr kurze Fragen:

Gibt es:
* Operatorenueberladung ?
* Templates ?
b = a; b.x=5; a.x == 5 ? Ist operator= bei Klassen standardmaessig Copy-Operator (also separater Speicher) oder Copy of Reference ?
28.09.2009, 08:26
Kyuu
Zitat:

Zitat von Ineluki

Operatorenueberladung ?

http://www.digitalmars.com/d/2.0/ope...erloading.html

Zitat:

Zitat von Ineluki

Templates ?

http://www.digitalmars.com/d/2.0/template.html

Zitat:

Zitat von Ineluki

b = a; b.x=5; a.x == 5 ? Ist operator= bei Klassen standardmaessig Copy-Operator (also separater Speicher) oder Copy of Reference ?

Bei Klassen wird standardmäßig die Referenz kopiert. Bei Strukturen wird bitweise kopiert.
Objekte werden übrigens auch standardmäßig auf dem Heap alloziert. Um explizit auf dem Stack zu allozieren, wird das Schlüsselwort scope vorangestellt.
Code (D):
```
 
class A {
    int v;
}
 
void main() {
    auto a1 = new A; // a1 ist auf dem Heap alloziert
    scope a2 = new A; // a2 ist auf dem Stack alloziert
}
 
```
Edit: Sieht aus, als würde euer Syntaxhighlighter nicht alle D-Schlüsselwörter umfassen. :/
28.09.2009, 13:59
DFYX

Hm, irgendwie find ich da die Art, wie Operatorenüberladung in C++ funktioniert, übersichtlicher, aber das wird wohl Gewohnheitssache sein.

Außerdem kann mich mir vorstellen, dass man bei der Templatesache höllisch schnell durcheinander kommt, wenn man beispielsweise Iteratoren bastelt, weil ja, soweit ich das verstanden hab, bei gleichem Parametertyp auch die gleiche Instanz weiterverwendet wird.
28.09.2009, 15:03
drunken monkey

Zitat:

Zitat von DFYX

Hm, irgendwie find ich da die Art, wie Operatorenüberladung in C++ funktioniert, übersichtlicher, aber das wird wohl Gewohnheitssache sein.

Kenne mich in C++ nicht damit aus, aber in D hat mich auch gestört, dass man beim Casting-Operator (afaik) nicht den Ziel-Typ mitgeliefert bekommt. o_O Man muss also irgendwas zurückliefern und hoffen, dass das in dem Kontext halbwegs passt.
Oder ich habe was übersehen. ^^"

Zitat:

Außerdem kann mich mir vorstellen, dass man bei der Templatesache höllisch schnell durcheinander kommt, wenn man beispielsweise Iteratoren bastelt, weil ja, soweit ich das verstanden hab, bei gleichem Parametertyp auch die gleiche Instanz weiterverwendet wird.

Templates fand ich wie gesagt auch sehr verwirrend, aber mit denen komme ich auch in C++ nicht ganz klar. ^^"
28.09.2009, 19:42
Kyuu

Zitat:

Zitat von DFYX

Außerdem kann mich mir vorstellen, dass man bei der Templatesache höllisch schnell durcheinander kommt, wenn man beispielsweise Iteratoren bastelt, weil ja, soweit ich das verstanden hab, bei gleichem Parametertyp auch die gleiche Instanz weiterverwendet wird.

Nein, natürlich nicht. Wo hast du das gelesen?

Zitat:

Zitat von drunken monkey

Kenne mich in C++ nicht damit aus, aber in D hat mich auch gestört, dass man beim Casting-Operator (afaik) nicht den Ziel-Typ mitgeliefert bekommt. o_O Man muss also irgendwas zurückliefern und hoffen, dass das in dem Kontext halbwegs passt.
Oder ich habe was übersehen. ^^"

Der Rückgabetyp ist der Typ zu dem du umwandelst. Das hat den Nachteil, dass momentan nur ein opCast pro Klasse/Struktur möglich ist. Das soll sich in Zukunft ändern, soweit ich weiß.
28.09.2009, 19:47
DFYX
Zitat:

Zitat von Kyuu

Nein, natürlich nicht. Wo hast du das gelesen?

Da:
Zitat:
Multiple instantiations of a TemplateDeclaration with the same TemplateArgumentList, before implicit conversions, all will refer to the same instantiation. For example:

Code (D):
template TFoo(T) { T f; } alias TFoo!(int) a; alias TFoo!(int) b; ... a.f = 3; assert(b.f == 3); // a and b refer to the same instance of TFoo
Jedenfalls hab ich das so interpretiert.

Edit: ah, nicht richtig hingeschaut, das bezieht sich nur auf Aliases.
28.09.2009, 19:56
drunken monkey

Zitat:

Zitat von Kyuu

Der Rückgabetyp ist der Typ zu dem du umwandelst. Das hat den Nachteil, dass momentan nur ein opCast pro Klasse/Struktur möglich ist. Das soll sich in Zukunft ändern, soweit ich weiß.

Genau das meinte ich. Der Rückgabetyp ist klar, es ist aber nicht möglich, herauszufinden, zu welchem Typ gecastet werden sollte. Also muss man schon vorher wissen, zu welchem Typ die Leute ein Objekt der Klasse am ehesten casten wollen könnten. Unpraktisch. :-/
28.09.2009, 20:37
Kyuu
Zitat:

Zitat von drunken monkey

Genau das meinte ich. Der Rückgabetyp ist klar, es ist aber nicht möglich, herauszufinden, zu welchem Typ gecastet werden sollte. Also muss man schon vorher wissen, zu welchem Typ die Leute ein Objekt der Klasse am ehesten casten wollen könnten. Unpraktisch. :-/

Ich glaube ich muss es noch etwas detaillierter erklären.
Zum einen wird opCast nur bei expliziten Casts angewandt, d.h. bei Ausdrücken der Form cast(typ)variable.
Zum anderen finden bei solchen Ausdrücken bis zu zwei Casts nacheinander statt, nämlich der explizite Cast durch opCast (falls definiert), und anschließend der implizite Cast vom Typ des vorherigen Casts zum Typ, der im Ausdruck steht (falls nicht sowieso schon identisch und falls ein impliziter Cast überhaupt möglich ist). Dabei ist nicht etwa wichtig, dass opCast genau zu dem Typ castet, der im Ausdruck steht, sondern, dass es zu einem Typ castet, der - falls nötig - implizit zu dem Typ gecastet wird, der im Ausdruck steht.
Damit man es sich besser vorstellen kann, hier ein Musterbeispiel für opCast:
Code (D):
```
 
class Circle {
  // ...
}
 
class Integer {
    this() {
    }
 
    this(int val) {
        value = val;
    }
 
    int opCast() {
        return value;
    }
 
    private int value;
}
 
void main() {
    auto a = new Integer(123);
    auto b = cast(int)a; // ok, explizit von Integer nach int
    auto c = cast(long)a; // ok, explizit von Integer nach int 
                          // und implizit von int nach long
    auto d = cast(Circle)a; // fehler, explizit von Integer nach int möglich,
                            // aber implizit von int nach Circle unmöglich!
}
 
```
Wie man sieht, reicht es absolut aus, mit opCast zu einem festen Typ zu casten, der dann dennoch implizit zu jedem numerischen Basistyp gecastet werden kann.

Auch sollte man anmerken, dass ein Cast Sinn machen muss. Es wäre sowohl unsinnig explizit von Integer nach Circle innerhalb von opCast zu casten (obwohl es durchaus möglich ist), als auch implizit von int nach Circle, da die Typen untereinander logisch unverträglich sind.

Ansonsten: Wie bereits geschrieben, könnte opCast zukünftig überladbar werden.

Edit: @DFYX:

Da du Iteratoren angesprochen hast: In D sind Iteratoren, entgegen der C++ STL, eher unüblich. In der Regel werden Ranges verwendet. Folgendes wäre für dich also vielleicht von Interesse:

ForEach
ForEachRange
std.range