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 sein, der aus beliebig langem Code zusammengesetzt ist, und kann eine beliebige Anzahl von Unterausdrücken enthalten. In einem Ausdruck mit mehreren Operatoren wird die Reihenfolge, in der die Operatoren angewendet werden, von der Operatorrangfolge, der Assoziativität und von Klammern bestimmt.
Jeder Operator verfügt über einen definierten Vorrang. In einem Ausdruck, der mehrere Operatoren mit verschiedenen 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 Rangfolge aufgelistet.
Primäre Operatoren
Ausdruck |
Beschreibung |
---|---|
x.y |
Memberzugriff |
f(x) |
Methoden- und Delegataufruf |
a[x] |
Array- und Indexerzugriff |
x++ |
Postinkrement |
x-- |
Postdekrement |
new T(...) |
Objekt- und Delegaterstellung |
new T(...){...} |
Objekterstellung mit Initialisierern. Siehe Objekt- und Auflistungsinitialisierer (C#-Programmierhandbuch). |
new {...} |
Anonymer Objektinitialisierer. Siehe Anonyme Typen (C#-Programmierhandbuch). |
new T[...] |
Arrayerstellung. Siehe Arrays (C#-Programmierhandbuch). |
typeof(T) |
Abrufen des System.Type-Objekts für T |
checked(x) |
Auswerten von Ausdrücken in geprüftem Kontext |
unchecked(x) |
Auswerten von Ausdrücken in nicht geprüftem Kontext |
default (T) |
Abrufen des Standardwerts vom Typ T |
delegate {} |
Anonyme Funktion (anonyme Methode) |
Unäre Operatoren
Ausdruck |
Beschreibung |
---|---|
+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 |
Beschreibung |
---|---|
Multiplikation |
|
Division |
|
Rest |
Additive Operatoren
Ausdruck |
Beschreibung |
---|---|
x + y |
Addition, Zeichenfolgenverkettung, Delegatkombination |
x - y |
Subtraktion, Delegatentfernung |
Schiebeoperatoren
Ausdruck |
Beschreibung |
---|---|
x << y |
Linksverschiebung |
x >> y |
Rechtsverschiebung |
Relationale Operatoren und Typoperatoren
Ausdruck |
Beschreibung |
---|---|
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 ungleich T ist. |
Gleichheitsoperatoren
Ausdruck |
Beschreibung |
---|---|
x == y |
Gleich |
x != y |
Ungleich |
Logische, bedingte und NULL-Operatoren
Kategorie |
Ausdruck |
Beschreibung |
---|---|---|
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-Sammeloperator |
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 |
Beschreibung |
---|---|
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;
Ein weiteres Beispiel für einen rechtsassoziativen Operator ist der ternäre Operator (?:). Die meisten binäre 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, -, *, = |
Operatorüberladung
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)