Laden...

Postfix oder Prefix Schreibweise um eine Variable zu inkrementieren?

Erstellt von esskar vor 13 Jahren Letzter Beitrag vor 13 Jahren 9.576 Views
Hinweis von winSharp93 vor 13 Jahren

Abgetrennt von IEnumerator<T>-Interface implementieren: Rückgabetyp von Current

esskar Themenstarter:in
203 Beiträge seit 2006
vor 13 Jahren
Postfix oder Prefix Schreibweise um eine Variable zu inkrementieren?

this._current = this._internalDictionary[this._index];
this._index++;

solltest du entweder als

this._current = this._internalDictionary[this._index++];

oder


this._current = this._internalDictionary[this._index];
++this._index;

schreiben!

5.941 Beiträge seit 2005
vor 13 Jahren

Hallo esskar

Da kann ich dir leider nicht zustimmen.
Die erste - originale - Variante ist m.E. am lesbarsten. Die zweite ist korrekt, aber weniger lesbar.
Die dritte ist auch korrekt, allerdings ist "this._index" in diesem Fall unnütz, sodass du gleich "this._index" schreiben kannst.

Gruss Peter

--
Microsoft MVP - Visual Developer ASP / ASP.NET, Switzerland 2007 - 2011

49.485 Beiträge seit 2005
vor 13 Jahren

Hallo Peter Bucher,

es ist zwar richtig, dass man in

this._current = this._internalDictionary[this._index++];

das ++ leicht übersehen kann, aber für genau solche Fälle ist der Postfix-Inkrementoperator gemacht, inbesondere wenn man die rechte Seite der Zuweisung als Returnwert verwendet, weil man sich dann durch den Postfix-Inkrementoperator eine Zwischenvariable spart.

An allen anderen Stellen, also inbesondere wenn ein Inkrement die einzige Operation innerhalb einer Anweisung ist, wie das bei der Zeile

++this._index;

sollte man den Prefix-Inkrementoperator verwenden. Das gilt auch in dem Reinitialisierungsteil einer for-Schleife. An solchen Stellen ist nämlich this._index++ unnütz um nicht zu sagen Unsinn.

Mir ist auch nicht wirklich klar, wie du darauf kommst, dass der Prefix-Op hier schlechter zu lesen ist? Weil er vor dem this (das man sich sparen kann und sparen sollte) steht? Dann ist das aber eine Frage des überflüssigen this und kein Grund den Postfix-Op zu bevorzugen.

Es gibt - außer in den eingangs beschriebenen Fällen - überhaupt keinen Grund, den Postfix-Inkrementoperator zu verwenden. Im Gegenteil! So gut wie alle anderen Operationen und Operatoren in C# sind Präfix (oder Infix), aber so gut wie nie Postfix. Wenn man eine Increment-Methode verwenden würde, würde die auch vor dem Operanden stehen. Auch in der natürlichen Sprache sagt man "inkrementiere den Index" und nicht "Index inkrementiere". Weil auf so gut wie jeder Zeile im Code Prefix-Operationen und -Operatoren verwendet werden, sollte man schon wegen der Einheitlichkeit wo immer möglich, die Prefix-Variante verwenden. Postfix-Operationen sind schon wegen ihrer Seltenheit schlechter lesbar, weil das einfach ungewohnter ist.

Und um nochmal auf this zurückzukommen: Wenn man schreibt Increment (this._index) würde ja auch keiner auf die Idee kommen, dass damit this inkrementiert werden soll. Keiner würde auf die Idee kommen, dass bei -this._index der negative Wert von this gebildet werden soll. Warum sollte man bei ++this._index also denken, dass this inkrementiert werden soll?

Habe ich dich überzeugt? Wenn nicht, schreib dich bitte mal, wie du zu deiner - in meinen Augen unhaltbaren - Aussage kommst. Dass in C++ das ++ hinter dem C steht, kann ja kein Argument sein. 😃

herbivore

5.742 Beiträge seit 2007
vor 13 Jahren

Ich schließe mich mal Peter Bucher an.

Es gibt - außer in den eingangs beschriebenen Fällen - überhaupt keinen Grund, den Postfix-Inkrementoperator zu verwenden. Im Gegenteil!

Umgekehrt kann man aber genauso argumentieren: Es gibt keinen Grund, den Prefixinkrementoperator zu verwenden 😉

Wenn man eine Increment-Methode verwenden würde, würde die auch vor dem Operanden stehen.

Naja - aber ich würde hier eher von einer Zuwesiung als von einem Methodenaufruf sprechen:


i = i + 1;
//Wird verkürzt zu:
i += 1;
//wird verkürzt zu:
i++;

Da ist es IMHO nur sinnvoll, dass das Plus auch weiterhin nach dem Variablenname steht.
Bei "++i" hingegen wandert das "+" vor die Variable.

An solchen Stellen ist nämlich this._index++ unnütz um nicht zu sagen Unsinn.

