The following operators perform arithmetic operations with operands of numeric types:
- Unary
++(increment),--(decrement),+(plus), and-(minus) operators - Binary
*(multiplication),/(division),%(remainder),+(addition), and-(subtraction) operators
All integral and floating-point numeric types support these operators.
The int, uint, long, and ulong types define all these operators. The other integral types (sbyte, byte, short, ushort, and char) define only the ++ and -- operators. For the other operators, if you use the integral types sbyte, byte, short, ushort, or char as operands, the values are converted to the int type and the result type is int. If the operands are different integral or floating-point types, their values are converted to the closest containing type, if such a type exists. For more information, see the Numeric promotions section of the C# language specification. The ++ and -- operators are defined for all integral and floating-point numeric types and the char type. The result type of a compound assignment expression is the type of the left-hand operand.
ms.custom: "updateeachrelease"
The C# language reference documents the most recently released version of the C# language. It also contains initial documentation for features in public previews for the upcoming language release.
The documentation identifies any feature first introduced in the last three versions of the language or in current public previews.
Increment operator ++
The unary increment operator ++ increments its operand by 1. The operand must be a variable, a property access, or an indexer access.
The increment operator is supported in two forms: the postfix increment operator, x++, and the prefix increment operator, ++x.
Postfix increment operator
The result of x++ is the value of x before the operation, as the following example shows:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csPostfixIncrement
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}Prefix increment operator
The result of ++x is the value of x after the operation, as the following example shows:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csPrefixIncrement
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}Decrement operator --
The unary decrement operator -- decrements its operand by 1. The operand must be a variable, a property access, or an indexer access.
The decrement operator is available in two forms: the postfix decrement operator, x--, and the prefix decrement operator, --x.
Postfix decrement operator
The result of x-- is the value of x before the operation, as the following example shows:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csPostfixDecrement
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}Prefix decrement operator
The result of --x is the value of x after the operation, as the following example shows:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csPrefixDecrement
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}Unary plus and minus operators
The unary + operator returns the value of its operand. The unary - operator computes the numeric negation of its operand.
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csUnaryPlusAndMinus
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}The ulong type doesn't support the unary - operator.
Multiplication operator *
The multiplication operator * computes the product of its operands:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csMultiplication
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}The unary * operator is the pointer indirection operator.
Division operator /
The division operator / divides its left-hand operand by its right-hand operand.
Integer division
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 toward zero:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csIntegerDivision
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}To get the quotient of the two operands as a floating-point number, use the float, double, or decimal type:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csIntegerAsFloatingPointDivision
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}Floating-point division
For the float, double, and decimal types, the / operator returns the quotient of the two operands:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csFloatingPointDivision
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}If one operand is decimal, the other operand can't be float or double, because neither float nor double has an implicit conversion to decimal. You must explicitly convert the float or double operand to the decimal type. For more information about conversions between numeric types, see Built-in numeric conversions.
Remainder operator %
The remainder operator % computes the remainder after dividing its left-hand operand by its right-hand operand.
Integer remainder
For operands of integer types, the result of a % b is the value produced by $a - \frac{a}{b} \times b$. The sign of the non-zero remainder matches the sign of the left-hand operand, as the following example shows:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csIntegerRemainder
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}Use the System.Math.DivRem method to compute both integer division and remainder results.
Floating-point remainder
For the float and double operands, the result of x % y for the finite x and y is the value z such that
- The sign of
z, if non-zero, matches the sign ofx. - The absolute value of
zcomes from the calculation $|x| - n \times |y|$, wherenis the largest integer less than or equal to $\frac{|x|}{|y|}$. Here, $|x|$ and $|y|$ represent the absolute values ofxandy, respectively.
For information about the behavior of the % operator with non-finite operands, see the Remainder operator section of the C# language specification.
For decimal operands, the remainder operator % works the same as the remainder operator of the System.Decimal type.
The following example demonstrates how the remainder operator behaves with floating-point operands:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csFloatingPointRemainder
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}Addition operator +
The addition operator + computes the sum of its operands:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csAddition
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}You can also use the + operator for string concatenation and delegate combination. For more information, see the + and += operators article.
Subtraction operator -
The subtraction operator - subtracts the right-hand operand from the left-hand operand:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csSubtraction
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}You can also use the - operator to remove a delegate. For more information, see the - and -= operators.
Compound assignment
For a binary operator op, a compound assignment expression of the form
x op= yIs equivalent to
x = x op yExcept that x is only evaluated once.
The following example demonstrates the usage of compound assignment with arithmetic operators:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csCompoundAssignment
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}Because of numeric promotions, the result of the op operation might not be implicitly convertible to the type T of x. 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. The following example demonstrates that behavior:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csCompoundAssignmentWithCast
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}In the preceding example, value 44 is the result of converting value 300 to the byte type.
You also use the += and -= operators to subscribe to and unsubscribe from an event, respectively. For more information, see How to subscribe to and unsubscribe from events.
Operator precedence and associativity
The following list orders arithmetic operators in groups from highest precedence to lowest precedence:
- (Primary) operators: postfix increment
x++and decrementx--operators. - (Unary) operators: prefix increment
++xand decrement--xoperators, and unary+and-operators. - (Multiplicative) operators:
*,/, and%operators. - (Additive) operators: binary
+and-operators.
Binary arithmetic operators are left-associative. That is, the compiler evaluates operators with the same precedence level from left to right.
Use parentheses, (), to change the order of evaluation imposed by operator precedence and associativity.
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csPrecedenceAndAssociativity
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}For the complete list of C# operators ordered by precedence level, see the Operator precedence section of the C# operators article.
Arithmetic overflow and division by zero
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.
Integer arithmetic overflow
Integer division by zero always throws a System.DivideByZeroException.
If integer arithmetic overflow occurs, the overflow-checking context, which can be checked or unchecked, controls the resulting behavior:
- In a checked context, if overflow happens in a constant expression, a compile-time error occurs. Otherwise, when the operation is performed at run time, an System.OverflowException is thrown.
- In an unchecked context, the result is truncated by discarding any high-order bits that don't fit in the destination type.
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:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csCheckedUnchecked
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}By default, arithmetic operations occur in an unchecked context.
Floating-point arithmetic overflow
Arithmetic operations by using the float and double types never throw an exception. The result of arithmetic operations using those types can be one of special values that represent infinity and not-a-number:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csFloatingPointOverflow
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}For the operands of the decimal type, arithmetic overflow always throws an System.OverflowException. Division by zero always throws a System.DivideByZeroException.
Round-off errors
Because of general limitations in the floating-point representation of real numbers and floating-point arithmetic, round-off errors can occur in calculations that use floating-point types. The result of an expression might differ from the expected mathematical result. The following example demonstrates several such cases:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csRoundOffErrors
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}For more information, see the remarks at the System.Double, System.Single, or System.Decimal reference pages.
Operator overloadability
You can overload the unary (++, --, +, and -) and binary (*, /, %, +, and -) arithmetic operators for a user-defined type. When you overload a binary operator, you also implicitly overload the corresponding compound assignment operator. Starting with C# 14, a user-defined type can explicitly overload the compound assignment operators (op=) to provide a more efficient implementation. Typically, a type overloads these operators because the value can be updated in place, rather than allocating a new instance to store the result of the operation. If a type doesn't provide an explicit overload, the compiler generates the implicit overload.
User-defined checked operators
When you overload an arithmetic operator, you can use the checked keyword to define the checked version of that operator. The following example shows how to do that:
sample · csharpdocs/csharp/language-reference/operators/snippets/shared/ArithmeticOperators.csCheckedOperator
namespace operators;
public static class ArithmeticOperators
{
public static void Examples()
{
Console.WriteLine("==== ++ and -- operators");
Increment();
Decrement();
Console.WriteLine("==== Unary + and - operators");
UnaryPlusAndMinus();
Console.WriteLine("==== *, /, %, +, and - operators");
Multiplication();
IntegerDivision();
IntegerAsFloatingPointDivision();
FloatingPointDivision();
IntegerRemainder();
FloatingPointRemainder();
Addition();
Subtraction();
Console.WriteLine("==== Precedence and associativity examples");
PrecedenceAndAssociativity();
Console.WriteLine("==== Compound assignment");
CompoundAssignment();
CompoundAssignmentWithCast();
Console.WriteLine("==== Special cases");
CheckedUnchecked();
IntegerDivisionOverflow();
FloatingPointOverflow();
RoundOffErrors();
}
private static void Increment()
{
// <SnippetPrefixIncrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
// </SnippetPrefixIncrement>
// <SnippetPostfixIncrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
// </SnippetPostfixIncrement>
}
private static void Decrement()
{
// <SnippetPrefixDecrement>
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
// </SnippetPrefixDecrement>
// <SnippetPostfixDecrement>
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
// </SnippetPostfixDecrement>
}
private static void UnaryPlusAndMinus()
{
// <SnippetUnaryPlusAndMinus>
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
// </SnippetUnaryPlusAndMinus>
}
private static void Multiplication()
{
// <SnippetMultiplication>
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
// </SnippetMultiplication>
}
private static void IntegerDivision()
{
// <SnippetIntegerDivision>
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
// </SnippetIntegerDivision>
}
private static void IntegerAsFloatingPointDivision()
{
// <SnippetIntegerAsFloatingPointDivision>
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
// </SnippetIntegerAsFloatingPointDivision>
}
private static void FloatingPointDivision()
{
// <SnippetFloatingPointDivision>
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
// </SnippetFloatingPointDivision>
}
private static void IntegerRemainder()
{
// <SnippetIntegerRemainder>
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
// </SnippetIntegerRemainder>
}
private static void FloatingPointRemainder()
{
// <SnippetFloatingPointRemainder>
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
// </SnippetFloatingPointRemainder>
}
private static void Addition()
{
// <SnippetAddition>
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
// </SnippetAddition>
}
private static void Subtraction()
{
// <SnippetSubtraction>
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
// </SnippetSubtraction>
}
private static void PrecedenceAndAssociativity()
{
// <SnippetPrecedenceAndAssociativity>
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
// </SnippetPrecedenceAndAssociativity>
}
private static void CompoundAssignment()
{
// <SnippetCompoundAssignment>
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
// </SnippetCompoundAssignment>
}
private static void CompoundAssignmentWithCast()
{
// <SnippetCompoundAssignmentWithCast>
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
// </SnippetCompoundAssignmentWithCast>
}
private static void CheckedUnchecked()
{
// <SnippetCheckedUnchecked>
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}.");
}
// </SnippetCheckedUnchecked>
}
private static void IntegerDivisionOverflow()
{
// <SnippetIntegerDivisionOverflow>
int a = int.MinValue;
int b = -1;
try
{
int c = unchecked(a / b);
}
catch (ArithmeticException)
{
Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}
// </SnippetIntegerDivisionOverflow>
}
// <CheckedOperator>
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
// </CheckedOperator>
private static void FloatingPointOverflow()
{
// <SnippetFloatingPointOverflow>
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
// </SnippetFloatingPointOverflow>
}
private static void RoundOffErrors()
{
// <SnippetRoundOffErrors>
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
// </SnippetRoundOffErrors>
}
}When you define a checked operator, you must also define the corresponding operator without the checked modifier. A checked context calls the checked operator, and an unchecked context calls the operator without the checked modifier.
When you define both versions of an operator, their behavior differs only when the result of an operation is too large to represent in the result type as follows:
- A checked operator throws an System.OverflowException.
- An operator without the
checkedmodifier returns an instance representing a truncated result.
For information about the difference in behavior of the built-in arithmetic operators, see the Arithmetic overflow and division by zero section.
You can use the checked modifier only when you overload any of the following operators:
- Unary
++,--, and-operators - Binary
*,/,+, and-operators - Compound assignment
*=,/=,+=, and-=operators (C# 14 and later) - Explicit conversion operators
C# language specification
For more information, see the following sections of the C# language specification:
- Postfix increment and decrement operators
- Prefix increment and decrement operators
- Unary plus operator
- Unary minus operator
- Multiplication operator
- Division operator
- Remainder operator
- Addition operator
- Subtraction operator
- Compound assignment
- The checked and unchecked operators
- Numeric promotions
- User defined compound assignment