Skepsis am neuen Standard

[audacia]

Nexus schrieb:

Ich verstehe aber, dass das aufgrund der existierenden Templates, die auch meistens angewandt werden, nicht wirklich eine Alternative darstellt.

Das ist der Punkt.

[audacia]

knivil schrieb:

Templates sind Generics.

Nein.

knivil schrieb:

Und zum Thema Closures: das "Feature" hat schon C

Nein.

Wie kommst du dazu, anderen das Verbreiten von Halbwahrheiten anzulasten?

[knivil]

Fuer dich Wikipedia: http://de.wikipedia.org/wiki/Generischer_Typ und http://de.wikipedia.org/wiki/Closure . Objekte koennen Closures sein, Closures koennen Objekte sein.

Wie kommst du dazu, anderen das Verbreiten von Halbwahrheiten anzulasten?

Weil sie anscheinend dahinterstehende Konzepte nicht verstanden haben. Klar ist das Generics aus C# nicht vergleichbar mit denen aus C++, aber es sind doch beides Elemente der generischen Programmierung, Generics.

[Simon2]

Hi audacia,

ich will Dir gar nicht widersprechen, aber ich habe den Eindruck, dass hier einfach 2 Paradigmen aufeinanderstoßen: Compilezeit vs. Laufzeit.

Da schlägt sich C++ halt sehr eindeutig auf die Seite der Compilezeit (außer z.B. bei exceptione specifications, wo es mal wirklich sinnvoll gewesen wäre ). Je mehr man das Ziel verfolgt, möglichst alle Fehlerquellen bereits zur Compilezeit auszumerzen und das Ganze noch mit generischer Programmierung würzt, desto schwerer wird es einfach, dem Compiler den kompletten Quellcode vorzuenthalten .... mit allen Nachteilen wie: Zerbröselnde Linkzeit-Modularisierung, unzureichende Typinformation zur Laufzeit (wobei man die als "Gimmick" wohl trotzdem implementieren dürfte, es aber wohl eher nicht so wichtig ansieht), ...
Vielleicht haben sich die C++-Kommittee-ler auch einfach gedacht: "Wer das möchte, ist mit Java prima bedient."

Ich persönlich vermisse die "Compilerunabhängigkeit" (und sei es nur auf einer Plattform) am meisten; für jedes Produkt NxM-Matrizen an plattform- UND compiler(versions)abhängigen Libs gegeneinander abgleichen zu müssen, wird zur Sysiphusarbeit und oftmals absoluten Innovationsbremse...

Gruß,

Simon2.

[Nexus]

Shade Of Mine schrieb:

Warum ist es wichtig ob es ein vector<int, std::allocator> oder ein vector<int, my_alloc> oder ein my_vec<int> ist?

Ich habe jetzt eher im Vergleich zu std::list oder anderen Containern gemeint. Das Wissen über den Allokator kann zwar auch nie schaden, aber das ist leicht bei der Deklaration (oder beim Rückgabetypen einer Funktion) nachlesbar.

Shade Of Mine schrieb:

auto iter = v.begin();

ist zB super praktisch. wozu muss ich hier extra den typen angeben. mich interessieren die allocatoren doch garnicht, ich will nen iterator haben.

und das ist fast überall so. typen händisch angeben wenn es eh keine wahl gibt, ist sinnloser mehraufwand. es ist ja nicht so als ob es andere typen wären - auto reduziert den wartungsaufwand enorm. da du plötzlich nicht mehr dauernd typedef verwenden musst - sondern einfach auto nimmst.

Da hast du Recht, mit Iteratoren oder längeren Typen wie solchen aus Boost kann automatische Typerkennung wirklich sehr praktisch sein (hatte ich zwar früher bereits geschrieben, aber im letzten Post irgendwie verdrängt).

Aber schon beim begin() kann es zu Problemen führen, da man je nachdem einen const_iterator will... Oder?

Und eben befürchte ich, dass man schnell zur Übertreibung neigt, denn auto ist fast überall anwendbar, wo eine Initialisierung mit einem Ausdruck stattfindet.

auto x = 3;
auto pos = Object.GetPosition(); // Was ist jetzt pos? Vector<3, float> oder Vector<2, int>?
auto size = Blabla.GetSize();  // wie gross ist size? short? int? long? size_t?

