Inkrementieren in C ++ - Wann wird x ++ oder ++ x verwendet?

Ich lerne gerade C ++ und habe vor einiger Zeit etwas über die Inkrementierung gelernt. Ich weiß, dass Sie "++ x" verwenden können, um die Inkrementierung vorher vorzunehmen, und "x ++", um sie danach durchzuführen.

Trotzdem weiß ich wirklich nicht, wann ich eines der beiden verwenden soll ... Ich habe "++ x" nie wirklich verwendet und die Dinge haben bisher immer gut funktioniert - also wann sollte ich es verwenden?

Beispiel: Wann ist es in einer for-Schleife vorzuziehen, "++ x" zu verwenden?

Könnte jemand auch genau erklären, wie die verschiedenen Inkrementierungen (oder Dekrementierungen) funktionieren? Ich würde dies sehr begrüssen.

Es geht nicht um Präferenz, sondern um Logik.

x++erhöht den Wert der Variablen x nach der Verarbeitung der aktuellen Anweisung.

++xErhöht den Wert der Variablen x, bevor die aktuelle Anweisung verarbeitet wird.

Entscheide dich also einfach für die Logik, die du schreibst.

x += ++ierhöht i und addiert i + 1 zu x. x += i++fügt i zu x hinzu und erhöht dann i.

Scott Meyers fordert Sie auf, das Präfix zu bevorzugen, außer in Fällen, in denen die Logik vorschreibt, dass das Postfix angemessen ist.

"Effective C ++" Punkt 6 - das ist ausreichend Autorität für mich.

Für diejenigen, die das Buch nicht besitzen, sind hier die relevanten Zitate. Ab Seite 32:

Aus Ihrer Zeit als C-Programmierer erinnern Sie sich vielleicht daran, dass das Präfixformular des Inkrementoperators manchmal als "Inkrementieren und Abrufen" bezeichnet wird, während das Postfixformular häufig als "Abrufen und Inkrementieren" bezeichnet wird. Es ist wichtig, sich an die beiden Sätze zu erinnern, da sie alle nur als formale Spezifikationen dienen ...

Und auf Seite 34:

Wenn Sie sich Sorgen um die Effizienz machen, sind Sie wahrscheinlich ins Schwitzen gekommen, als Sie die Postfix-Inkrementierungsfunktion zum ersten Mal sahen. Diese Funktion muss ein temporäres Objekt für ihren Rückgabewert erstellen, und die obige Implementierung erstellt auch ein explizites temporäres Objekt, das erstellt und zerstört werden muss. Die Präfix-Inkrement-Funktion hat keine solchen Provisorien ...

Aus der Referenz beim Inkrementieren von Iteratoren:

