spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Lustig wie keiner auf meinen Post reagiert.

MfG
Check

Also ich weiß nicht ob ich mich da richtig erinnere, hab C(++) nur neulich mal für einen 4kb Demo Versuch benutzt und in den letzten Jahren sonst auch kaum angerührt (davor habe ich meine ganzen Hobbyprojekte in C++ oder Delphi gemacht):
Mich irritiert es sehr wenn durch Operatoren andere Objekte zurückgegeben werden etc. Bei einer expliziten Funktion bin ich von Anfang an darauf gefasst.

vec3 *= pow(vec1 * vec2 * float1, vec4 * vec3);

vec3.scale(Math.pow(vec1.dot(vec2) * float4, vec4.dot(vec3)));

Letzteres kann ich besser lesen. Aber vielleicht ist das auch nur Gewöhnungssache.

Zitat von »Checkmateing«

Lustig wie keiner auf meinen Post reagiert.

MfG
Check

Solche beschwichtigenden Worte sind hier offtopic Nein natürlich hast du recht. Aber ich finde es immer wieder sehr interessant, dass die Aggression gegenüber anderen Sprachen tendenziell von den Personen ausgeht, die eine Sprache vertreten die etwas Performance orientierter ist und mehr lowlevel Zugriff ermöglicht.

rüp hat auf ZFX im "Ich hasse Java"-Thema mal diese humoristische Grafik gepostet, die die ganzen Sprachkriege ein wenig auf die Schippe nimmt:

Also ich durfte/musste jetzt im ersten Semester meines Studiums Java lernen und fand C++ doch sympathischer. Finde es aber auch nicht verwunderlich. Kann man schließlich C++, dann sind die für Anfänger vllt. nützlichen Einschränkungen eher Hindernis als Nutzen.
Klar ist Java grundsätzlich relativ leicht zu programmieren und gerade Arrays sind doch deutlich schöner zu verwenden als in C++(komfortables Erstellen von Arrays auch bei nicht zur Kompilierungszeit bekannten Längen und einfache Überprüfung der Länge von Arrays etc.).
Allerdings gab es doch etliche Punkte, die hier ja auch schon häufig genannt wurden, die mich oft gestört haben:

Operatorenüberladung: Operatoren dürfen nicht überladen werden, weil der Code unleserlich würde und man nicht unbedingt intuitiv versteht, was ein Operator tun könnte. Wozu bin ich denn Programmierer? Wenn ich unleserlichen Code schreiben und warten will, dann soll man micht doch lassen. Vor allen finde ich das Argument ziemlich lächerlich. Denn jeder der schon mal mehrere Operationen(+ - * /) mit bspw. BigInteger durchgeführt hat, weiß, dass der Code alles andere als gut lesbar ist, weil sämtliche Funktionen ineinander verschachhtelt werden und es sieht dann einfach schrecklich aus. Und wer garantiert mir denn, dass Funktionen genau das tun, was ihr Name vermuten lässt? Auch niemand, also verstehe ich einfach nicht, warum man Operatoren nicht überladen sollen dürfte.

Mehrfachvererbung: Mehrfachvererbung ist verboten! Achso naja gut so ganz stimmt das ja doch nicht. Denn manchmal wäre Mehrfachvererbung auch ganz sinnvoll. Darum gibt es Interfaces. Interfaces darf man mehrere implementieren. Oberklassen darf es nur eine geben. Dieses Konzept ist für mich auch nicht unbedingt schlüssig gewählt. Das hat nämlich ggf. zur Folge, dass man in Interfaces abstrakte Getter und Setter-Methode implementiert, deren Variablen, die gesetzt werden sollen, erst von den eigentlichen Klassen enthalten sind(schließlich dürfen in Interfaces keine dynamischen Instanzvariablen enthalten sein). Schönes Klassendesign sieht dann auch jeden Fall anders aus.

Referenzsemantik: Vor kurzem laß ich den schönen Satz: "Pointers are evil, we call them references." Trifft finde ich schon ziemlich genau das, was es letztlich ist. Zwar sind Referenzen sehr schön, allerdings muss man bedenken, dass diese Referenzen alle irgendwann vom Garbage-Controller aufgesammelt werden müssen. Und wann der Garbage-Controller sie einsammelt ist ungewiss. Das Problem ist, dass der Garbage-Controller alles andere als schnell ist und gerade in der Spieleentwicklung ist es alles andere als wünschenswert, wenn mitten im Spiel, dieses plötzlich einfriert, weil der Garbage-Collector die Referenzleichen aufräumt. In C++ entscheide ich eben selbst, wann die Variablen gelöscht werden. In C++ hört man dennoch oft, man solle das Schlüsselwort "new" möglichst selten verwenden, da man Pointer, die man erstellt auch wieder aufräumen muss und manchmal dann unklar ist, wo nun der Pointer egtl. gelöscht werden soll bzw. welche Klasse dafür zuständig ist. In Java gilt letztlich aber genau das gleiche, da man eben aufpassen muss, dass man nicht unbedacht Referenzen erstellt, die dann irgendwann vllt. vom Garbage-Controller aufgeräumt werden müssen.
Gleichzeitig hat man in C++ aber die Möglichkeit bei der Variablenerstellung klar anzugeben, ob die Variable eine Referenz auf eine andere sein soll oder eine Kopie angelegt werden soll, was doch sehr viel Komfort bringt. Ich glaube zwar, dass gerade Anfänger deutlich öfter Kopien nutzen als notwendig, aber in Java finde ich es einfach extrem schwierig, wenn man nicht ohne weiteres eine Variable als Kopie anlegen kann. Statt dessen muss die Variable, die kopiert werden soll explizite Funktionen aufrufen, damit sie kopiert wird(ggf. ist noch ein expliziter Cast notwendig) und es ist deutlich unübersichtlicher eine Kopie auszumachen. Stattdessen gibt es für die internen Datentypen eben einfach noch jeweils Klassen, welche dann Referenzsemantik bieten, während die normalen Datentypen Kopien sind.

