C++ bietet mehrere Wege, Ihren Programmcode abzukürzen und klarzulegen. Einer dieser Wege ist der arithmetische Zuweisungsoperator.

Die folgende Anweisungsform ist in den meisten Programmiersprachen üblich:

total = total + item; // Addiert "item" zu "total"

In diesem Fall addieren Sie etwas zu einem bereits bestehenden Wert (oder Sie führen eine andere Rechenoperation mit ihm durch). Die Syntax dieser Anweisung stößt aber bei denjenigen auf Ablehnung, die mehr Wert auf die Kürze der Anweisung legen, da der Name total zweimal auftaucht. Deshalb stellt C++ eine verkürzte Variante bereit: Den arithmetischen Zuweisungsoperator kombiniert und den wiederholten Operanden wegfallen läßt. Hier folgt eine Anweisung, die genau die gleiche Wirkung hat wie die obere Anweisung:

total += item; // Addiert "item" zu "total"

Es gibt für alle arithmetische Operatoren einen entsprechenden arithmetischen Zuweisungsoperator: +=, -=, *=. /= und &= (und noch einige andere Operanden mehr). Das folgende Beispiel veranschaulicht den Gebrauch des arithmetischen Zuweisungsoperators:

// assign.cpp
// Veranschaulicht den arithmetischen Zuweisungsoperator
#include <iostream.h>

void main()
 {
  int ans = 27;
  ans += 10; // Gleichbedeutend mit: ans = ans + 10;
  cout << endl << ans;
  ans -= 7;  // Gleichbedeutend mit ans = ans -7;
  cout << endl << ans;
  ans *= 2;  // Gleichbedeutend mit ans = ans * 2;
  cout << endl << ans;
  ans /= 3; // Gleichbedeutend mit ans = ans / 3;
  cout << endl << ans;
  ans &= 3;  // Gleichbeteutend mit ans = ans % 3;
  cout << endl << ans;
 }

Es folgt die Ausgabe des Programms:

37
30
60
20
2

Inkrementoperator

Es folgt noch weiter spezialisierter Opertor. Es kommt sehr ost vor, daß Sie zum Wert einer vorhandenen die Zahl 1 addieren müssen. Sie können dies auf dem normalen Weg erreichen:

count = count + 1; // ddiert 1 zu "count"

Oder Sie setzen einen arithmetischen Zuweisungsoperator ein:

cout += 1; // Addiert 1 zu "cout"

Es gibt aber eine noch kürzere Form:

++cout; // Addiert 1 zu "cout"

Der Operator ++ inkrementiert (addiert 1 dazu) sein Argument.

Als wenn dies nicht genug wäre, kann der Inkrementoperator auf zweierlei Art und Weise verwendet werden: Als Präfix, was bedeutet, daß der Operator der Variablen vorausgeht; und als Postfix, was bedeutet, daß der Operator auf die Variable folgt. Worin besteht der Unterschied? Häufig wird eine Wariable in einer Anweisung inkrementiert, die andere Rechenoperation an ihr ausgeführt. Als Beispiel:

totalWeight = avgWeight * ++count;

Es stellt sich hier folgende Frage: Wird die Multipliktion ausgeführt, bevor oder nachdem count inkrementiert worden ist? In diesem Fall wird count zuerst inkrementiert. Woher wissen wir das? Weil die Präfixschreibweise ++count verwendet wurde. Wenn wir die Postfixschreibweise cout++ benutzt hätten, wäre die Multiplikation zuerst ausgeführt und count anschließend inkrementiert worden.

Es folgt ein Beispiel, das sowohl die Präfix als auch die Postfixversion des Inkrementoperators zeigt:

// increm.cpp
// Veranschaulicht den Inkrementoperator
#include <iostream.h>

void main()
 {
  int cout = 10;
  cout << "count=" << count << endl;  // Anzeige von 10
  cout << "count=" << ++count << endl;  // Anzeige von 11 (Präfix)
  cout << "count=" << count << endl;  // Anzeige von 11
  cout << "count=" << count++ << endl;  // nzeige von 11 (Postfix)
  cout << "count=" << count << endk;  // Anzeige von 12
 }

Der Dekrementoperator (--)

Der Dekrementoperator -- verhält sich zum großen Teil wie der Inkrementoperator, mit der Ausnahme, daß er vom Operand die Zahl 1 subtrahiert. Er kann ebenfalls in der Präfix und Postfixform verwendet werden.

15