Das ist das Ende von C++!

Simon2

quote experte schrieb:

std::vector ... um nur ein Beispiel zu nennen ...

Wäre ein gutes Beispiel, wenn es nicht etwas analoges dazu in Java geben würde, dass diese Klasse als Argument entkräftet ..

Ein gutes Beispiel für ein template mit Kopiersemantik (auch für Klassentypen) ? Da bin ich wirklich gespannt...

Übrigens: IIRC C hat dasselbe Problem ...

Gruß,

Simon2.

groovemaster

@daHa

Und wieso ist dann sowas mit const nicht möglich?

int main()
{
    int a = /*...*/;
    const int b = a;
}

Meine Frage diesbzgl. war ja erstmal vollkommen losgelöst vom Scope. Auf der einen Seite steht da, dass mit const Konstanten zur Kompilierzeit aufgelöst werden können. Auf der anderen Seite sehe ich aber nicht, wann und wo Laufzeitkonstanten möglich sind. Deshalb war ein nichtssagender Link auf die Doku einfach nur nutzlos.

daHa schrieb:

und das mit den mixin, du kannst das ja, ebenfalls aus der doku, in anderen sprachen nachprogrammieren und dir den unterschied anschaun, die anderen bsps ebenfalls dementsprechend evaluieren
int y = 3;

template Foo()
{
    int abc() { return y; }
}

void test()
{
    int y = 8;
    mixin Foo;  // local y is picked up, not global y
    assert(abc() == 8);
}

OK, nehmen wir einfach mal das Beispiel. Ohne Mixins schreibe ich

int y = 3;

void test()
{
    int y = 8;
    int abc() { return y; }
    assert(abc() == 8);
}

Wo soll hier die Notwendigkeit von Mixins sein? OK, ich höre dich jetzt schon aufschreien und sagen, es könnte ja theoretisch auch eine weitere Funktion geben, wo ich dann anstatt einer erneuten nested Funktion einfach "mixin Foo;" schreibe. Aber vllt. merkst du ja worauf ich hinaus will. Die Beispiele zeigen zwar ungefähr wie Mixins in D funktionieren. Sie sind aber relativ sinnlos. Deshalb war meine Frage, wo hier sinnvolle Anwendungen in "Real World Applications" sind, die mit anderen Sprachmitteln nicht möglich wären. Ich sehe keine, oder zumindest nur das was Clw schon schrieb, dass man damit Code Redundanzen vermeiden kann. Es sind im Grunde ja nichts anderes als scopelose Templates. "Normale" Templates scheinen mir aber grundsätzlich eine sauberere Lösung zu sein. Du kannst mich mit einem praktischen Beispiel aber gerne vom Gegenteil überzeugen.

daHa

das mit dem const ist in D so wie es eben ist
entweder etwas ist const, oder nicht
darueber zu diskutieren ob const wie in c++ mehr sinn macht wuerd die naechsten 20 seiten sinnlos hin und her fabrizieren.

bez mixin, reald wordl bsps hab ich keine, leider fehlt mir die zeit mich mehr als hin und wieder ein paar minuten mit D zu beschaeftigen

was mir aber als zb einfaellt waer folgendes

import std.stdio;

interface IReader{
	void doRead();
}
//------------------------------------------------
interface IWriter{
	void doWrite();
}
//------------------------------------------------
template IReaderDefaultImplementation(){
	void doRead(){
		doOpen();
		writefln("IReaderDefaultImplementation");
		doClose();
	}
}
//------------------------------------------------
template IWriterDefaultImplementation(){
	void doWrite(){
		doOpen();
		writefln("IWriterDefaultImplementation");
		doClose();
	}
}
//------------------------------------------------
template RWDeviceFile(){
	void doOpen(){  writefln("OpenFile"); }
	void doClose(){ writefln("CloseFile"); }
}
//------------------------------------------------
template RWDeviceSpezial(){
	void doOpen(){ writefln("OpenSpezial"); }
	void doClose(){ writefln("CloseSpezial"); }
}
//------------------------------------------------

class ARWFile : IReader, IWriter {
	mixin RWDeviceFile ; 
	mixin IReaderDefaultImplementation ; 
	mixin IWriterDefaultImplementation ;
}

class ARWSpezial : IReader, IWriter {
	mixin RWDeviceSpezial ; 
	mixin IReaderDefaultImplementation ; 
	mixin IWriterDefaultImplementation ;
}

class ARWasGanzSpezielles : IReader {
	void doOpen(){  writefln("Open WasAnderes"); }
	void doClose(){ writefln("Close WasAnderes"); }
	mixin IReaderDefaultImplementation ; 

}

class AWNochWasSpezielles : IWriter {
	mixin RWDeviceFile ; 
	void doWrite(){
		doOpen();
		writefln("NochWasSpezielles in datei schreiben");
		doClose();
	}

}

/*
weitere lustige kombinationen
*/

int main(char[][] args)
{
	ARWFile rwf = new ARWFile() ;
	ARWSpezial rws = new ARWSpezial() ;
	IReader rwgs = new ARWasGanzSpezielles();
	IWriter wnws = new AWNochWasSpezielles();

	rwf.doRead();
	rwf.doWrite();

	rws.doRead();
	rws.doWrite();

	rwgs.doRead();

	wnws.doWrite();

    return 0;
}

groovemaster

daHa schrieb:

darueber zu diskutieren ob const wie in c++ mehr sinn macht wuerd die naechsten 20 seiten sinnlos hin und her fabrizieren.

Darum geht es doch gar nicht. Die Frage war lediglich, ob D den gleichen Umfang an const Semantik bietet. Offensichtlich ist dem nicht so. Das ist vollkommen wertungsfrei zu sehen.

Und dein Beispiel mit den Mixins, das sieht für mich sehr nach Präprozessor aus. Sehe ich aber nicht nur als unnütz, sondern sogar eher negativ. So kann ganz schnell das Design leiden. Kann denn die Implementation hier sicherstellen, dass das selbe Mixin auch nur eine Instanz im Speicher anlegt? So wie es zB wäre, wenn man den Basisklassen/Interfaces gleich eine passende default doRead und doWrite Implementation spendieren würde.

daHa

ein vergleich mit preprocessor (makros) ist sicher angebracht, allerdings kommen mir D mixin doch weit maechtiger vor.
unnütz find ich es nicht, ob das jetzt negativ ist ist bewertungssache.
viele java oder c# programmierer finden auch in C++ sachen negativ und unnuetz.
obriges bsp ist eigentlich ein bsp fuer mehrfachvererbung, die es in D eigenglich nicht gibt, aber durch mixin doch realtiv unaufwendig und flexibel realisierbar ist, glaub mit java oder c# waers etwas aufwendiger zum implementieren
es gibt aber sicher auch noch einen haufen anderer sachen wo das ganze sinn macht bzw machen koennte
(debug release utiltest code switch usw ....)
das man damit auch haufenweise bloedsinn machen kann ist mir vorerst egal, mit c++ muss ich auch aufpassen das ich mir nicht in den eigenen fuss schiess.