Wegen der zusätzlichen Variablen, die alte C Compiler früher evtl. angelegt haben, um den Wort vor der Inkrementierung zu speichern?

Auch in der natürlichen Sprache sagt man "inkrementiere den Index" und nicht "Index inkrementiere".

Auch das hinkt ein wenig: "Der Index wird inkrementiert" 🙂

wie du zu deiner - in meinen Augen unhaltbaren - Aussage kommst

Ich würde hier also überhaupt nicht von einer "unhaltbaren Aussage" sprechen, sondern vielmehr von einer Glaubensfrage.

49.485 Beiträge seit 2005
vor 13 Jahren

Hallo winSharp93,

Umgekehrt kann man aber genauso argumentieren: Es gibt keinen Grund, den Prefixinkrementoperator zu verwenden

nö, kann man nicht, zumindest nicht nachdem ich schon x Gründe genannt hatte, die dafür sprechen.

Wegen der zusätzlichen Variablen, die alte C Compiler früher evtl. angelegt haben, um den Wort vor der Inkrementierung zu speichern?

Nein, weil es dann keine Verwendung des Wertes vor dem Inkrementieren gibt. Also genau das, wofür den den Postfix-Inkrementoperator gibt, genau das, was das besondere und ungewöhnliche an ihm ist, an der Stelle gar nicht benötigt wird.

Auch das hinkt ein wenig: "Der Index wird inkrementiert"

Nein, es hinkt nicht, denn es geht ja hier um Anweisungen. Und die stehen - mindestens ganz überwiegend - in der Befehlsform. Und damit steht sprachlich die Operation (immer) vor dem Operanden.

Ich würde hier also überhaupt nicht von einer "unhaltbaren Aussage" sprechen, sondern vielmehr von einer Glaubensfrage.

Also ich finde die Situation schon ziemlich eindeutig.

Mein Problem ist nicht so sehr, wenn ich eine unsinnige Verwendung von i++ in fremden Code sehe. Das stört mich relativ wenig. Ich denke dann nur, ok, derjenige hat es halt nicht besser gewusst. 😃 Mein Problem war, dass Peter es ohne Angaben von Gründen so dargestellt hat, als käme nur das eine - das in meinen Augen falsche - als einzig richtige Lösung in Betracht.

herbivore

1.552 Beiträge seit 2010
vor 13 Jahren

Hallo Leute,

@herbivore:
was spricht für dich dagegen die for schleife als
for(int i = 0; i < 10; ++i)
Anstelle von
for(int i = 0; i < 10; i++)
zu schreiben.

Und die stehen - mindestens ganz überwiegend - in der Befehlsform. Und damit steht sprachlich die Operation (immer) vor dem Operanden.

Eigentlich nur wegen der sprachlichen Grammatik?

Gruß
Michael

Mein Blog
Meine WPF-Druckbibliothek: auf Wordpress, myCSharp

49.485 Beiträge seit 2005
vor 13 Jahren

Hallo xxMUROxx,

was spricht für dich dagegen die for schleife als
for(int i = 0; i < 10; ++i)
Anstelle von
for(int i = 0; i < 10; i++)
zu schreiben.

offensichtlich hattest du mich falsch verstanden.

Ich bin dafür, in der Schleife ++i zu schreiben. Ich halte es für unsinnig, in der Schleife i++ zu verwenden, weil da die Postfix-Semantik des Operators überhaupt nicht zum Tragen kommt.

Überhaupt sollte man an allen Stellen den Prefix-Inkrementoperator verwenden, außer man benötigt, das, was den Postfix-Inkrementoperator besonders macht: Die Verwendung des Wertes vor dem Inkrementieren. Nur in diesem besonderen (und seltenen Fall) ist die Verwendung des Postfix-Inkrementoperator angebracht.

Ich habe ja eine ganze Reihe von Gründen angeführt. Die Grammatik ist nur einer davon.

herbivore

5.742 Beiträge seit 2007
vor 13 Jahren

Also ich finde die Situation schon ziemlich eindeutig

Ich nicht.
Ein wirklich überzeugendes Argument hast du IMHO noch nicht gennannt.
Und dass es keine Gründe für die Verwendung des Postfixoperators gibt, spricht noch lange nicht für den Prefixoperator.

Postfix-Operationen sind schon wegen ihrer Seltenheit schlechter lesbar, weil das einfach ungewohnter ist.

Also bei mir stehen die in jeder for-Schleife; so selten sind sie daher (zumindest bei mir) nicht.
Und ja, auch dass das "++" hinter dem C steht spricht für die weite Verbreitung der Postfixschreibweise 😁

Und in einer for-Schleife:


for (int i = 0; i < count; i++)
//bzw. 
for (int i = 0; i < count; ++i)

