====== Operator-Prioritäten ======

Operatoren werden in C als gleichwertig behandelt, wenn sie auf gleicher Ebene stehen. Operatoren mit hoher Priorität werden zuerst berechnet (z.B. Punktrechnung vor Strichrechnung).
Die Reihenfolge gibt bei binären Operatoren (zwei Argumente, zum Beispiel ''Arg1 + Arg2'') an, in welcher Reihenfolge die Argumente ausgewertet werden.


^ Priorität ^ Operator ^ Reihenfolge   ^ Bedeutung ^
|    15     | ()       | links, rechts | Funktionsaufruf |
|    15     | []       | links, rechts | Index     |
|    15     | <nowiki>-></nowiki>      | links, rechts | Dereferenzieren und Elementzugriff |
|    15     | .        | links, rechts | Elementzugriff |
|           ||||
|    14     | +        |               | positiv (Vorzeichen) |
|    14     | -        |               | negativ (Vorzeichen) |
|    14     | !        |               | logisches Nicht |
|    14     | ~        |               | bitweises Nicht |
|    14     | ++       |               | Präfix-Inkrement |
|    14     | ++       |               | Postfix-Inkrement |
|    14     | --       |               | Präfix-Dekrement |
|    14     | --       |               | Postfix-Dekrement |
|    14     | &        |               | Address-of |
|    14     | *        |               | Dereferenzieren |
|    14     | cast     |               | Typumwandlung |
|    14     | sizeof() |               | sizeof-Operator |
|           ||||
|    13     | *        | links, rechts | Multiplikation |
|    13     | /        | links, rechts | Division      |
|    13     | %        | links, rechts | Modulo        |
|           ||||
|    12     | +        | links, rechts | Addition      |
|    12     | -        | links, rechts | Subtraktion   |
|           ||||
|    11     | <<       | links, rechts | Links-Shift   |
|    11     | >>       | links, rechts | Rechts-Shift  |
|           ||||
|    10     | <        | links, rechts | kleiner       |
|    10     | >=       | links, rechts | kleiner oder gleich  |
|    10     | >        | links, rechts | größer        |
|    10     | >=       | links, rechts | größer oder gleich |
|           ||||
|     9     | ==       | links, rechts | gleich        |
|     9     | !=       | links, rechts | ungleich      |
|           ||||
|     8     | &        | links, rechts | bitweises Und |
|           ||||
|     7     | <nowiki>|</nowiki> | links, rechts | bitweises Oder |
|           ||||
|     6     | <nowiki>^</nowiki> | links, rechts | bitweises Exklusiv-Oder |
|           ||||
|     5     | <nowiki>&&</nowiki> | links, rechts | logisches Und |
|           ||||
|     4     | <nowiki>||</nowiki> | links, rechts | logisches Oder |
|           ||||
|     3     | <nowiki>?:</nowiki> | links, rechts | Bedingung |
|           ||||
|     2     | =        | rechts, links | Zuweisung |
|     2     | <nowiki>*=, /=, %=, +=, -=,<br> &=, ^=, |=, <<=, >>=</nowiki> | rechts, links | Operation und Zuweisung | 
|           ||||
|     1     | ,        | links, rechts | Komma     |
|           ||||
|     0     | ;        | links, rechts | Semikolon |


Prioritäten können durch Klammerung mit runden Klammern geändert werden.

===== Beispiele =====

==== Punkt vor Strichrechnung ====
<code cpp>x = 1 + 2 * 3;</code>

Der * Operator hat die Priorität 13 und bindet seine beiden Operanden (2 und 3), damit stärker an sich als der Plus-Operator (Priorität 12). Mit Klammern ausgedrückt steht dort
<code cpp>x = 1 + ( 2 * 3 );</code>

==== Vorzeichen ====
<code cpp>x = -2 + 4;</code>
Der Vorzeichenoperator besitzt die Priorität 14 und damit stärker als der Plus-Operator mit Priorität 12. Mit Klammern:
<code cpp>x = (-2) + 4;</code>

Würde der Plus-Operator stärker binden als der Vorzeichenoperator, würde zunächst 2+4 addiert und anschließend das Ergebnis 6 negiert. Möchte man dies ausdrücken, muss geklammert werden: ''x = -( 2 + 4)''

==== cast Operator ====
Der Cast-Operator dient der Typumwandlung. Casten ist fast immer ein Zeichen für ein Fehler im Programmdesign und sollte möglichst nie vorkommen.

Hierfür wird der neue Datentyp in Klammern vor den Ausdruck gesetzt. Gelegentlich muss dem Compiler jedoch eine Typumwandlung mitgeteilt werden.
<code cpp>
int x = 7;
double einDrittelVonX = x / 3;  // Hier wird eine Integer-Division durchgeführt: 7 / 3 ist 2.0 (nicht 2.333...).
</code>
Um diese Berechnung korrekt durchzuführen, muss mit Fließkommazahlen gerechnet werden. Bei einem konstanten Wert kann dafür einfach ein Punkt bzw. ''.0'' angefügt werden. Für die Variable ist eine Typumwandlung erforderlich:
<code cpp>
int x = 7;
double einDrittelVonX= ( (double)x ) / 3.0;   // Hier wird eine Fließkommazahl dividiert: 7 / 3 ist 2.333...
</code>

==== Weitere Beispiele ====

...finden sich zum Thema [[start|Ausdrücke]].