Hallo,
ich lese sehr häufig in C/C++ und Java Konstrukte folgender Art:
1
a+=1;
Gemeint damit ist:
1
a=a+1;
Was ist eigentlich der Grund, dass die erste Schreibweise bevorzugt
wird? Geht es nur darum, sich die "Tipparbeit" für einen Operanden zu
sparen?
Ich finde das so unleserlich und muss dann immer "umdenken".
Ja, es geht um das Weglassen unnötigen Getippsels.
Mit etwas Übung wird sich Deine Einstellung ändern, die "Langversion"
wird Dir umständlich und schlecht zu lesen vorkommen.
Hallo
Was ist übersichtlicher
Dies_ist_ein_integer_zum_hochzaehlen += 1
oder
Dies_ist_ein_integer_zum_hochzaehlen =
Dies_ist_ein_integer_zum_hochzaehlen + 1
Und jetzt stell dir vor, da ist ein Schreibfehler drin.
Gruß
Joachim
nochwas:
Bei den +=, |= &= etc ist immer klar, dass es eine Manipulation der
Linkseitigen Variable bedeutet und dass ohne dass ich mir die rechte
Seite des Audrucks überhaup anschauen muss.
Wenns nur um ein inkrement um 1 geht gibt's eh nicht besser
dokumentierendes als
i++
Gruß
Tom
dito schrieb:
> ich lese sehr häufig in C/C++ und Java Konstrukte folgender Art:> a += 1;> Was ist eigentlich der Grund, dass die erste Schreibweise bevorzugt> wird?
Seltsame Behauptung. Ich würde in diesem Fall sowieso gleich
Stefan Salewski schrieb:
> In Modula/Oberon hatten wir>> INC(a), INC(a,CONSTANT) bzw.> DEC(a), DEC(a,CONSTANT)> für ganze Zahlen. Gefällt mir noch immer am besten.
Man könnte sich in C diesbezüglich ein Makro schreiben.
Allerdings wird es dann für einen anderen C-Programmierer komplett
unleserlich ;-)
dito schrieb:
> Ich finde das so unleserlich und muss dann immer "umdenken".
(Nach)denken gehört zum Job ;)
Wie schon geschrieben drückt es halt einmal den Wunsch aus, das man
etwas auf die Variable drauf addieren will.
Andererseits spart es Tipp- und Lesarbeit (wurde auch schon genannt) du
sieht sofort a += b und weisst das auf a irgenwas draufaddiert wird (und
in a gespeichert), ohne das du Angenehmen könntest a würde einfach
überschrieben
Und das nächste ist wenn du irgendwann mal den Namen der Variablen
anpassen willst kannst du es nicht so leicht "vergessen".
Mit so vielen Antworten in kurzer Zeit hätte ich gar nicht gerechnet.
Also geht es in erster Linie doch einfach um weniger Tipparbeit.
Dieser Grund klingt für mich aber auch sehr plausibel:
> Bei den +=, |= &= etc ist immer klar, dass es eine Manipulation der> Linkseitigen Variable bedeutet und dass ohne dass ich mir die rechte> Seite des Audrucks überhaup anschauen muss.
dito schrieb:
> Mit so vielen Antworten in kurzer Zeit hätte ich gar nicht gerechnet.> Also geht es in erster Linie doch einfach um weniger Tipparbeit.> ...
Außerdem handelt es sich nur um ein Möglichkeit, man darf es so machen
muss aber nicht.
Trotzdem, irgendwas muss schon dran sein, früher oder später ertappt man
sich dabei, dass man die Kurzschreibweise immer öfter automatisch
verwendet.
Wenn ich es nicht überlesen habe, fehlt noch ein weiteres
Argument:
Bis vor ein paar Jahren waren die Compiler wesentlich weniger
ausgereift bzgl. Optimierung.
Ein entsprechend dummer Compiler würde in einem Ausdruck der Art:
1
feld[i+j]=feld[i+j]+1;
gar nicht merken, daß er zweimal den denselben Code produziert.
Mit ++feld[i+j] oder feld[i+j]+=1 ist es egal, wie dumm der
Compiler ist - der bessere Code entsteht automatisch.
Es gibt in C (meiner Meinung nach leider) ein Paar Möglichkeiten,
Ausdrücke zu verkürzen. So z.B. auch für eine if-Anweisung.
Einer meiner Profs im Studium hatte davor gewarnt, sich verkürzte
Schreibweisen anzugewöhnen. Code sollte immer (auch für
Gelegenheitsprogrammierer... oder Chefs :-) ) möglichst einfach zu lesen
sein.
Ich halte mich bis heute daran, da ich finde, er hatte recht.
Oder in anderen Worte: Keep it simple and stupid. Vermeidet Fehler,
Falschauslegungen etc.
Gruß
E.
die kurze Schreibweise sorgt für weniger Fehler...
z.b. eine_var = ene_var+5;
hier gut zu erkennen, aber ob man das immer so gut erkennen kann...
da doch lieber eine_var+=5; eine Stelle weniger wo ich mich vertippen
kann
Für viele Leute, die Assembler oder RPN gewohnt sind, ist es einfacher
zu lesen. Das klappt z.B., wenn man einen langen Ausdruck aufbricht und
eine Variable quasi als Arbeitsregister benutzt:
Man kann auch den umgekehrten Weg gehen und alles moeglich lang
hinschreiben.
Aus Wikipedia zu Cobol:
Wenn es zum Beispiel in C heißt a = b + c;, dann schreibt ein
Cobol-Programmierer entweder ADD b TO c GIVING a oder alternativ COMPUTE
a = b + c.
Wenns den Spass macht und die Finger noch beweglich sind ;-)
>So z.B. auch für eine if-Anweisung.>Einer meiner Profs im Studium hatte davor gewarnt, sich verkürzte>Schreibweisen anzugewöhnen.
ich finde manchmal die verkürzte if Schreibweise auch ganz angebracht.
z.B:
fange ich an, nach Unterschieden in den Ausdrücken links und rechts vom
Gleicheitszeichen zu suchen. Da ich bei solchen Vergleichen regelmäßig
etwas übersehe, breche ich die Zeile manchmal im Editor temporär um,
damit die ähnliche Teile direkt untereinander stehen.
Wenn ich dann nach 20s feststelle, dass der linke Ausdruck identisch
auch auf der rechten Seite auftaucht, fluche ich über den Programmierer
und frage mich, warum er die Zuweisung nicht so geschrieben hat:
1
object[obj_id].polygon[jstart+j].x+=xshift;
was nicht nur wesentlich besser lesbar, sondern auch änderungsfreundli-
cher ist.
Es gibt zwar einige Kurzschreibweisen in C, die den Code bei falscher
Anwendung zu sehr verdichten und damit schwerer lesebar machen. Der
'+='-Operator und seine Kollegen gehören meiner Meinung nach aber
definitv nicht dazu.
Je nach Compiler und verwendeten Mikrocontroller kann es dabei auch um
ein kleineres Programfile gehen.
Für i++ dürfte sehr häufig direkt ein Assemblerbefehl z.B. "incf i,f"
oder ähnlich möglich sein.
Für i = i + 1 gibt es erstmal kein direktes Assembleräquivalent. Es sei
denn der Optimierer ist so intelligent, und bricht es auf i++ herunter.
ich finde a+=1 deutlich ästhetischer als a=a+1
das letzte hinterlässt in meinem Gehirn die Denkspur:
nimm a und addiere 1 dazu und weise wieder alles nach a zu
beim ersten ist es eher: incrementiere a um 1
>ich finde a+=1 deutlich ästhetischer
Und wenn man statt
a+=1
a+1
a=1
a=+1
a==1
usw. tippt? Wird wohl nicht selten vorkommen, wo die meisten in diesem
Forum je Text-Zeile mindestens einen Tippfehler machen. Aber ist ja kein
Problem bei dem neuerdings üblichen Programmierstil: Eine Zeile etwas
verändern, compilieren und testen. Und wenn es nicht funktioniert auf
Hilfe von Herrn Buchegger hoffen.
Na ja, ein versehentliches a+1 sowie a==1 bemerkt man spätestens beim
Compilieren, wenn einem die Warning: Statement has no effect ins Gesicht
springt. Davon abgesehen bevorzuge ich
a += 1;
(mit dem Whitespace!)
Sven Woehlbier schrieb:
> Je nach Compiler und verwendeten Mikrocontroller kann es dabei auch um> ein kleineres Programfile gehen.>> Für i++ dürfte sehr häufig direkt ein Assemblerbefehl z.B. "incf i,f"> oder ähnlich möglich sein.>> Für i = i + 1 gibt es erstmal kein direktes Assembleräquivalent. Es sei> denn der Optimierer ist so intelligent, und bricht es auf i++ herunter.
Ich wundere mich immer, wieso eigentlich nicht ++i genommen wird, wenn
eine Variable einfach nur inkrementiert werden soll.
"i++" steht für "erzeuge eine Kopie vom aktuellen Zustand und
inkrementiere das Original".
Ein schlauer Compiler macht aus
a = a +1;
a += 1;
a++;
eigentlich ein
++a;
, denn nur letzteres lässt sich mit "inc a" (Jetzt mal Pseudo-Assembler,
da eh jedem klar sein wird was gemeint ist) darstellen.
Ich benutze selbst eigentlich auch immer nur variable++, weil andere
Programmierer sich oftmals irritiert geben und ich einfach nur lesbaren
Code schreiben will, anstatt jetzt irgendwelche "++variable ist viel
korrekter!!!"-Prinzipien durchzudrücken.
Aber wundern tue ich mich trotzdem.
Und was ist mit sowas
int ff (int x)
{
// hier viele side effects
// hier viel Rechenzeit
return x;
}
void main ()
{
int a[100];
a[ff(x)] = a[ff(x)] + 1; // so ist es Mist
}
Da wird die Funktion ff zweimal ausgeführt im Gegensatz zu
a[ff(x)] += 1; oder
a[ff(x)]++;
@Pink Shell:
Stimmt, das ist ein weiteres gutes Beispiel, das ganz klar für die
Verwendung des +=-Operators spricht. Wenn man das gleiche Verhalten wie
Es gibt noch einen Grund der Vorteile für die kurze Schreibweise bringt:
Angenommen a ist eine Klasse
Bei dieser Klasse ist der + Operator überschrieben.
Der Kompiler macht für a = a + x und a += x denselben Code.
Es hat also keine Auswirkung.
Wenn in der Klasse a aber der += Operator mit einer optimierten Funktion
überschrieben wurde, so kann der Kompiler diese nur in der kurzen
Schreibweise verwenden.
Unabhängig davon, ob der += Operator in der Klasse a überschrieben wurde
oder nicht bringt es keinen Nachteil die kurze Version zu verwenden,
aber eventuell Vorteile!
MfG
JensM
JensM schrieb:
> Es gibt noch einen Grund der Vorteile für die kurze Schreibweise> bringt:> Angenommen a ist eine Klasse>> Bei dieser Klasse ist der + Operator überschrieben.>> Der Kompiler macht für a = a + x und a += x denselben Code.> Es hat also keine Auswirkung.
Nein. a += x ruft immer den Operator += auf. Wenn der in der Klasse
nicht definiert wurde, meldet der Compiler einen Fehler. Er ersetzt den
Operator nicht im Hintergrund durch einen anderen.
Pink Shell schrieb:
> int ff (int x)> {> // hier viele side effects> // hier viel Rechenzeit> return x;> }>> void main ()> {> int a[100];> a[ff(x)] = a[ff(x)] + 1; // so ist es Mist> }
sowas ist sowieso ganz schlechter Stil.