braucht man eigentlich den Wert nach dem zweiten Semikolon (irgendeinen Namen gab's da doch...) in keinem Fall. Also weder den Wert vor dem Inkrementieren, noch den danach.

so dargestellt hat, als käme nur das eine - das in meinen Augen falsche - als einzig richtige Lösung in Betracht.

Im Moment trifft das aus meiner Perspektive aber auch auf deine Antwort zu 😉

Ich bin weiterhin davon überzeugt, dass das reine Ansichtssache ist (und evtl. durch Codingguidelines fetzulegen ist).
Fast so, wie die Frage, wo man denn nun die spitzen Klammern setzt 😉

49.485 Beiträge seit 2005
vor 13 Jahren

Hallo winSharp93,

Und dass es keine Gründe für die Verwendung des Postfixoperators gibt, spricht noch lange nicht für den Prefixoperator.

wenn es Gründe gibt, an den meisten Stellen den Prefix-Inkrementoperator zu verwenden, dann heißt das doch - weil man sich ja für eine Möglichkeit entscheiden muss - automatisch, dass man an den meisten Stellen den Postfix-Inkrementoperator nicht verwenden sollte.

Und ja, auch dass das "++" hinter dem C steht spricht für die weite Verbreitung der Postfixschreibweise

Das ist höchsten die Ursache dafür, aber es spricht nicht für die Verwendung.

Im Moment trifft das aus meiner Perspektive aber auch auf deine Antwort zu

Du hast mich unfair zitiert. Ich hatte geschrieben:

Mein Problem war, dass Peter es ohne Angaben von Gründen so dargestellt hat, als käme nur das eine - das in meinen Augen falsche - als einzig richtige Lösung in Betracht.

Und Gründe habe ich ja nun mehr als genug angegeben.

herbivore

49.485 Beiträge seit 2005
vor 13 Jahren

Hallo winSharp93,

eins deiner Argumente hatte ich übersprungen:

  
i = i + 1;  
//Wird verkürzt zu:  
i += 1;  
//wird verkürzt zu:  
i++;  
  

Da ist es IMHO nur sinnvoll, dass das Plus auch weiterhin nach dem Variablenname steht.

Wenn du schon die Analogie zu i = i + 1 ansprichst. Das ist doch noch ein Argument für ++i, denn was ist die exakte Analogie zu i = i + 1? Richtig, ++i und eben nicht i++. Denn wenn man i = i + 1 in dem Ausdruck x = (i = i + 1) ersetzen will, so dass x den gleichen Wert bekommt wie vorher, was muss man einsetzen? Richtig ++i. 😃

herbivore

771 Beiträge seit 2009
vor 13 Jahren

Hallo zusammen,

immer diese Glaubenskriege 8o

Ich persönlich verwende auch fast immer (als alleinige Anweisung!) den Postfix-Operator i++ (auch wenn wie schon gesagt wurde, in C bzw. C++ der Prefix-Operator ++i - gerade bei Iteratoren - bevorzugt werden sollte - wobei heutige Compiler dies schon entsprechend optimieren).

6.862 Beiträge seit 2003
vor 13 Jahren

Hallo zusammen,

Herbivore, deine Argumente sind schön und gut, aber du kämpfst hier gegen Windmühlen. Die Begründung mit der Grammatik zählt nicht weil es abermillionen Menschen auf der Welt gibt deren Sprachen auch Postfix Konstrukte kennen. Auf die trifft die Prefix Denkweise nicht zu. Und selbst wenn man mit Englisch als bestimmende Sprache hernimmt, gibt es immer noch die zigmillionen Codeschnipsel die man im Internet findet in denen (außer natürlich in Fällen wo das Prefix Inkrement benötigt wird), fast immer der Postfix Operator benutzt wird. Auch wenn es bei dir nicht der Fall ist, wenn es egal ist ob der Post- oder Prefixinkrement benutzt werden kann, wird in den allermeisten Fällen die Postfix Variante verwendet. Absolut gesehen ist das Postfix Inkrement viel viel häufiger anzutreffen als das Prefix Inkrement. Nicht unbedingt aus technischen Gründen, da magst du mit deiner Argumentation das der Prefixinkrement sionnvoller wäre, recht haben.

Baka wa shinanakya naoranai.

Mein XING Profil.

3.430 Beiträge seit 2007
vor 13 Jahren

Hallo zusammen,

das mit dem Pre / Postfix ist meiner Meinung auch eher eine Gewohnheitssache.
Ich verwende meistens die Postfix (sofern es keine Prefix sein muss) Schreibweise deshalb findet man es schöner und leserlicher. Aber das ist nur so weil man es so gewohnt ist.

Wir lesen den Text auch von links nach rechts.
Aber wenn man es von rechts nach links gewohnt wäre dann ist das einfacher 😃

Herbivore hat schon einige Argumente aufgezeigt wieso es logischer ist den Prefix Operator zu wählen.
Da muss ich dir auch zustimmen dass diese Aussagen wirklich ihre Logik haben, aber so drastisch, dass das eine falsch und das andere richtig ist sehe ich das nicht.

IMHO sind beide Versionen richtig wobei der Prefix ein kleines bisschen logischer ist.
Aber die Meisten Programmierer verwenden wohl eher Postfix weshalb sie diese Schreibweise auch leserlicher finden.

Gruss
Michael

U
1.578 Beiträge seit 2009
vor 13 Jahren

Aber man sagt doch auch

"inkrementiere i" => Increment(i); => ++i; 😁

ich glaube kaum das man i++ vermeiden muss, mir persönlich gefällt der pre-inkrement einfach besser. immer wenn ich i++ sehe zuckts in den fingern.
Heißt es nicht auch das man Rückgabewerte von Methoden immer beachten sollte?

Den post verwende ich tatsächlich nur wenn ich den Rückgabewert benötige bevor ich inkrementiere, dafür isser ja da, ich verwende doch nichts was ich nicht benötige.

3.170 Beiträge seit 2006
vor 13 Jahren

Hallo,

Wenn du schon die Analogie zu i = i + 1 ansprichst. Das ist doch noch ein Argument für ++i, denn was ist die exakte Analogie zu i = i + 1? Richtig, i und eben nicht i. Denn wenn man i = i + 1 in dem Ausdruck x = (i = i + 1) ersetzen will, so dass x den gleichen Wert bekommt wie vorher, was muss man einsetzen? Richtig ++i. 😃 Dieses Beispiel finde ich sehr überzeugend, und stimme herbivore von der Theorie her hundertprozentig zu.
Allerdings halte ich mich selbst eher selten daran, Grund ist wohl das, was sich in der Aussage von talla findet.

Gruß, MarsStein

Non quia difficilia sunt, non audemus, sed quia non audemus, difficilia sunt! - Seneca

5.941 Beiträge seit 2005
vor 13 Jahren

Salute zusammen

Oh, so ein Glaubenskrieg wollte ich nicht auslösen, ich dachte nicht dass es so eine Zweiteilung gibt.
Herbivore hat mir angekreidet, das ich zuwenig argumentiert habe.

Also, eigentlich ganz einfach:
Ich finde den Postfix-Operator lesbarer, Gründe wurden auch schon genannt, wie bspw. der natürliche Lesefluss.
Der wichtigste Grund ist für mich aber, dass der Postfix-Operator am bekanntesten ist, am häufigsten benutzt wird und in einigen Sprachen der einzig existente ist.

Das heisst: Wenn ich irgendwo den Prefix-Operator benutze, können andere damit Schwierigkeiten bekommen, was für mich auch mit der Grund ist, möglichst überall den Postfix-Operator zu nutzen, denn es geht auch ganz ohne Prefix-Operator.

Der einzige technische Unterschied vom Pre- zum Postfix-Operator ist AFAIK ja, dass der Ausdruck "i" selber dann schon um eins erhöht wird, hingegen bei "i" nicht der Ausdruck selber, sondern die Variable "i" beim nächten Gebrauch inkrementiert ist.
Das mag in manchen Fällen einfacher / simpler zu schreiben sein (Eine statt zwei Zeilen / oder das Ausdrücke nicht auseinander "gerissen" werden müssen, nur um den Postfix-Operator nutzen zu können.

Im Fazit geht bei mir die Lesbarkeit vor. D.h. ich verwende den Prefix-Operator sehr, sehr selten.

@herbivore
Technisch, akademisch kann deine Argumentation verstanden werden und ist auch korrekt. Es scheint das wir unterschiedliche Prioritäten haben.

Gruss Peter

--
Microsoft MVP - Visual Developer ASP / ASP.NET, Switzerland 2007 - 2011

4.207 Beiträge seit 2003
vor 13 Jahren

Hallo,

also ich muss mich da auch Peter anschließen - ich finde die Variante mit Postfix und in zwei Zeilen ebenfalls lesbarer.

Ist die Postfix-Schreibweise verbreiteter als die Präfix-Schreibweise. Postfix sind die meisten Entwickler gewohnt, Präfix nicht. Verwendet man nun Präfix, was ja durchaus einen semantischen Unterschied macht, läuft man Gefahr, dass die Lesbarkeit des Codes leidet. Insofern würde ich Präfix nicht einsetzen.

Und was das ursprüngliche Beispiel angeht: Hier geht es um zwei Aktionen: Auslesen eines Wertes, und dann den Index erhöhen. Wenn das doch zwei Aktionen sind, warum sollte ich die krampfhaft in eine Zeile zusammenziehen? Das trägt IMHO ebenfalls nicht zur Lesbarkeit bei.

Die Argumente für Präfix waren zwar viele, aber sonderlich überzeugend haben sie auf mich auch nicht gewirkt.

Viele Grüße,

Golo

Wissensvermittler und Technologieberater
für .NET, Codequalität und agile Methoden

www.goloroden.de
www.des-eisbaeren-blog.de

49.485 Beiträge seit 2005
vor 13 Jahren

Hallo Peter Bucher,

.. der natürliche Lesefluss

ich hatte ja schon argumentiert, warum ich finde der natürliche Lesefluss gerade für i spricht. Es kann also allenfalls um den üblichen bzw. gewohnten Lesefuss in Bezug auf die In- und Decrementoperatoren gehen. Sprich, weil so viele Leute i verwenden, kommt es uns einfach geläufiger vor.

Die meisten unären Operatoren (+x, -x, !x, ~x, (T)x) in C# sind Postfix, nur ++ und -- gibt es sowohl als Prefix als auch als Postfix. Wenn es um die Natürlichkeit und um die Analogie zu den anderen unären Operatoren geht, müsste man also ++x und --x bevorzugen.

Es ist schon die große Frage, warum x++ so verbreitet ist, obwohl so gut wie alle Analogieüberlegungen für ++x sprechen.

herbivore

5.941 Beiträge seit 2005
vor 13 Jahren

Hoi Golo

Postfix sind die meisten Entwickler gewohnt, Präfix nicht [...]

Ich glaube das ist der Knackpunkt.

Unbewusst nutzt der Entwickler ja sehr viele Prefix-Operatoren, wie bspw. die Negation eines Ausdruckes.
Also könnte man daraus schliessen, das Präfix-Operatoren üblicher, gewohnter und natürlicher sind - was herbivore hier anscheinend meint.

Jedoch ist es an der Stelle einer Inkrementation eben nicht so.
Ich sehe das getrennt an, also alles andere und die Inkrementation. Und die Inkrementation ist als Postfix gebräuchlich und am verbreitesten.

Und das entgegen dem eigentlich viel häufigeren Gebrauch von Präfix-Operatoren im allgemeinen.

Gruss Peter

--
Microsoft MVP - Visual Developer ASP / ASP.NET, Switzerland 2007 - 2011

3.170 Beiträge seit 2006
vor 13 Jahren

Hallo,

Es ist schon die große Frage, warum x++ so verbreitet ist, obwohl so gut wie alle Analogieüberlegungen für ++x sprechen. Die Antwort darauf ein Klassiker mit Killerkraft: Das war schon immer so.

Gruß, MarsStein

Non quia difficilia sunt, non audemus, sed quia non audemus, difficilia sunt! - Seneca

4.207 Beiträge seit 2003
vor 13 Jahren

Es ist schon die große Frage, warum x++ so verbreitet ist, obwohl so gut wie alle Analogieüberlegungen für ++x sprechen.

Weil die Analogieüberlegungen in der Praxis in diesem Fall irrelevant sind. In den meisten Fällen (Schleifen zB oder obigem Beispiel) ist es nämlich egal, welche Variante genutzt wird.

Genauso wie die Frage, wie man es nun an sich macht, letztlich irrelevant ist. Die Codequalität wird dadurch nicht besser oder schlechter. Die Performance ist nicht besser oder schlechter. Per se ist auch nicht die Lesbarkeit besser oder schlechter.

Der Punkt ist einfach: Es hat sich halt so etabliert, vermutlich, weil die meisten Beispiele für Schleifen mit i++ und nicht mit i arbeiten, und weil C nun mal C++ heißt und nicht ++C, und dabei ist es dann einfach geblieben.

Natürlich kann man jetzt lang und breit argumentieren, warum, wieso, weshalb man das doch anders machen sollte - aber mal ganz ehrlich: Wozu?

Genauso gut könnte man darüber diskutieren, ob man bei einer Eigenschaft erst get und dann set oder erst set und dann get implementieren sollte. Das ist genauso egal. Fakt ist aber, es hat sich so eingebürgert, erst get, dann set - warum sollte man es da nun anders machen, auf die Gefahr hin, Missverständnisse drastisch zu erhöhen?

Wissensvermittler und Technologieberater
für .NET, Codequalität und agile Methoden

www.goloroden.de
www.des-eisbaeren-blog.de

5.941 Beiträge seit 2005
vor 13 Jahren

Hallo zusammen

Punkt ist einfach: Es hat sich halt so etabliert, vermutlich, weil die meisten Beispiele für Schleifen mit i++ und nicht mit i arbeiten, und weil C nun mal C++ heißt und nicht ++C, und dabei ist es dann einfach geblieben.

Womit du mein letztes Posting nochmals unterstreichst.

Ich kann somit alle Parteien verstehen und als Fazit ziehen, das eben dieser Knackpunkt mit der Etablierung entscheidend ist, und eine theoretische Analogieüberlegungen in der Praxis irrelevant ist.

Gruss Peter

--
Microsoft MVP - Visual Developer ASP / ASP.NET, Switzerland 2007 - 2011

R
68 Beiträge seit 2010
vor 13 Jahren

Es ist schon die große Frage, warum x++ so verbreitet ist,
obwohl so gut wie alle Analogieüberlegungen für ++x sprechen.

Eventuell auch deswegen, weil in der Qualitätsliteratur (für mich hauptsächlich
Addison Wesley und O'Reilly) alle Beispiele und Sniplets den postfix verwenden
und der präfix meist nur der Vollständigkeithalber erwähnt wird.

In Summe tippe ich auf historische Gründe, da beim for-next in den alten
Hochsprachen das inkrement erst beim next, d.h. im nachhinhein erfolgte.
Auch bei alten, assemblernahen Sprachen wie z.B. Forth stand der operator immer
am Ende, z.B. 25 10 + (UPN).

Ich denke beide Lösungen sind o.k., der Lesbarkeit tut es in Summe keinen
Abbruch, da dass inkrement bei der Analyse fremden Codes das kleinste Problem
hinsichtlich der Lesbarkeit darstellen dürfte.

Robin

5.941 Beiträge seit 2005
vor 13 Jahren

Salute Robin

Ich denke beide Lösungen sind o.k., der Lesbarkeit tut es in Summe keinen
Abbruch, da dass inkrement bei der Analyse fremden Codes das kleinste Problem
hinsichtlich der Lesbarkeit darstellen dürfte.

Nunja, die Summe von kleinen Hindernissen hinsichtlich der Lesbarkeit ergibt dann auch ein grosses Hinderniss.
Und wie das mit den Ausnahmen so ist. Entweder ist man richtig lazy oder richtig strict.

Das ist jetzt zwar ein wenig radikal und aufs Detail geschaut. Muss es meiner Ansicht nach auch sein, da man sonst schnell in die lazy-Richtung geschoben wird.

Gruss Peter

--
Microsoft MVP - Visual Developer ASP / ASP.NET, Switzerland 2007 - 2011

49.485 Beiträge seit 2005
vor 13 Jahren

Hallo Peter Bucher,

eine vollständige Einheitlichkeit der - ich nenne es mal Gestaltung - von Code wird es nie geben. So wie man da mit klarkommen muss, dass manche die öffnende geschweifte Klammern ans Ende der Zeile setzen und andere an den Anfang der folgenden oder manche zuerst set und dann get schreiben statt anderherum, wird man auch damit leben müssen, dass mache - auch in Zukunft - i schreiben und andere i--. Wie schon ziemlich zu Anfang gesagt, stört es mich nicht, wenn jemand i schreibt.

herbivore

4.207 Beiträge seit 2003
vor 13 Jahren

eine vollständige Einheitlichkeit der - ich nenne es mal Gestaltung - von Code wird es nie geben.

Und was genau wolltest Du uns damit jetzt sagen? Wofür oder wogegen ist das ein Argument? Bzw ein Beispiel?

Natürlich ist das nie vollständig gegeben - aber zumindest im Rahmen eines einzelnen Teams oder eines Projekts ist es durchaus erstrebenswert.

Wissensvermittler und Technologieberater
für .NET, Codequalität und agile Methoden

www.goloroden.de
www.des-eisbaeren-blog.de

49.485 Beiträge seit 2005
vor 13 Jahren

Hallo Golo Roden,

aber zumindest im Rahmen eines einzelnen Teams oder eines Projekts ist es durchaus erstrebenswert.

da stimme ich dir vollkommen zu.

herbivore

5.941 Beiträge seit 2005
vor 13 Jahren

Hoi herbivore

eine vollständige Einheitlichkeit der - ich nenne es mal Gestaltung - von Code wird es nie geben. So wie man da mit klarkommen muss, dass manche die öffnende geschweifte Klammern ans Ende der Zeile setzen und andere an den Anfang der folgenden oder manche zuerst set und dann get schreiben statt anderherum, wird man auch damit leben müssen, dass mache - auch in Zukunft - ++i schreiben und andere i--.

Theoretisch kann er das, nur ist das praktisch fast nicht zu 100% umsetzbar. Damit leben muss man nicht, zumindest nicht, wenn man das unter seiner Kontrolle hat.

Privat habe ich als Ziel 100% zu erreichen, im Geschäft auch. Privat werde ich das mit sehr viel Aufwand fast erreichen, im Geschäft nicht.
Aber das ist auch egal, denn 80% sind besser als 0% und 100% sind ein besseres Ziel als pessimistisch hinzugehen und zu sagen: "Du musst damit leben".

Wie schon ziemlich zu Anfang gesagt, stört es mich nicht, wenn jemand i++ schreibt.

Okay, aber inwiefern ist das relavant für die Diskussion?

Gruss Peter

--
Microsoft MVP - Visual Developer ASP / ASP.NET, Switzerland 2007 - 2011

4.207 Beiträge seit 2003
vor 13 Jahren

@ herbivore: Bekomm ich noch ne Antwort auf meine Fragen?

Wissensvermittler und Technologieberater
für .NET, Codequalität und agile Methoden

www.goloroden.de
www.des-eisbaeren-blog.de

49.485 Beiträge seit 2005
vor 13 Jahren

Hallo Peter Bucher,

Damit leben muss man nicht, zumindest nicht, wenn man das unter seiner Kontrolle hat.

in der ganzen Diskussion ging es aber um den Bereich, den man nicht unter Kontrolle hat. Es ging darum, wie andere damit umgehen. Es ging darum, welchen Rat man anderen gibt. Für sich selber oder im Team kann man natürlich Regeln festlegt. Darin habe ich ja Golo schon zugestimmt.

Hallo Golo Roden,

ich hoffe, jetzt ist es klarer, was ich meinte.

herbivore

4.207 Beiträge seit 2003
vor 13 Jahren

Ja, danke für die Aufklärung 😃

Wissensvermittler und Technologieberater
für .NET, Codequalität und agile Methoden

www.goloroden.de
www.des-eisbaeren-blog.de

5.941 Beiträge seit 2005
vor 13 Jahren

Salute herbivore

Okay, das macht es klarer 😃

Gruss Peter

--
Microsoft MVP - Visual Developer ASP / ASP.NET, Switzerland 2007 - 2011

S
469 Beiträge seit 2007
vor 13 Jahren

Ich weiß nicht, wie bei euch die Coderichtlinien aussehen, aber bei uns heißt eine klare Regel, dass der Übersichtlichkeit halber nicht zwei unterschiedliche Aktionen in eine Zeile verbaut werden dürfen (Ausnahme natürlich die Initialisierung von Zählvariablen in Schleifen).
Weder

TuWas(++i); 

noch

TuWas(i++); 

wären somit erlaubt, das Inkrementieren von i müsste vor oder nach dem Funktionsaufruf in einer extra Zeile stehen (idR danach).
Diese Regel finde ich auch ganz sinnvoll, weil man das Inkrementieren dann wirklich schwerer übersehen kann.
Ob i++ oder ++i, ist ziemlich egal, wenn es in einer Zeile als einzige Anweisung steht und sonst nichts weiter. Was man da verwendet, ist wirklich nur noch eine Frage des persönlichen Geschmacks.
Bei Schleifen hängt es meiner Meinung nach auch stark von der Situation ab.
Wenn ich eine Liste mit Hilfe einer FOR-Schleife durchlaufen will, dann schreibe ich

for (int i = 0; i < myList.Count(); i++)
{
}

hier künstlich ein ++i zu erzwingen, indem man mit i=-1 anfängt, das wäre doch unsinnig.
Wenn ich jetzt natürlich eine Schleife 10 mal durchlaufen will und die Zahlen 1 - 10 ausgeben, dann ist natürlich lesbarer, ich lasse die Schleife von 0 bis 10 laufen und inkrementiere mit ++i.

Allgemein:
Je nachdem woher das "i" überhaupt kommt, fände ich im Falle, dass ich es selbst zuvor erstellt hätte, auch befremdlich, wenn ich es mit 0 initialisiert hätte, wenn doch der erste Wert, den es bei der Verwendung haben soll, 1 ist.
Also quasi:

int i = 0;
TuWas(++i);

fände ich seltsam und verwirrend, da ich, wenn ich die Initialisierung von i mit 0 sehe, davon ausgehe, dass dies der erste Wert für i ist, der verwendet wird.

int i = 1;
TuWas(i);

würde ich da eher schreiben!

gruß
sth_Weird

++++++++++++++++++++~+
Fluchen ist die einzige Sprache, die jeder Programmierer perfekt beherrscht


Linux is for free...if your time is worth nothing
++++++++++++++++++++~+

2.891 Beiträge seit 2004
vor 13 Jahren

Wenn ich eine Liste mit Hilfe einer FOR-Schleife durchlaufen will, dann schreibe ich

for (int i = 0; i < myList.Count(); i++)  
{  
}  

hier künstlich ein ++i zu erzwingen, indem man mit i=-1 anfängt, das wäre doch unsinnig

Nein, das ist ein Trugschluss, dass du bei -1 anfangen musst. Sowohl bei i++ als auch bei ++i musst du mit dem gleichen Wert anfangen.

U
1.578 Beiträge seit 2009
vor 13 Jahren

Genau, die Anweisung nach dem zweiten Semikolon wird erst ausgeführt wenn der Anweisungsblock durch ist

for (int i = 0; i < myList.Count(); i++)
{
    TuWas(myList[i]);
}

ist äquivalent zu

int i = 0;
while (i < myList.Count())
{
    TuWas(myList[i]);
    i++;
}
4.207 Beiträge seit 2003
vor 13 Jahren

Hallo sth_Weird!

FULLACK

Das ist das, was ich oben mit

Und was das ursprüngliche Beispiel angeht: Hier geht es um zwei Aktionen: Auslesen eines Wertes, und dann den Index erhöhen. Wenn das doch zwei Aktionen sind, warum sollte ich die krampfhaft in eine Zeile zusammenziehen? Das trägt IMHO ebenfalls nicht zur Lesbarkeit bei.

meinte.

Viele Grüße,

Golo

Wissensvermittler und Technologieberater
für .NET, Codequalität und agile Methoden

www.goloroden.de
www.des-eisbaeren-blog.de

S
469 Beiträge seit 2007
vor 13 Jahren

Nein, das ist ein Trugschluss, dass du bei -1 anfangen musst. Sowohl bei i++ als auch bei ++i musst du mit dem gleichen Wert anfangen.

Asche auf mein Haupt, da hab ich Mist erzählt (hat oben aber schon einer korrigiert).
Hab das Konstrukt mit dem ++i so noch nie verwendet.

++++++++++++++++++++~+
Fluchen ist die einzige Sprache, die jeder Programmierer perfekt beherrscht


Linux is for free...if your time is worth nothing
++++++++++++++++++++~+

656 Beiträge seit 2008
vor 13 Jahren

Kurz und knackig: lesbar bitte. Erst index, dann increment.

Abgesehen davon, lesbar ist in managed Sprachen sowiso besser. Optimiert ja sowiso alles der Compiler:

i++;
++i;
int post = i++;
int pre = ++i;

baut auch schönes x86

inc i; //i++

inc i; //++i

mov eax, i;
mov temp, eax; //temp = i;
inc i; //++i
mov eax, temp;
mov post, eax; //post = temp;

inc i; //++i
mov eax, i;
mov pre, eax; //pre = i;

Drum: überlasst das optimieren dem Compiler, der kanns (meist) besser.
Früher war das in C/C++ noch ein Argument, dass man Prefix bevorzugen sollte, weil damit kein Temp erzeugt wird, aber auch das sollten die meisten Compiler können (bei STL-Iteratoren bin ich mir allerdings nicht sicher).

49.485 Beiträge seit 2005
vor 13 Jahren

Hallo BhaaL,

um Optimierung ging es doch gar nicht. Es ging doch von Anfang an um Lesbarkeit und dann noch um Sinnhaftigkeit. Wenn wir über eine separate Anweisung reden, sind i und i im Ergebnis semantisch gleichbedeutend. Das sieht man ja auch schön an deinem "x86"-Code. Dann muss aber die Frage erlaubt sein, welche von den beiden semantisch gleichbedeutenden Varianten man verwenden sollte. Warum ich finde, dass man, wenn man die Wahl hat, ++i verwenden sollte, habe ich ja nun ausführlich begründet. Auch warum ich sie lesbarer finde.

herbivore

5.941 Beiträge seit 2005
vor 13 Jahren

Hallo zusammen

@herbivore
Als Nebenbemerkung finde ich die Sache mit Priorität auf Lesbarkeit, auch weil der Code sowieso optimiert wird, passend und sinnvoll.

Ich denke somit ist alles gesagt, mehrfach 😃

Gruss Peter

--
Microsoft MVP - Visual Developer ASP / ASP.NET, Switzerland 2007 - 2011

656 Beiträge seit 2008
vor 13 Jahren

um Optimierung ging es doch gar nicht.

Gut, mein Fehler, kam mir aber ein wenig komisch vor, dass alle nur um die "Schönheit" und Lesbarkeit (aus mehreren Sichten) der Operation geschrieben haben. Unterschwellig hatte ich da irgendwie die ein oder andere Diskussion (auf Basis C/C++) im Kopf, wo die eisernen Verfechter der Prefix-Variante immer mit Performance, kein temp usw. argumentiert haben. Und wer die beiden Sprachen kennt, dem muss ich vermutlich nix über Lesbarkeit erzählen.

Dann muss aber die Frage erlaubt sein, welche von den beiden semantisch gleichbedeutenden Varianten man verwenden sollte. Warum ich finde, dass man, wenn man die Wahl hat, ++i verwenden sollte, habe ich ja nun ausführlich begründet. Auch warum ich sie lesbarer finde.

Geschmäcker sind zum Glück verschieden, und was das angeht ist mir die Postfix Variante lieber/gebräuchlicher - weils jeder so verwendet, weil C++ auch C++ heißt, weils eh alle trotzdem lesen können, oder warum auch immer.
Abgesehen davon gehts mir aber ähnlich wie dir - wenn keine bestimmte Intention dahinter ist (wie im Beispiel gezeigt someArray[++idx] oder MyMethod(++i)), ist mir egal ob dort Prefix oder Postfix steht - und sowas mach ich in Produktivcode meist sowiso nicht, maximal in einem Quick&Dirty Prototyp.

Wenn man dann aber so weit geht, und das ganze mit Methodenaufrufen vergleicht, müsste man bei der Prefix-Variante auf ++(i) (eigentlich: ++(ref i)) umsteigen, weil ++ (und auch --) den Wert der Variable selbst ändern. Wenn ich mir da andere unäre Operatoren ansehe (beispielsweise ~ oder auch -) ist das nicht der Fall. Drum gefällt mir der Vergleich da auch irgendwie nicht; auch wenns im Hintergrund sowiso zu nem i = operator++(i) werden würde.
Von der Seite betrachtet machts auch Sinn, warum ++i eigentlich i+1 liefert, i++ aber i.