Ein weiterer Knackpunkt sind noch Generics, die gegenüber Templates doch klar den kürzen ziehen. Was ich allerdings ebenfalls sehr interessant finde ist, dass es schlichtweg keine Möglichkeit gibt bspw. generische Arrays anzulegen. Das kann dann zu Compiler-Warnungen führen. Lösungen dafür gibt es keine außer die Warnung eben zu unterdrücken. Dabei passiert im Code egtl. nie etwas schlimmes und es ist zu jeder Zeit gewährleistet, dass es funktioniert, aber dennoch gibt es eben Warnungen, die man nicht beheben kann. Nicht unbedingt ein Zeichen für gutes Sprachdesign.

Zitat von »Chromanoid«

Also ich weiß nicht ob ich mich da richtig erinnere, hab C(++) nur neulich mal für einen 4kb Demo Versuch benutzt und in den letzten Jahren sonst auch kaum angerührt:
Mich irritiert es sehr wenn durch Operatoren andere Objekte zurückgegeben werden etc. Bei einer expliziten Funktion bin ich von Anfang an darauf gefasst.

vec3 *= pow(vec1 * vec2 * float1, vec4 * vec3);

vec3.scale(Math.pow(vec1.dot(vec2) * float4, vec4.dot(vec3)));

Letzteres kann ich besser lesen. Aber vielleicht ist das auch nur Gewöhnungssache.

Das würde bei mir so aussehen:

Das Skalarprodukt als * zu überladen, wäre imo ein ziemlich unglücklicher Einsatz von Operator Overloading

Zitat von »Chromanoid«

Aber ich finde es immer wieder sehr interessant, dass die Aggression gegenüber anderen Sprachen sehr häufig von den Personen ausgeht, die eine Sprache vertreten die etwas Performance orientierter ist und mehr lowlevel Zugriff ermöglicht.

Also was mich betrifft, kann man ganz ehrlich nicht von Aggression reden. Ich hab nur manchmal Spaß an solchen Diskussionen
Was die Grafik betrifft: Ich würde mal meinen, das sollte eher ein vollständiger Graph sein

Zitat von »Fred«

Mehrfachvererbung: Mehrfachvererbung ist verboten! Achso naja gut so ganz stimmt das ja doch nicht. Denn manchmal wäre Mehrfachvererbung auch ganz sinnvoll. Darum gibt es Interfaces. Interfaces darf man mehrere implementieren. Oberklassen darf es nur eine geben. Dieses Konzept ist für mich auch nicht unbedingt schlüssig gewählt. Das hat nämlich ggf. zur Folge, dass man in Interfaces abstrakte Getter und Setter-Methode implementiert, deren Variablen, die gesetzt werden sollen, erst von den eigentlichen Klassen enthalten sind(schließlich dürfen in Interfaces keine dynamischen Instanzvariablen enthalten sein). Schönes Klassendesign sieht dann auch jeden Fall anders aus.

Die fehlende Mehrfachvererbung ist imo gar kein Problem, im Gegenteil. Auch wenn Mehrfachvererbung in C++ extrem mächtig ist, so sind die resultierenden Konstrukte doch auch wirklich, wirklich komplex. Ich würde für Sprachen wie Java oder C# keinen wirklichen Mehrwert durch Mehrfachvererbung sehen. Vererbung würde ich generell nur sehr sparsam einsetzen, Interfaces sind das, was man in einem schönen Design meist eigentlich haben will. Getter und Setter will man dann sowieso vermeiden.

@Mehrfachvererbung: Imo kann man damit sehr viel Scheiße bauen - ich zumindest bin damit damals als fortgeschrittener Anfänger schon richtig aufs Maul geflogen. Mehrere Interfaces sind keine Mehrfachvererbung.
@Operatorenüberladung: Wie man in meinem Beispiel gesehen hat, kann man damit auch viel Scheiße bauen.
@Referenzsemantik: Ich finde sichere Referenzen, GC & Co. besser als irgendwelche Memory Leaks zu suchen, weil ein Kollege Scheiße mit Pointern gebaut hat.

C++ bietet so viel Möglichkeiten Scheiße zu bauen, dass vernünftige großangelegte Projeke IMO nur möglich sind, wenn man die Sprache extrem beschneidet und einen strengen Coding Standard durchsetzt. Wie macht ihr das eigentlich in C++, wenn ihr eine Open Source Bibliothek einbindet? Ich überfliege in Java oder C# immer gerne mal den Quellcode. Dank ausgezeichneter IDE Unterstützung (die durch eine gewisse Simplizität der Sprachen schon lange gewährleistet werden kann) ist das sehr schnell möglich. Wie viele Bibliotheken verwendet ihr so durchschnittlich für eure Projekte?

Das soll es glaube ich auch nicht.

Mit Gewalt bekommt man alles kaputt. Nur weil man viel Scheiße bauen kann, heißt das noch lange nicht, dass ein Sprachmittel unbrauchbar ist. Ich kann mit praktisch jedem Sprachmittel in so ziemlich jeder Sprache Scheiße bauen, wenn ich will. Ich denke, bei Operator Overloading überwiegen die Vorteile ganz klar. Dass man es immer auch übertreiben kann, ist auch klar, aber nicht Problem der Sprache, wenn du mich fragst. Mehrfachvererbung würde für Java oder C# vermutlich eher nichts bringen.