Sie sollten den Operator vor dem Inkrementieren (++ Iter) dem Operator nach dem Inkrementieren (iter ++) vorziehen, wenn Sie den alten Wert nicht verwenden möchten. Das Nachinkrementieren wird im Allgemeinen wie folgt implementiert:

   Iter operator++(int)   {
     Iter tmp(*this); // store the old value in a temporary object
     ++*this;         // call pre-increment
     return tmp;      // return the old value   }

Offensichtlich ist es weniger effizient als das Vorinkrementieren.

Durch die Vorinkrementierung wird das temporäre Objekt nicht generiert. Dies kann einen erheblichen Unterschied machen, wenn die Erstellung Ihres Objekts teuer ist.

Ich möchte nur bemerken, dass der geneatisierte Code derselbe ist, wenn Sie eine Inkrementierung vor / nach der Inkrementierung verwenden, bei der die Semantik (von vor / nach) keine Rolle spielt.

Beispiel:

pre.cpp:

#include <iostream>

int main()
{
  int i = 13;
  i++;
  for (; i < 42; i++)
    {
      std::cout << i << std::endl;
    }
}

post.cpp:

#include <iostream>

int main()
{

  int i = 13;
  ++i;
  for (; i < 42; ++i)
    {
      std::cout << i << std::endl;
    }
}

_

$> g++ -S pre.cpp
$> g++ -S post.cpp
$> diff pre.s post.s   
1c1
<   .file   "pre.cpp"
---
>   .file   "post.cpp"

Das Wichtigste ist, dass x ++ den Wert zurückgeben muss, bevor das Inkrement tatsächlich stattgefunden hat. Daher muss eine temporäre Kopie des Objekts erstellt werden (Pre-Inkrement). Dies ist weniger effizient als ++ x, das direkt inkrementiert und zurückgegeben wird.

Eine andere erwähnenswerte Sache ist jedoch, dass die meisten Compiler in der Lage sein werden, solche unnötigen Dinge zu optimieren, wenn dies möglich ist. Beispielsweise führen beide Optionen hier zu demselben Code:

for (int i(0);i<10;++i)
for (int i(0);i<10;i++)

Ich stimme @BeowulfOF zu, obwohl ich aus Gründen der Klarheit immer empfehlen würde, die Aussagen so aufzuteilen, dass die Logik absolut klar ist, dh:

i++;
x += i;

oder

x += i;
i++;

Meine Antwort lautet also: Wenn Sie klaren Code schreiben, sollte dies selten eine Rolle spielen (und wenn es darauf ankommt, ist Ihr Code wahrscheinlich nicht klar genug).

Ich wollte nur noch einmal betonen, dass ++ x voraussichtlich schneller als x ++ ist (insbesondere wenn x ein Objekt eines beliebigen Typs ist). Daher sollte ++ x verwendet werden, sofern dies nicht aus logischen Gründen erforderlich ist.

Sie haben den Unterschied richtig erklärt. Es hängt nur davon ab, ob x vor jedem Durchlauf einer Schleife oder danach inkrementiert werden soll. Es hängt von Ihrer Programmlogik ab, was angemessen ist.

Ein wichtiger Unterschied beim Umgang mit STL-Iteratoren (die auch diese Operatoren implementieren) besteht darin, dass ++ eine Kopie des Objekts erstellt, auf das der Iterator zeigt, diese dann inkrementiert und dann zurückgibt. ++ Es führt andererseits zuerst das Inkrement durch und gibt dann einen Verweis auf das Objekt zurück, auf das der Iterator jetzt zeigt. Dies ist meistens nur relevant, wenn jede Leistung zählt oder wenn Sie Ihren eigenen STL-Iterator implementieren.

Bearbeiten: Die Verwechslung von Präfix- und Suffixnotation wurde behoben

Postfix-Form von ++, - Operator folgt der Regel use-then-change ,

Das Präfixformular (++ x, - x) folgt der Regeländerung-dann-Verwendung .

Beispiel 1:

Wenn mehrere Werte mit << unter Verwendung von cout kaskadiert werden, finden Berechnungen (falls vorhanden) von rechts nach links statt, der Druck erfolgt jedoch von links nach rechts, z. B. (wenn val anfänglich 10).

 cout<< ++val<<" "<< val++<<" "<< val;

wird in ergeben

12    10    10 

Beispiel 2:

Wenn in Turbo C ++ mehrere Vorkommen von ++ oder (in irgendeiner Form) in einem Ausdruck gefunden werden, werden zuerst alle Präfixformulare berechnet, dann wird der Ausdruck ausgewertet und schließlich werden Postfixformulare berechnet, z.

int a=10,b;
b=a++ + ++a + ++a + a;
cout<<b<<a<<endl;

Es wird in Turbo C ++ ausgegeben

48 13

Während es im modernen Compiler ausgegeben wird (weil sie die Regeln streng befolgen)

45 13

• Hinweis: Die mehrfache Verwendung von Inkrementierungs- / Dekrementierungsoperatoren für dieselbe Variable in einem Ausdruck wird nicht empfohlen. Die Behandlung / Ergebnisse solcher
  Ausdrücke variieren von Compiler zu Compiler.

Das Verständnis der Sprachsyntax ist wichtig, wenn Sie die Klarheit des Codes berücksichtigen möchten. Kopieren Sie eine Zeichenfolge, beispielsweise mit Post-Inkrement:

char a[256] = "Hello world!";
char b[256];
int i = 0;
do {
  b[i] = a[i];
} while (a[i++]);

Wir möchten, dass die Schleife ausgeführt wird, indem das Nullzeichen (das false testet) am Ende der Zeichenfolge angetroffen wird. Dazu muss der Wert vor dem Inkrementieren getestet und auch der Index erhöht werden. Aber nicht unbedingt in dieser Reihenfolge - eine Möglichkeit, dies mit dem Vorinkrement zu codieren, wäre:

int i = -1;
do {
  ++i;
  b[i] = a[i];
} while (a[i]);

Es ist eine Geschmackssache, die klarer ist und wenn die Maschine eine Handvoll Register hat, sollten beide die gleiche Ausführungszeit haben, selbst wenn a [i] eine Funktion ist, die teuer ist oder Nebenwirkungen hat. Ein wesentlicher Unterschied könnte der Exit-Wert des Index sein.