Arithmetische Operatoren (C#-Referenz)Arithmetic operators (C# reference)

Die folgenden Operatoren führen arithmetische Operationen mit numerischen Typen aus:The following operators perform arithmetic operations with numeric types:

Diese Operatoren unterstützen alle numerischen Ganzzahl- und Gleitkomma-Typen.Those operators support all integral and floating-point numeric types.

Inkrementoperator ++Increment operator ++

Der unäre Inkrementoperator (++) erhöht seinen Operanden um 1.The unary increment operator ++ increments its operand by 1. Der Operand muss eine Variable, ein Eigenschaftenzugriff oder ein Indexerzugriff sein.The operand must be a variable, a property access, or an indexer access.

Der Inkrementoperator wird in zwei Formen unterstützt: als Postfix-Inkrementoperator x++ und als Präfix-Inkrementoperator ++x.The increment operator is supported in two forms: the postfix increment operator, x++, and the prefix increment operator, ++x.

Postfix-Operator für InkrementPostfix increment operator

Das Ergebnis von x++ ist der Wert von x vor dem Vorgang, wie das folgende Beispiel zeigt:The result of x++ is the value of x before the operation, as the following example shows:

int i = 3;
Console.WriteLine(i);   // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i);   // output: 4

Präfixinkrement-OperatorPrefix increment operator

Das Ergebnis von ++x ist der Wert von x nach dem Vorgang, wie das folgende Beispiel zeigt:The result of ++x is the value of x after the operation, as the following example shows:

double a = 1.5;
Console.WriteLine(a);   // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a);   // output: 2.5

Dekrementoperator --Decrement operator --

Der unäre Dekrementoperator -- verringert seinen Operanden um 1.The unary decrement operator -- decrements its operand by 1. Der Operand muss eine Variable, ein Eigenschaftenzugriff oder ein Indexerzugriff sein.The operand must be a variable, a property access, or an indexer access.

Der Dekrementoperator wird in zwei Formen unterstützt: als Postfix-Dekrementoperator x-- und als Präfix-Dekrementoperator --x.The decrement operator is supported in two forms: the postfix decrement operator, x--, and the prefix decrement operator, --x.

Postfix-Operator für DekrementPostfix decrement operator

Das Ergebnis von x-- ist der Wert von x vor dem Vorgang, wie das folgende Beispiel zeigt:The result of x-- is the value of x before the operation, as the following example shows:

int i = 3;
Console.WriteLine(i);   // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i);   // output: 2

Präfix-DekrementoperatorPrefix decrement operator

Das Ergebnis von --x ist der Wert von x nach dem Vorgang, wie das folgende Beispiel zeigt:The result of --x is the value of x after the operation, as the following example shows:

double a = 1.5;
Console.WriteLine(a);   // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a);   // output: 0.5

Unäre Plus- und MinusoperatorenUnary plus and minus operators

Der unäre +-Operator gibt den Wert seines Operanden zurück.The unary + operator returns the value of its operand. Der unäre --Operator berechnet die numerische Negation des Operanden.The unary - operator computes the numeric negation of its operand.

Console.WriteLine(+4);     // output: 4

Console.WriteLine(-4);     // output: -4
Console.WriteLine(-(-4));  // output: 4

uint a = 5;
var b = -a;
Console.WriteLine(b);            // output: -5
Console.WriteLine(b.GetType());  // output: System.Int64

Console.WriteLine(-double.NaN);  // output: NaN

Der unäre --Operator unterstützt nicht den ulong-Typ.The unary - operator doesn't support the ulong type.

Multiplikationsoperator *Multiplication operator *

Der Multiplikationsoperator * berechnet das Produkt seiner Operanden:The multiplication operator * computes the product of its operands:

Console.WriteLine(5 * 2);         // output: 10
Console.WriteLine(0.5 * 2.5);     // output: 1.25
Console.WriteLine(0.1m * 23.4m);  // output: 2.34

Der unäre *-Operator ist der Zeigerdereferenzierungsoperator.The unary * operator is the pointer indirection operator.

Divisionsoperator /Division operator /

Der Divisionsoperator / dividiert den linken Operanden durch den rechten Operanden.The division operator / divides its left-hand operand by its right-hand operand.

GanzzahldivisionInteger division

Für die Operanden von Ganzzahltypen weist das Ergebnis des /-Operators einen Ganzzahltyp auf und ist gleich dem Quotienten der beiden Operanden, gerundet auf Null:For the operands of integer types, the result of the / operator is of an integer type and equals the quotient of the two operands rounded towards zero:

Console.WriteLine(13 / 5);    // output: 2
Console.WriteLine(-13 / 5);   // output: -2
Console.WriteLine(13 / -5);   // output: -2
Console.WriteLine(-13 / -5);  // output: 2

Um den Quotienten der beiden Operanden als Gleitkommazahl abzurufen, verwenden Sie den Typ float, double oder decimal:To obtain the quotient of the two operands as a floating-point number, use the float, double, or decimal type:

Console.WriteLine(13 / 5.0);       // output: 2.6

int a = 13;
int b = 5;
Console.WriteLine((double)a / b);  // output: 2.6

GleitkommadivisionFloating-point division

Für die Typen float, double oder decimal ist das Ergebnis des /-Operators der Quotient der beiden Operanden:For the float, double, and decimal types, the result of the / operator is the quotient of the two operands:

Console.WriteLine(16.8f / 4.1f);   // output: 4.097561
Console.WriteLine(16.8d / 4.1d);   // output: 4.09756097560976
Console.WriteLine(16.8m / 4.1m);   // output: 4.0975609756097560975609756098

Wenn einer der Operanden decimal lautet, kann ein anderer Operand weder float noch double sein, weil weder float noch double implizit zu decimal konvertiert werden können.If one of the operands is decimal, another operand can be neither float nor double, because neither float nor double is implicitly convertible to decimal. Sie müssen den Operanden float oder double explizit zum Typ decimal konvertieren.You must explicitly convert the float or double operand to the decimal type. Weitere Informationen zu impliziten Konvertierungen zwischen numerischen Typen finden Sie unter Tabelle für implizite numerische Konvertierungen.For more information about implicit conversions between numeric types, see Implicit numeric conversions table.

Restoperator %Remainder operator %

Der Restoperator % berechnet den Rest nach der Division seines linken Operanden durch den rechten Operanden.The remainder operator % computes the remainder after dividing its left-hand operand by its right-hand operand.

Ganzzahliger RestInteger remainder

Für Operanden von Ganzzahltypen entspricht das Ergebnis von a % b dem von a - (a / b) * b erzeugten Wert.For the operands of integer types, the result of a % b is the value produced by a - (a / b) * b. Das Vorzeichen des Rests, der ungleich 0 (null) ist, ist wie im folgenden Beispiel gezeigt identisch mit dem des linken Operanden:The sign of the non-zero remainder is the same as that of the left-hand operand, as the following example shows:

Console.WriteLine(5 % 4);   // output: 1
Console.WriteLine(5 % -4);  // output: 1
Console.WriteLine(-5 % 4);  // output: -1
Console.WriteLine(-5 % -4); // output: -1

Verwenden Sie die Math.DivRem-Methode, wenn Sie sowohl Ganzzahldivision als auch Restergebnisse berechnen möchten.Use the Math.DivRem method to compute both integer division and remainder results.

GleitkommarestFloating-point remainder

Für die Operanden float und double entspricht das Ergebnis von x % y für die endlichen Werte x und y dem Wert z, sodass:For the float and double operands, the result of x % y for the finite x and y is the value z such that

  • das Vorzeichen von z dem Vorzeichen von x entspricht, sofern der Wert nicht 0 (null) ist.The sign of z, if non-zero, is the same as the sign of x.
  • der absolute Wert von z dem von |x| - n * |y| erzeugten Wert entspricht, wobei n der größtmöglichen Ganzzahl entspricht, die kleiner oder gleich |x| / |y| ist. Hierbei sind |x| und |y| jeweils die absoluten Werte von x und y.The absolute value of z is the value produced by |x| - n * |y| where n is the largest possible integer that is less than or equal to |x| / |y| and |x| and |y| are the absolute values of x and y, respectively.

Hinweis

Diese Methode zum Berechnen des Rests ist analog zu der Methode, die für ganzzahlige Operanden verwendet wird, unterscheidet sich jedoch von der Norm IEEE 754.This method of computing the remainder is analogous to that used for integer operands, but differs from the IEEE 754. Wenn Sie den Restvorgang benötigen, der der Norm IEEE 754 entspricht, verwenden Sie die Methode Math.IEEERemainder.If you need the remainder operation that complies with the IEEE 754, use the Math.IEEERemainder method.

Weitere Informationen zum Verhalten des %-Operators bei nicht begrenzten Operanden finden Sie im Abschnitt Restoperator der C#-Sprachspezifikation.For information about the behavior of the % operator with non-finite operands, see the Remainder operator section of the C# language specification.

Der Restoperator % entspricht für die decimal-Operanden dem Restoperator vom Typ System.Decimal.For the decimal operands, the remainder operator % is equivalent to the remainder operator of the System.Decimal type.

Im folgenden Beispiel wird das Verhalten des Restoperators mit Gleitkommaoperanden veranschaulicht:The following example demonstrates the behavior of the remainder operator with floating-point operands:

Console.WriteLine(-5.2f % 2.0f); // output: -1.2
Console.WriteLine(5.9 % 3.1);    // output: 2.8
Console.WriteLine(5.9m % 3.1m);  // output: 2.8

Additionsoperator +Addition operator +

Der Additionsoperator + berechnet die Summe der Operanden:The addition operator + computes the sum of its operands:

Console.WriteLine(5 + 4);       // output: 9
Console.WriteLine(5 + 4.3);     // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3

Der +-Operator kann auch für die Zeichenfolgenverkettung und Delegatkombination verwendet werden.You also can use the + operator for string concatenation and delegate combination. Weitere Informationen finden Sie im Artikel zu den Operatoren + und +=.For more information, see the + and += operators article.

Subtraktionsoperator -Subtraction operator -

Der Subtraktionsoperator - subtrahiert den rechten Operanden vom linken:The subtraction operator - subtracts its right-hand operand from its left-hand operand:

Console.WriteLine(47 - 3);      // output: 44
Console.WriteLine(5 - 4.3);     // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2

Der --Operator kann auch für die Delegatentfernung verwendet werden.You also can use the - operator for delegate removal. Weitere Informationen finden Sie im Artikel zum --Operator.For more information, see the - operator article.

VerbundzuweisungCompound assignment

Bei einem binären Operator op entspricht ein Verbundzuweisungsausdruck der FormFor a binary operator op, a compound assignment expression of the form

x op= y

für die folgende Syntax:is equivalent to

x = x op y

außer dass x nur einmal überprüft wird.except that x is only evaluated once.

Im folgenden Beispiel wird die Verwendung von Verbundzuweisungen mit arithmetischen Operatoren veranschaulicht:The following example demonstrates the usage of compound assignment with arithmetic operators:

int a = 5;
a += 9;
Console.WriteLine(a);  // output: 14

a -= 4;
Console.WriteLine(a);  // output: 10

a *= 2;
Console.WriteLine(a);  // output: 20

a /= 4;
Console.WriteLine(a);  // output: 5

a %= 3;
Console.WriteLine(a);  // output: 2

Aufgrund von numerischen Höherstufungen kann das Ergebnis der Operation op ggf. nicht implizit in den Typ T von x konvertiert werden.Because of numeric promotions, the result of the op operation might be not implicitly convertible to the type T of x. In diesem Fall gilt Folgendes: Wenn op ein vordefinierter Operator ist und das Ergebnis der Operation explizit in den Typ T von x konvertiert werden kann, entspricht ein Verbundzuweisungsausdruck der Form x op= y dem Ausdruck x = (T)(x op y). Der einzige Unterschied ist, dass x nur einmal ausgewertet wird.In such a case, if op is a predefined operator and the result of the operation is explicitly convertible to the type T of x, a compound assignment expression of the form x op= y is equivalent to x = (T)(x op y), except that x is only evaluated once. Das folgende Beispiel veranschaulicht dieses Verhalten:The following example demonstrates that behavior:

byte a = 200;
byte b = 100;

var c = a + b;
Console.WriteLine(c.GetType());  // output: System.Int32
Console.WriteLine(c);  // output: 300

a += b;
Console.WriteLine(a);  // output: 44

Die Operatoren += und -= können auch zum Abonnieren von Ereignissen und zum Kündigen von Ereignisabonnements verwendet werden.You also use the += and -= operators to subscribe to and unsubscribe from events. Weitere Informationen finden Sie unter Vorgehensweise: Abonnieren von Ereignissen und Kündigen von Ereignisabonnements.For more information, see How to: subscribe to and unsubscribe from events.

Operatorrangfolge und AssoziativitätOperator precedence and associativity

In der folgenden Liste sind die arithmetischen Operatoren beginnend mit dem höchsten Rangfolgenoperator absteigend sortiert:The following list orders arithmetic operators starting from the highest precedence to the lowest:

  • Postfixinkrementoperator x++ und Postfixdekrementoperator x--Postfix increment x++ and decrement x-- operators
  • Präfixinkrementoperator ++x und Präfixdekrementoperator --x sowie unäre +- und --OperatorenPrefix increment ++x and decrement --x and unary + and - operators
  • Multiplikative Operatoren *, / und %Multiplicative *, /, and % operators
  • Additive Operatoren + und -Additive + and - operators

Binäre arithmetische Operatoren sind linksassoziativ.Binary arithmetic operators are left-associative. Das bedeutet, dass Operatoren mit der gleichen Rangfolgenebene von links nach rechts ausgewertet werden.That is, operators with the same precedence level are evaluated from left to right.

Verwenden Sie Klammern (), wenn Sie die Reihenfolge der Auswertung ändern möchten, die durch Operatorrangfolge und Assoziativität festgelegt wird.Use parentheses, (), to change the order of evaluation imposed by operator precedence and associativity.

Console.WriteLine(2 + 2 * 2);   // output: 6
Console.WriteLine((2 + 2) * 2); // output: 8

Console.WriteLine(9 / 5 / 2);   // output: 0
Console.WriteLine(9 / (5 / 2)); // output: 4

Die vollständige Liste der nach Rangfolgenebene sortierten C#-Operatoren finden Sie unter C#-Operatoren.For the complete list of C# operators ordered by precedence level, see C# operators.

Arithmetischer Überlauf und Division durch 0 (null)Arithmetic overflow and division by zero

Liegt das Ergebnis einer arithmetischen Operation außerhalb des Bereichs möglicher endlicher Werte des betreffenden numerischen Typs, hängt das Verhalten eines arithmetischen Operators vom Typ der Operanden ab.When the result of an arithmetic operation is outside the range of possible finite values of the involved numeric type, the behavior of an arithmetic operator depends on the type of its operands.

Arithmetischer Überlauf bei ganzen ZahlenInteger arithmetic overflow

Division ganzer Zahlen durch Null löst immer eine DivideByZeroException aus.Integer division by zero always throws a DivideByZeroException.

Im Fall eines arithmetischen Überlaufs bei ganzen Zahlen steuert ein Kontext für Überlaufprüfungen, der aktiviert oder deaktiviert (Checked oder Unchecked) sein kann, das resultierende Verhalten:In case of integer arithmetic overflow, an overflow checking context, which can be checked or unchecked, controls the resulting behavior:

  • In einem aktivierten Kontext tritt bei einem Überlauf in einem konstanten Ausdruck ein Kompilierzeitfehler auf.In a checked context, if overflow happens in a constant expression, a compile-time error occurs. Andernfalls wird, wenn die Operation zur Laufzeit ausgeführt wird, eine OverflowException-Ausnahme ausgelöst.Otherwise, when the operation is performed at run time, an OverflowException is thrown.
  • In einem deaktivierten Kontext wird das Ergebnis gekürzt, indem alle höherwertigen Bits verworfen werden, die nicht in den Zieltyp passen.In an unchecked context, the result is truncated by discarding any high-order bits that don't fit in the destination type.

Neben den Anweisungen Checked und Unchecked können Sie mithilfe der checked- und unchecked-Operatoren den Kontext für Überlaufprüfungen steuern, in dem ein Ausdruck ausgewertet wird:Along with the checked and unchecked statements, you can use the checked and unchecked operators to control the overflow checking context, in which an expression is evaluated:

int a = int.MaxValue;
int b = 3;

Console.WriteLine(unchecked(a + b));  // output: -2147483646
try
{
    int d = checked(a + b);
}
catch(OverflowException)
{
    Console.WriteLine($"Overflow occurred when adding {a} to {b}.");
}

Standardmäßig erscheinen arithmetische Operationen in einem unchecked-Kontext.By default, arithmetic operations occur in an unchecked context.

Arithmetischer Überlauf bei GleitkommatypenFloating-point arithmetic overflow

Bei arithmetischen Operationen mit den Typen float und double wird nie eine Ausnahme ausgelöst.Arithmetic operations with the float and double types never throw an exception. Das Ergebnis von arithmetischen Operationen mit diesen Typen können spezielle Werte sein, die unendliche und nicht numerische Zahlen darstellen:The result of arithmetic operations with those types can be one of special values that represent infinity and not-a-number:

double a = 1.0 / 0.0;
Console.WriteLine(a);                    // output: Infinity
Console.WriteLine(double.IsInfinity(a)); // output: True

Console.WriteLine(double.MaxValue + double.MaxValue); // output: Infinity

double b = 0.0 / 0.0;
Console.WriteLine(b);                // output: NaN
Console.WriteLine(double.IsNaN(b));  // output: True

Für Operanden vom Typ decimal löst ein arithmetischer Überlauf immer eine OverflowException-Ausnahme und die Division durch 0 (null) immer eine DivideByZeroException-Ausnahme aus.For the operands of the decimal type, arithmetic overflow always throws an OverflowException and division by zero always throws a DivideByZeroException.

RundungsfehlerRound-off errors

Aufgrund allgemeiner Einschränkungen der Gleitkommadarstellung von reellen Zahlen und arithmetischer Gleitkommaoperatoren können in Berechnungen mit Gleitkommatypen Rundungsfehler auftreten.Because of general limitations of the floating-point representation of real numbers and floating-point arithmetic, the round-off errors might occur in calculations with floating-point types. Das bedeutet, dass das generierte Ergebnis eines Ausdrucks vom erwarteten mathematischen Ergebnis abweichen kann.That is, the produced result of an expression might differ from the expected mathematical result. Im folgenden Beispiel werden einige solcher Fälle dargestellt:The following example demonstrates several such cases:

Console.WriteLine(.41f % .2f); // output: 0.00999999

double a = 0.1;
double b = 3 * a;
Console.WriteLine(b == 0.3);   // output: False
Console.WriteLine(b - 0.3);    // output: 5.55111512312578E-17

decimal c = 1 / 3.0m;
decimal d = 3 * c;
Console.WriteLine(d == 1.0m);  // output: False
Console.WriteLine(d);          // output: 0.9999999999999999999999999999

Weitere Informationen finden Sie in den Hinweisen auf den Referenzseiten zu System.Double, System.Single oder System.Decimal.For more information, see remarks at System.Double, System.Single, or System.Decimal reference pages.

OperatorüberladbarkeitOperator overloadability

Ein benutzerdefinierter Typ kann die unären (++, --, + und -) und binären (*, /, %, + und -) arithmetischen Operatoren überladen.A user-defined type can overload the unary (++, --, +, and -) and binary (*, /, %, +, and -) arithmetic operators. Wenn ein binärer Operator überladen ist, wird der zugehörige Verbundzuweisungsoperator implizit auch überladen.When a binary operator is overloaded, the corresponding compound assignment operator is also implicitly overloaded. Ein benutzerdefinierter Typ kann einen Verbundzuweisungsoperator nicht explizit überladen.A user-defined type cannot explicitly overload a compound assignment operator.

C#-SprachspezifikationC# language specification

Weitere Informationen finden Sie in den folgenden Abschnitten der C#-Sprachspezifikation:For more information, see the following sections of the C# language specification:

Siehe auchSee also