Die Beispiele sind vielleicht etwas überspitzt, aber ich selber würde wahrscheinlich relativ schnell die Übersicht verlieren. Es fängt ja schon mit Dingen wie IntelliSense an, wo man sich nicht mehr viel Bezeichner merken muss. Mit auto bekommt man auch die Typen geschenkt. An manchen Orten ist die Abstraktion hilfreich, an anderen weniger...

knivil schrieb:

Fuer dich Wikipedia: http://de.wikipedia.org/wiki/Generischer_Typ

Hast du auch den Satz "Ein anderer Weg, den u.a. C++ geht, ist die Anwendung von Templates." gelesen?

[knivil]

Hast du auch den Satz "Ein anderer Weg, den u.a. C++ geht, ist die Anwendung von Templates." gelesen?

Soll ich dir auch den Artikel vorlesen: "Bei Programmiersprachen gibt es prinzipiell zwei Ansätze, generische Typen zu unterstützen ...". Und mit "ein anderer Weg" stellt einfach nur einen Gegensatz zur ersten Moeglichkeit dar. Ja und genau deswegen Halbwissen, weil aus nicht richtig Lesen und noch weniger Verstehen irgendwie 'ne Meinung entsteht, die einfach nur zum Himmel schreien ist.

[audacia]

knivil schrieb:

Fuer dich Wikipedia

Wikipedia-Links sind nicht gut geeignet, um zu kaschieren, daß du dich mit der Differentation von Templates und Generics noch nicht beschäftigt hast.

knivil schrieb:

Jedes Objekt kann man als Closure abstrahieren oder aber auch andersherum.

Der Unterschied zwischen der grundsätzlichen Möglichkeit und einer Sprachunterstützung ist dir bekannt?

Simon2 schrieb:

Vielleicht haben sich die C++-Kommittee-ler auch einfach gedacht: "Wer das möchte, ist mit Java prima bedient."

Den Eindruck habe ich auch

Simon2 schrieb:

Je mehr man das Ziel verfolgt, möglichst alle Fehlerquellen bereits zur Compilezeit auszumerzen und das Ganze noch mit generischer Programmierung würzt, desto schwerer wird es einfach, dem Compiler den kompletten Quellcode vorzuenthalten ....

Das stimmt schon, aber z.B. Generics sind ebenso typsicher wie Templates, können aber anders als diese in untypisiertem Zustand geparst werden. Dadurch ist dann auch ein export -Mechanismus gut machbar. (Praktischer Beweis: Delphi 2009. Das unterstützt Generics, die zur Übersetzungszeit instantiiert werden - sie sind demnach ebenso effizient wie Templates -, doch werden sie dennoch wie gewöhnliche Klassen geparst - was das Problem der nutzlosen Fehlermeldungen, das man in C++ durch Concepts angehen will, vermeidet.)

Simon2 schrieb:

Ich persönlich vermisse die "Compilerunabhängigkeit" (und sei es nur auf einer Plattform) am meisten; für jedes Produkt NxM-Matrizen an plattform- UND compiler(versions)abhängigen Libs gegeneinander abgleichen zu müssen, wird zur Sysiphusarbeit und oftmals absoluten Innovationsbremse...

So wünschenswert das wäre: auch hierfür ist es viel zu spät. An so etwas hätte man zu Anfang der Entwicklung denken müssen.

[Nexus]

Gut, auf Wikipedia werden Generics mit generischen Typen gleichgesetzt. Im Sprachgebrauch meint man mit Generics aber eher die Typen, wie sie z.B. in Java verwendet werden. Im englischen Wikipedia-Artikel werden die Begriffe zum Beispiel auch weniger verwaschen.

Ich hatte deinen Post zuerst auch so verstanden, als wolltest du Templates und Generics als identisch bezeichnen.

[knivil]

Nexus schrieb:

Gut, auf Wikipedia werden Generics mit generischen Typen gleichgesetzt. Im Sprachgebrauch meint man mit Generics aber eher die Typen, wie sie z.B. in Java verwendet werden. Im englischen Wikipedia-Artikel werden die Begriffe zum Beispiel auch weniger verwaschen.

Ich habe den englischen auch gelesen. Dort heisst es im Eingangsbeispiel: commonly called generics.

[Nexus]

knivil schrieb:

Ich habe den englischen auch gelesen. Dort heisst es im Eingangsbeispiel: commonly called generics.

Stimmt, hab ich übersehen. Wie dem auch sei, Wikipedia ist nicht der Weisheit letzter Schluss. Ich habe jedenfalls noch nie jemanden die C++-Templates Generics nennen hören, allzu verbreitet scheint der Begriff also nicht zu sein. Aber wenden wir uns lieber wieder dem Thema zu...

