Operatoren (C#-Programmierhandbuch)
In C# ist ein Operator ein Programmelement, das auf einen oder mehrere Operanden in einem Ausdruck oder einer Anweisung angewendet wird. Operatoren mit einem Operanden, z. B. der Inkrementoperator (++) oder new, werden als unäre Operatoren bezeichnet. Operatoren mit zwei Operanden, z. B. arithmetische Operatoren (+, -, *, /), werden als binäre Operatoren bezeichnet. Der bedingte Operator (?:) verfügt über drei Operanden. Er ist der einzige ternäre Operator in C#.
Die folgende C#-Anweisung enthält einen einzelnen unären Operator und einen einzigen Operanden. Der Inkrementoperator ++ ändert den Wert des Operanden y.
y++;
Die folgende C#-Anweisung enthält zwei binäre Operatoren mit jeweils zwei Operanden. Die Operanden des Zuweisungsoperators = sind die ganzzahlige Variable y und der Ausdruck 2 + 3. Der Ausdruck 2 + 3 selbst besteht aus dem Additionsoperator und zwei Operanden: 2 und 3.
y = 2 + 3;
Operatoren, Evaluierung und Operatorrangfolge
Ein Operand kann ein gültiger Ausdruck beliebiger Größe sein und sich aus einer beliebigen Anzahl anderer Ausdrücke zusammensetzen. In einem Ausdruck mit mehreren Operatoren, wird die Reihenfolge, in der die Operatoren angewendet werden, von der Operatorrangfolge, Assoziativität und Klammern bestimmt.
Jeder Operator verfügt über einen definierten Vorrang. In einem Ausdruck, der mehrere Operatoren mit verschiedene Rangfolgenebenen enthält, bestimmt die Rangfolge der Operatoren die Reihenfolge, in der die Operatoren ausgewertet werden. Beispielsweise weist die folgende Anweisung n1 3 zu.
n1 = 11 - 2 * 4;
Die Multiplikation wird zuerst ausgeführt, da Multiplikation Vorrang vor Subtraktion enthält.
In der folgenden Tabelle werden die Operatoren basierend auf dem Typ der Operation, die sie ausführen, in Kategorien unterteilt. Die Kategorien sind entsprechend der Operatorrangfolge aufgelistet.
Primäre Operatoren
Ausdruck |
Beschreibungen |
|---|---|
x.y |
Memberzugriff |
f(x) |
Aufrufen von Methoden und Delegaten |
a[x] |
Array- und Indexerzugriff |
x++ |
Postinkrement |
x-- |
Postdekrement |
new T(...) |
Objekt- und Delegaterstellung |
new T(...){...} |
Objekterstellung mit Initialisierern. Weitere Informationen finden Sie unter Objekt- und Auflistungsinitialisierer (C#-Programmierhandbuch). |
new {...} |
Anonymer Objektinitialisierer. Weitere Informationen finden Sie unter Anonyme Typen (C#-Programmierhandbuch). |
new T[...] |
Arrayerstellung. Weitere Informationen finden Sie unter Arrays (C#-Programmierhandbuch). |
typeof(T) |
Abrufen des System.Type-Objekts für T |
checked(x) |
Auswerten von Ausdrücken in überprüftem Kontext |
unchecked(x) |
Auswerten von Ausdrücken in nicht überprüftem Kontext |
default (T) |
Abrufen des Standardwerts vom Typ T |
delegate {} |
Anonyme Funktion (anonyme Methode) |
Unäre Operatoren
Ausdruck |
Beschreibungen |
|---|---|
+x |
Identity |
-x |
Negation |
!x |
Logische Negation |
~x |
Bitweise Negation |
++x |
Präinkrement |
--x |
Prädekrement |
(T)x |
Explizites Konvertieren von x in den Typ T |
Multiplikative Operatoren
Ausdruck |
Beschreibungen |
|---|---|
Multiplikation |
|
Division |
|
Rest |
Additive Operatoren
Ausdruck |
Beschreibungen |
|---|---|
x + y |
Addition, Zeichenfolgenverkettung, Delegatkombination |
x - y |
Subtraktion, Delegatentfernung |
Schiebeoperatoren
Ausdruck |
Beschreibungen |
|---|---|
x << y |
Nach links verschieben |
x >> y |
Nach rechts verschieben |
Relationale Operatoren und Typoperatoren
Ausdruck |
Beschreibungen |
|---|---|
x < y |
Kleiner als |
x > y |
Größer als |
x <= y |
Kleiner oder gleich |
x >= y |
Größer oder gleich |
x is T |
Gibt true zurück, wenn x gleich T ist, andernfalls false. |
x as T |
Gibt x als T typisiert zurück, oder NULL, wenn x nicht vom Typ T ist. |
Gleichheitsoperatoren
Ausdruck |
Beschreibungen |
|---|---|
x == y |
Gleich |
x != y |
Ungleich |
Logische, bedingte und NULL-Operatoren
Kategorie |
Ausdruck |
Beschreibungen |
|---|---|---|
Logisches AND |
x & y |
Ganzzahliges bitweises AND, boolesches logisches AND |
Logisches XOR |
x ^ y |
Ganzzahliges bitweises XOR, boolesches logisches XOR |
Logisches OR |
x | y |
Ganzzahliges bitweises OR, boolesches logisches OR |
Bedingtes AND |
x && y |
Wertet y nur aus, wenn x den Wert true hat. |
Bedingtes OR |
x || y |
Wertet y nur aus, wenn x den Wert false hat. |
Null Coalesce |
x ?? y |
Ergibt y, wenn x den Wert NULL hat, andernfalls x |
Bedingt |
x ?: y : z |
Wird zu y ausgewertet, wenn x den Wert "true" hat, und zu z, wenn x den Wert "false" hat. |
Zuweisungsoperatoren und anonyme Operatoren
Ausdruck |
Beschreibungen |
|---|---|
Zuweisung |
|
x op= y |
Verbundzuweisung. Unterstützt diese Operatoren: +=, -=, *=, /=, %=, &=, |=, !=, <<=, >>= |
(T x) => y |
Anonyme Funktion (Lambda-Ausdruck) |
Assoziativität
Wenn ein Ausdruck zwei oder mehr Operatoren mit demselben Rang enthält, wird die Auswertungsreihenfolge anhand des Assoziativitätsgesetzes festgelegt. Linksassoziative Operatoren werden von links nach rechts ausgewertet. x * y / z wird beispielsweise als (x * y) / z ausgewertet. Rechtsassoziative Operatoren werden von rechts nach links ausgewertet. Beispielsweise ist der Zuweisungsoperator rechtsassoziativ. Falls nicht, würde der folgende Code zu einem Fehler führen.
int a, b, c;
c = 1;
// The following two lines are equivalent.
a = b = c;
a = (b = c);
// The following line, which forces left associativity, causes an error.
//(a = b) = c;
Die Zuweisungsoperatoren und der ternäre Operator (?:) sind rechtsassoziativ. Alle anderen binären Operatoren sind linksassoziativ.
Unabhängig davon, ob Operatoren in einem Ausdruck linksassoziativ oder rechtsassoziativ sind, werden zuerst die Operanden aller Ausdrücke von links nach rechts ausgewertet. Die folgenden Beispiele veranschaulichen die Auswertungsreihenfolge von Operatoren und Operanden.
Anweisung |
Reihenfolge der Auswertung |
|---|---|
a = b |
a, b, = |
a = b + c |
a, b, c, +, = |
a = b + c * d |
a, b, c, d, *, +, = |
a = b * c + d |
a, b, c, *, d, +, = |
a = b - c + d |
a, b, c, -, d, +, = |
a += b -= c |
a, b, c, -=, += |
Hinzufügen von Klammern
Sie können die Reihenfolge ändern, die von Operatorenrangfolge und Assoziativität festgelegt wird, indem Sie Klammern verwenden. Beispielsweise wird 2 + 3 * 2 gewöhnlich als 8 ausgewertet, da Multiplikationsoperatoren Vorrang gegenüber additiven Operatoren besitzen. Wenn Sie jedoch den Ausdruck als (2 + 3) * 2 schreiben, wird die Addition vor der Multiplikation ausgewertet, und das Ergebnis ist 10. Die folgenden Beispiele veranschaulichen die Auswertungsreihenfolge der in Klammern gesetzten Ausdrücke. Wie in den vorherigen Beispielen werden die Operanden ausgewertet, bevor der Operator angewendet wird.
Anweisung |
Reihenfolge der Auswertung |
|---|---|
a = (b + c) * d |
a, b, c, +, d, *, = |
a = b - (c + d) |
a, b, c, d, +, -, = |
a = (b + c) * (d - e) |
a, b, c, +, d, e, -, *, = |
Überladen von Operatoren
Sie können das Verhalten der Operatoren für benutzerdefinierte Klassen und Strukturen ändern. Dieser Prozess wird als Operatorüberladung bezeichnet. Weitere Informationen finden Sie unter Überladbare Operatoren (C#-Programmierhandbuch).
Verwandte Abschnitte
Weitere Informationen finden Sie unter Operatorschlüsselwörter (C#-Referenz) und C#-Operatoren.
Siehe auch
Referenz
Anweisungen, Ausdrücke und Operatoren (C#-Programmierhandbuch)