Was wann? Ich würde pauschal sagen, immer ++n, weil es keinen Seiteneffekt gibt. Außer man frickelt und das wird gewünscht.

Wenn erst inkrementiert udn dann zurückgegeben soll, dann : ++c

Wenn erst wert zurückgegeben soll und erst dann erhöht, dann c++

Wenn erst inkrementiert udn dann zurückgegeben soll, dann : ++c
Wenn erst wert zurückgegeben soll und erst dann erhöht, dann c++

richtig, einen anderen grund gibt es nicht. sollten unerwünschte nebeneffekte auftreten: programmiersprache wechseln.

laut Meyers gibt es aber doch einen gewaltigen Performanceunterschied zwischen beiden. Hab aber leider nicht im Kopf welcher nun besser ist und das Buch auch nicht in Reichweite.

Gruß Mümmel

Und als Entscheidungsgrundlage: Wenn der Rückgabewert des Operators weiter ausgewertet werden soll, nimm die Variante, die das richtige Ergebnis liefert (++x liefert den erhöhten Wert, x++ den Originalwert). Wenn der Rückgabewert egal ist, nimm ++x, der ist potentiell schneller^*.

^* Bei Build-in Typen macht es in der Regel keinen Unterschied, aber selbstdefinierte Typen müssen sich idR kopieren, um die Semantik von op++ erfüllen zu können - und dieses Kopieren kann teuer sein (und nicht jeder Compiler ist in der Lage es zu optimieren).

Und als Entscheidungsgrundlage: Wenn der Rückgabewert des Operators weiter ausgewertet werden soll, nimm die Variante, die das richtige Ergebnis liefert (++x liefert den erhöhten Wert, x++ den Originalwert). Wenn der Rückgabewert egal ist, nimm ++x, der ist potentiell schneller

Anders gesagt: Immer Präfix, außer Du brauchst Postfix.

Wenn der Rückgabewert egal ist, nimm ++x, der ist potentiell schneller^*.

wieso könnte der schneller sein?

CStoll schrieb:

Wenn der Rückgabewert egal ist, nimm ++x, der ist potentiell schneller^*.

wieso könnte der schneller sein?

class A {
  A &operator++() { ... return *this; } //prefix
  A operator++(int) { // postfix
    A tmp(*this);
    ++*this;
    return tmp;
  }
};

Aber war es nicht so, dass der Compiler auch bei Builtin-Typen a++ zu ++a machen konnte?

CStoll schrieb:

Wenn der Rückgabewert egal ist, nimm ++x, der ist potentiell schneller^*.

wieso könnte der schneller sein?

Vielleicht solltest du nicht mitten im Beitrag aufhören mit Lesen - das hochgestellte * kennzeichnet bei mir normalerweise Fußnoten, die weiter unten erläutert werden

@rüdiger: Bei Build-ins durchaus - bei selbstgebauten Typen eher nicht.

Das Problem ist dabei denke ich weniger der Compiler, als z.B. Funktionen deren Implementierung der Compiler nicht kennt, und die daher aufgerufen werden müssen (könnten ja erwünschte Seiteneffekte haben). z.B. das Locken von Mutexen, "interlocked" Funktionen oder dynamische Speicheranforderungen können im Normalfall nicht wegoptimiert werden.

Von daher die Regel: wenn post- oder pre- egal ist, dann pre-inkrement.

Was für andere Sprachen gilt kann ich nicht sagen.

@stutzig: Das Problem wird immer dann interessant, wenn es zwei verschiedene Inkrement-Funktionen gibt - die unabhängig voneinander implementiert werden könnten (C# und D definieren afaik eine Funktion für beide Varianten - da macht sich das Optimieren etwas einfacher).