audacia schrieb:

Das stimmt schon, aber z.B. Generics sind ebenso typsicher wie Templates, können aber anders als diese in untypisiertem Zustand geparst werden. Dadurch ist dann auch ein export -Mechanismus gut machbar. (Praktischer Beweis: Delphi 2009. Das unterstützt Generics, die zur Übersetzungszeit instantiiert werden - sie sind demnach ebenso effizient wie Templates -, doch werden sie dennoch wie gewöhnliche Klassen geparst - was das Problem der nutzlosen Fehlermeldungen, das man in C++ durch Concepts angehen will, vermeidet.)

Wie kann die volle Typsicherheit in untypisiertem Zustand bewahrt werden? Das klingt auch so, als hätte sich das C++-Standardkomitee gar nichts überlegt.

[Simon2]

audacia schrieb:

...

Simon2 schrieb:

Je mehr man das Ziel verfolgt, möglichst alle Fehlerquellen bereits zur Compilezeit auszumerzen und das Ganze noch mit generischer Programmierung würzt, desto schwerer wird es einfach, dem Compiler den kompletten Quellcode vorzuenthalten ....

Das stimmt schon, aber z.B. Generics sind ebenso typsicher wie Templates, ...

Gleich vorweg: Mit Generics habe ich mich noch nicht beschäftigt und auch mit Delphi nicht.
Allerdings (oder vielleicht deswegen) fällt es mir schwer, mir vorzustellen, wie man das (vom Templateparameter abhängige) Verhalten eines Templates typsicher gestalten will, wenn man es nicht (noch) einmal mit diesem zusammen compiliert.

Wie gesagt: Kann an meiner Unwissenheit oder mangelnden Phantasie liegen, ist aber so.

Gruß,

Simon2.

[C++fan 2009]

C++-Progger, ein schrieb:

Warum tut das Standardkomitee eigentlich so als würde C++ in einer Luftblase existieren? Es wäre doch allen geholfen, wenn man C++ mit der realen Welt im Hinterkopf entwickeln würde, schließlich will man ja auch dort die Sprache einsetzen.

Man kann C++ sehr gut real einsetzen. Man braucht nicht jeden Quatsch verwenden, den es anbietet.

[Shade Of Mine]

Nexus schrieb:

Aber schon beim begin() kann es zu Problemen führen, da man je nachdem einen const_iterator will... Oder?

Um ehrlich zu sein: meistens ist mir das total egal.

Und eben befürchte ich, dass man schnell zur Übertreibung neigt, denn auto ist fast überall anwendbar, wo eine Initialisierung mit einem Ausdruck stattfindet.

Das finde ich zB super.

auto x = 3;
auto pos = Object.GetPosition(); // Was ist jetzt pos? Vector<3, float> oder Vector<2, int>?
auto size = Blabla.GetSize();  // wie gross ist size? short? int? long? size_t?

Warum ist es wichtig ob pos ein Vector<3, int> oder ein Vector<7, float> ist?
Und warum ist es wichtig welchen unsigned typen size hat? es ist groß genug die größe von Blabla zu beinhalten. wenn ich eine bestimmte größe haben will, dann gebe ich den typen selber an. aber meistens will ich das nicht. vorallem wenn templates im spiel sind.

typename vector_type::iterator i = v.begin();
typename vector_type::iterator e = v.end();
while(i!=e) {
  typename vector_type::value_type copy = *i;
  copy.foo();
  ++i;
}

*brr*

viel schöner:

for(auto i=v.begin(), e=v.end(); i!=e; ++i) {
  auto copy = *i;
}

Überall wo du mit templates zu tun hast wird der code soviel klarer durch auto.

vorallem wenn du plötzlich template factories hast:
auto func = create_expression<TypeList<foo, bar, baz, None>>();

Es fängt ja schon mit Dingen wie IntelliSense an, wo man sich nicht mehr viel Bezeichner merken muss. Mit auto bekommt man auch die Typen geschenkt. An manchen Orten ist die Abstraktion hilfreich, an anderen weniger...

Und wo ist das schlecht? Intellisense ist super weil ich mir nix merken muss und auto erspart mir wieder sinnlose information zu tippen.

[Shade Of Mine]

audacia schrieb:

