Forum: PC-Programmierung Warum abkürzende Schreibweise?


von dito (Gast)


Lesenswert?

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".

von I.c.h (Gast)


Lesenswert?

Also ich finde so etwas auch unschön. Aber ich denke es ist einfach 
weniger zu tippen!

von Mark B. (markbrandis)


Lesenswert?

Nicht wenige Programmierer sind faule Säcke, was Tippen angeht. ;-)

von Rufus Τ. F. (rufus) Benutzerseite


Lesenswert?

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.

von Albrecht H. (alieninside)


Lesenswert?

1
MeineGanzEigeneVariable += 1;
1
MeineGanzEigeneVariable = MeineGanzEigeneVariable + 1;

oder
1
MeineGanzEigeneVariable += NochNeAndereVariable;
1
MeineGanzEigeneVariable = MeineGanzEigeneVariable + NochNeAndereVariable;

von Joachim (Gast)


Lesenswert?

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

von Thomas B. (escamoteur)


Lesenswert?

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

von Maik F. (sabuty) Benutzerseite


Lesenswert?

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
1
a++;
schreiben. ;)

von Stefan Salewski (Gast)


Lesenswert?

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.

von Johnny B. (johnnyb)


Lesenswert?

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 ;-)

von Läubi .. (laeubi) Benutzerseite


Lesenswert?

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".

von dito (Gast)


Lesenswert?

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.

von Albrecht H. (alieninside)


Lesenswert?

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.

von Klaus W. (mfgkw)


Lesenswert?

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.

von Peter (Gast)


Lesenswert?

feld[i++]++;
 feld[i++]++;

geht ja gar nicht ohne Kurzschreibweise (oder geht das etas doch ..)

 feld[i = i + 1]++;
 feld[i = i + 1]++;

von Klaus W. (mfgkw)


Lesenswert?

feld[i = i + 1]++ entspricht aber feld[++i]++, nicht feld[i++]++

von Erich R. (riedi)


Lesenswert?

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.

von ... .. (docean) Benutzerseite


Lesenswert?

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

von Janosch (Gast)


Lesenswert?

dito schrieb:
> Ich finde das so unleserlich und muss dann immer "umdenken".

Dann gewöhne dir mal richtiges denken an. ;)

von Sven P. (Gast)


Lesenswert?

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:
1
int x;
2
3
x = ursprung();
4
x *= skalierung();
5
x += offset();
6
...

von Helmut L. (helmi1)


Lesenswert?

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 ;-)

von raymond (Gast)


Lesenswert?

>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:
1
Label mylabel = Label ( sichtbar ? sichtbaresFenster : unsichtbaresFenster, SWT.NONE)

anstatt:
1
if (sichtbar)
2
  Label mylabel = Label (  sichtbaresFenster, SWT.NONE)
3
else
4
  Label mylabel = Label ( unsichtbaresFenster, SWT.NONE)

von Yalu X. (yalu) (Moderator)


Lesenswert?

Jedesmal, wenn ich so etwas lese
1
object[obj_id].polygon[jstart+j].x = object[obj_id].polygon[jstart+j].x + xshift;

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.

von Klaus W. (mfgkw)


Lesenswert?

ACK

Wer will, darf gerne BASIC nehmen.

von Sven W. (woehlb)


Lesenswert?

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.

von Martin (Gast)


Lesenswert?

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

von Stefan Salewski (Gast)


Lesenswert?

>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.

von der mechatroniker (Gast)


Lesenswert?

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!)

von Jacek G. (tfc)


Lesenswert?

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.

von Pink S. (pinkshell)


Lesenswert?

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)]++;

von Yalu X. (yalu) (Moderator)


Lesenswert?

@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
1
   a[ff(x)] += 1;

ohne += erreichen wollte, müsste man
1
   int tmp;
2
3
   tmp = ff(x);
4
   a[tmp] = a[tmp] + 1;

schreiben, was ziemlich holprig aussieht.

von JensM (Gast)


Lesenswert?

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

von Rolf Magnus (Gast)


Lesenswert?

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.

von Lehrmann M. (ubimbo)


Lesenswert?

ich denke mal es hat jeder seinen eigenen C-Stil. Jeder wie er mag find 
ich =)

von Vlad T. (vlad_tepesch)


Lesenswert?

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.

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.