(Praktischer Beweis: Delphi 2009. Das unterstützt Generics, die zur Übersetzungszeit instantiiert werden - sie sind demnach ebenso effizient wie Templates -, doch werden sie dennoch wie gewöhnliche Klassen geparst - was das Problem der nutzlosen Fehlermeldungen, das man in C++ durch Concepts angehen will, vermeidet.)

Ist in C++ nur wegen der fehlenden standardisierten ABI nicht möglich.

Deshalb tut man precompiled header verwenden um den kompilierungsaufwand zu reduzieren.

Aber ich kenne die Templates in Delphi nicht - habe nur sehr gemischtes darüber gehört. Kannst du deren funktionalität mal näher erklären?

[audacia]

Vorweg: Kompiliert wird eine generische Klasse erst, wenn sie mit einem konkreten Typen instantiiert wird. Geparst hingegen wird sie schon untypisiert. In den Moduldateien (bei Delphi sind das *.dcu-Dateien) wird dann der Parse-Tree abgelegt, in den bei der Instantiierung nur noch die tatsächlichen Typen injiziert werden müssen.

Nexus schrieb:

Wie kann die volle Typsicherheit in untypisiertem Zustand bewahrt werden?

Durch Typrestriktionen. Bei der Deklaration der generischen Klasse muß der Typ so beschränkt werden, daß zu dessen Übersetzungszeit bekannt ist, welche Operationen dieser Typ beherrscht. Dafür kannst du dann nicht mehr irgendwelche Methoden des Arguments aufrufen, die nicht durch die Typrestriktion explizit bekannt gemacht wurden:

template <class T>
    bool isEqual (T lhs, T rhs)
{ return lhs == rhs; } // geht nicht mit Generics

Wenn du aber eine entsprechende Typrestriktion angibst, kannst du so etwas auch mit Generics machen. Bei den Generics in .NET sähe das etwa so aus (Syntax ist Delphi für .NET, da ich nicht flüssig in C# bin):

type
  CompareHelper <T: IEquatable <T>> = class
  public
    class function IsEqual (lhs, rhs: T): Boolean;
  end;

class function CompareHelper <T>.IsEqual (lhs, rhs: T): Boolean;
begin
  Result := lhs.Equals (rhs);
end;

Das funktioniert dann auch für skalare Typen, da diese in .NET die nötigen Interfaces unterstützen. (Concept Maps gehen übrigens in eine sehr ähnliche Richtung.)

Da Delphi für Win32 kein "rooted type system" hat, ist das dort nicht so einfach. Gegenwärtig muß man sich mit dem Übergeben eines Comparers etc. behelfen. (Allerdings ist es den Äußerungen der Zuständigen in den CodeGear-Newsgroups zufolge recht wahrscheinlich, daß sich das in den kommenden Versionen noch ändert.)

Shade Of Mine schrieb:

Aber ich kenne die Templates in Delphi nicht - habe nur sehr gemischtes darüber gehört. Kannst du deren funktionalität mal näher erklären?

http://sjrd.developpez.com/delphi/tutoriel/generics/

Shade Of Mine schrieb:

Ist in C++ nur wegen der fehlenden standardisierten ABI nicht möglich.

Wie kommst du denn darauf? Was hat das ABI damit zu tun, daß Templates nicht untypisiert geparst werden können, weil sie nur ein flexibel konfigurierbarer Präprozessormechanismus sind?

Shade Of Mine schrieb:

Deshalb tut man precompiled header verwenden um den kompilierungsaufwand zu reduzieren.

Sagte ich ja bereits. Aber damit ist C++, ohne daß es am Zeilendurchsatz des Compilers läge (s.o.), immer noch deutlich langwieriger zu übersetzen als Sprachen mit einem vernünftigen Modulkonzept, und die Fehlermeldungen sind auch nicht besser.

[Nexus]

Shade Of Mine schrieb:

Um ehrlich zu sein: meistens ist mir das total egal.

Ob nun ein Iterator volle Zugriffsrechte auf die Elemente hat oder nicht? Wie wird das eigentlich gehandhabt, treten da keine Mehrdeutigkeiten auf?

Shade Of Mine schrieb:

Warum ist es wichtig ob pos ein Vector<3, int> oder ein Vector<7, float> ist?

Naja, es macht schliesslich schon einen Unterschied, ob man mit einem sieben- oder dreidimensionalen Vektor arbeitet. Es ist einfach so, dass man gerade bei diesem Beispiel wissen muss, welcher Typ dahinter steckt, da man ihn anwendet. Und mit auto muss ich zuerst die Memberfunktion GetPosition() suchen und erst ihren Rückgabetypen anschauen, während ich ansonsten gleich bei der Deklaration den Typen sehe.

Shade Of Mine schrieb:

Und warum ist es wichtig welchen unsigned typen size hat? es ist groß genug die größe von Blabla zu beinhalten.

Stimmt, das war ein schlechtes Beispiel. Ist aber gerade gut, so wird das leidige Problem der Grössentypen eingeschränkt.

Shade Of Mine schrieb:

Und wo ist das schlecht? Intellisense ist super weil ich mir nix merken muss und auto erspart mir wieder sinnlose information zu tippen.

Ob es gut ist, sich nichts zu merken, kann man wiederum diskutieren. Praktisch ist es während des Programmierens, keine Frage. Aber je mehr man sich auf IntelliSense verlässt, desto abhängiger wird man auch. Mit der Zeit überlegt man sich weniger und schlägt mehr nach.

Shade Of Mine schrieb:

Überall wo du mit templates zu tun hast wird der code soviel klarer durch auto.

Ja, das glaube ich gern. Es gab doch auch mal ein Beispiel für Boost.Lambda, wo ein einfacher Ausdruck bereits einen mehrzeiligen verschachtelten Templatetypen hat.

Ich bin inzwischen schon recht überzeugt, dass auto praktisch sein kann, gerade das Size-Beispiel hat mir einen weiteren Vorteil gezeigt. Aber dennoch kann ich die Aussage, dass einen den Typen einer Variable nicht zu interessieren hätte, so nicht unterstützen. Es gibt für mich einfach so viele Fälle, in denen ich froh darüber bin, bei der Deklaration gleich noch den Typen zu sehen. In den Iterationsschleifen weiss ich ja, dass ich einen Iterator habe, da kann ich mir die genaue Deklarationssyntax sparen. Aber bei lokalen Variablen, besonders in kurzen Funktionen, habe ich einfach einen viel schnelleren Überblick.

Aber das ist natürlich auch ein wenig Geschmackssache, wie gesagt helfen mir persönlich Typangaben an vielen Orten.

[Simon2]

audacia schrieb:

...Kompiliert wird eine generische Klasse erst, wenn sie mit einem konkreten Typen instantiiert wird. Geparst hingegen wird sie schon untypisiert. In den Moduldateien (bei Delphi sind das *.dcu-Dateien) wird dann der Parse-Tree abgelegt, in den bei der Instantiierung nur noch die tatsächlichen Typen injiziert werden müssen....Typrestriktionen...

Danke für die Info.

Jetzt bin ich schlauer.

Gruß,

Simon2.

[asc]

audacia schrieb:

Vorweg: Kompiliert wird eine generische Klasse erst, wenn sie mit einem konkreten Typen instantiiert wird. Geparst hingegen wird sie schon untypisiert. In den Moduldateien (bei Delphi sind das *.dcu-Dateien) wird dann der Parse-Tree abgelegt, in den bei der Instantiierung nur noch die tatsächlichen Typen injiziert werden müssen.

Wobei man auch sagen muss das beide Generics auf der einen, Templates auf der anderen Seite unterschiedliche Vorteile haben.

Generics sind sowohl in .Net als auch in Java (ich weiß nicht wie es im klassischen Delphi ist) in anderen Belangen wiederum eingeschränkter als C++ Templates (z.B. fehlen die Mechanismen der Templatemetaprogrammierung). Die Vorteile sollte man alleine an deinem Abschnitt ablesen können.

cu André

[audacia]

asc schrieb:

Wobei man auch sagen muss das beide Generics auf der einen, Templates auf der anderen Seite unterschiedliche Vorteile haben.

Ich glaube fast, das erwähnt zu haben

Ich spreche mich ja auch nicht gegen Templates aus. Aber für Dinge wie Container sind Generics schlicht besser geeignet.

[asc]

audacia schrieb:

Ich spreche mich ja auch nicht gegen Templates aus. Aber für Dinge wie Container sind Generics schlicht besser geeignet.

Und ich bin der Meinung wenn man alles was grundsätzlich positiv wäre noch zusätzlich in den C++ Standard einbaut kann man gleich eine Diplomarbeit für die Verwendung der Sprache verlangen. In sofern hätte ich aber auch nichts gegen eine neue Sprachversion (wegschmeißen von Altlasten, von mir aus kann man innerhalb eines speziellen Codetags dann explizit für alte Projekte die Sprache auf das bisherige C++ umschalten).