算術演算子 (C# リファレンス)Arithmetic operators (C# reference)

次の演算子は、数値型のオペランドを使用して算術演算を実行します。The following operators perform arithmetic operations with operands of numeric types:

これらの演算子は、整数浮動小数点のすべての数値型によってサポートされています。Those operators are supported by all integral and floating-point numeric types.

整数型の場合は、これらの演算子 (++ 演算子と -- 演算子を除く) が、intuintlong、および ulong 型に対して定義されます。In the case of integral types, those operators (except the ++ and -- operators) are defined for the int, uint, long, and ulong types. オペランドが他の整数型 (sbytebyteshortushortchar) のときは、それらの値は int 型に変換され、演算の結果もその型になります。When operands are of other integral types (sbyte, byte, short, ushort, or char), their values are converted to the int type, which is also the result type of an operation. オペランドが異なる整数型または浮動小数点型の場合、それらの値は格納されている最も近い型に変換されます (その型が存在する場合)。When operands are of different integral or floating-point types, their values are converted to the closest containing type, if such a type exists. 詳しくは、「C# 言語仕様」の「数値の上位変換」セクションをご覧ください。For more information, see the Numeric promotions section of the C# language specification. ++ 演算子と -- 演算子は、すべての整数数値型と浮動小数点数値型、および char 型に対して定義されます。The ++ and -- operators are defined for all integral and floating-point numeric types and the char type.

インクリメント演算子 ++Increment operator ++

単項インクリメント演算子 ++ は、オペランドを 1 ずつインクリメントします。The unary increment operator ++ increments its operand by 1. このオペランドは、変数、プロパティのアクセス、またはインデクサーのアクセスである必要があります。The operand must be a variable, a property access, or an indexer access.

インクリメント演算子は、後置インクリメント演算子である x++ と、前置インクリメント演算子である++x という 2 つの形式でサポートされます。The increment operator is supported in two forms: the postfix increment operator, x++, and the prefix increment operator, ++x.

後置インクリメント演算子Postfix increment operator

次の例に示すように、x++ の結果は、演算子の "前の" x 値です。The result of x++ is the value of x before the operation, as the following example shows:

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

前置インクリメント演算子Prefix increment operator

次の例に示すように、++x の結果は、演算子の "後ろの" x 値です。The result of ++x is the value of x after the operation, as the following example shows:

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

デクリメント演算子 --Decrement operator --

単項デクリメント演算子 -- は、オペランドを 1 ずつデクリメントします。The unary decrement operator -- decrements its operand by 1. このオペランドは、変数、プロパティのアクセス、またはインデクサーのアクセスである必要があります。The operand must be a variable, a property access, or an indexer access.

デクリメント演算子は、後置デクリメント演算子である x-- と、前置デクリメント演算子である --x という 2 つの形式でサポートされます。The decrement operator is supported in two forms: the postfix decrement operator, x--, and the prefix decrement operator, --x.

後置デクリメント演算子Postfix decrement operator

次の例に示すように、x-- の結果は、演算子の "前の" x 値です。The result of x-- is the value of x before the operation, as the following example shows:

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

前置デクリメント演算子Prefix decrement operator

次の例に示すように、--x の結果は、演算子の "後ろの" x 値です。The result of --x is the value of x after the operation, as the following example shows:

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

単項プラス演算子と単項マイナス演算子Unary plus and minus operators

単項 + 演算子によって、そのオペランドの値が返されます。The unary + operator returns the value of its operand. 単項 - 演算子は、そのオペランドの数値の否定を計算します。The unary - operator computes the numeric negation of its operand.

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

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

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

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

ulong 型は、単項 - 演算子をサポートしません。The ulong type doesn't support the unary - operator.

乗算演算子 *Multiplication operator *

乗算演算子 (*) は、そのオペランドの積を計算します。The multiplication operator * computes the product of its operands:

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

単項 * 演算子は、ポインター間接参照演算子です。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

整数型のオペランドに対する / 演算子の結果は、整数型で、2 つのオペランドの商を 0 方向に丸めたものと等しくなります。For the operands of integer types, the result of the / operator is of an integer type and equals the quotient of the two operands rounded towards zero:

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

2 つのオペランドの商を浮動小数点数として取得するには、floatdouble、または decimal 型を使います。To obtain the quotient of the two operands as a floating-point number, use the float, double, or decimal type:

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

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

浮動小数点の除算Floating-point division

floatdoubledecimal 型に対する / 演算子の結果は、2 つのオペランドの商となります。For the float, double, and decimal types, the result of the / operator is the quotient of the two operands:

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

オペランドの 1 つが decimal であった場合、もう 1 つのオペランドを floatdouble にすることはできません。floatdouble は暗黙的に decimal に変換できないためです。If one of the operands is decimal, another operand can be neither float nor double, because neither float nor double is implicitly convertible to decimal. float または double オペランドは明示的に 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

整数型のオペランドの場合、a % b の結果は a - (a / b) * b で生成される値になります。For the operands of integer types, the result of a % b is the value produced by a - (a / b) * b. 0 以外の剰余の符号は、次の例で示されるように、左側のオペランドの符号と同じになります。The sign of the non-zero remainder is the same as that of the left-hand operand, as the following example shows:

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

Math.DivRem メソッドを使用して、整数除算と剰余の結果の両方を計算します。Use the Math.DivRem method to compute both integer division and remainder results.

浮動小数点の剰余Floating-point remainder

float オペランドと double オペランドの場合、有限の xyx % y の結果は、次のような値 z となります。For the float and double operands, the result of x % y for the finite x and y is the value z such that

  • z の符号は、0 以外の場合、x の符号と同じになります。The sign of z, if non-zero, is the same as the sign of x.
  • z の絶対値は、|x| - n * |y| で生成される値となります。n は、|x| / |y| 以下で最も大きい整数であり、|x||y| はそれぞれ、xy の絶対値です。The absolute value of z is the value produced by |x| - n * |y| where n is the largest possible integer that is less than or equal to |x| / |y| and |x| and |y| are the absolute values of x and y, respectively.

注意

剰余を計算するこの手法は、整数オペランドに使用される手法に類似していますが、IEEE 754 の仕様とは異なります。This method of computing the remainder is analogous to that used for integer operands, but different from the IEEE 754 specification. IEEE 754 の仕様に準拠する剰余演算が必要な場合、Math.IEEERemainder メソッドを使用してください。If you need the remainder operation that complies with the IEEE 754 specification, use the Math.IEEERemainder method.

無限オペランドがある % 演算子の動作については、C# 言語仕様に関するページの「剰余演算」セクションを参照してください。For information about the behavior of the % operator with non-finite operands, see the Remainder operator section of the C# language specification.

decimal オペランドの場合、剰余演算子 %System.Decimal 型の剰余演算子に等しくなります。For the decimal operands, the remainder operator % is equivalent to the remainder operator of the System.Decimal type.

次の例では、浮動小数点オペランドを使用した剰余演算子の動作を示しています。The following example demonstrates the behavior of the remainder operator with floating-point operands:

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

加算演算子 +Addition operator +

加算演算子 + は、そのオペランドの合計を計算します。The addition operator + computes the sum of its operands:

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

文字列連結とデリゲートの組み合わせにも、+ 演算子を使用できます。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 its right-hand operand from its left-hand operand:

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

デリゲートの削除には、- 演算子を使用することもできます。You can also use the - operator for delegate removal. 詳細については、「- および -= 演算子」の記事を参照してください。For more information, see the - and -= operators article.

複合代入。Compound assignment

2 項演算子 op の場合、フォームの複合代入式For a binary operator op, a compound assignment expression of the form

x op= y

上記の式は、次の式と同じです。is equivalent to

x = x op y

ただし、x が評価されるのは 1 回だけです。except that x is only evaluated once.

次の例は、算術演算子を使用した複合代入の使用方法を示しています。The following example demonstrates the usage of compound assignment with arithmetic operators:

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

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

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

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

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

数値の上位変換のため、op 演算の結果は、x の型 T に暗黙的に変換できない可能性があります。Because of numeric promotions, the result of the op operation might be not implicitly convertible to the type T of x. そのような場合、op が定義済みの演算子であり、演算の結果が x の型 T に明示的に変換できる場合、x op= y の形式の複合代入式は、x が 1 回だけ評価される点を除き、x = (T)(x op y) と等価です。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:

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

イベントのサブスクリプションとサブスクリプションの解除には、+= 演算子と -= 演算子もそれぞれ使用できます。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 starting from the highest precedence to the lowest:

  • 後置インクリメント演算子 x++ と後置デクリメント演算子 x--Postfix increment x++ and decrement x-- operators
  • 前置インクリメント演算子 ++x とデクリメント演算子 --xおよび単項演算子 +-Prefix increment ++x and decrement --x and unary + and - operators
  • 乗算演算子 */%Multiplicative *, /, and % operators
  • 加法 + および - 演算子Additive + and - operators

2 項算術演算子は左結合です。Binary arithmetic operators are left-associative. つまり、優先度が同じ演算子は、左から右に評価されます。That is, operators with the same precedence level are evaluated from left to right.

演算子の優先順位と結合規則によって定められた評価の順序を変更するには、かっこ () を使用します。Use parentheses, (), to change the order of evaluation imposed by operator precedence and associativity.

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

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

優先度順に並べられた C# 演算子の完全な一覧については、C# 演算子に関する記事の「演算子の優先順位」セクションを参照してください。For the complete list of C# operators ordered by precedence level, see the Operator precedence section of the C# operators article.

算術オーバーフローと 0 による除算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

0 による整数除算では、常に DivideByZeroException がスローされます。Integer division by zero always throws a DivideByZeroException.

整数の算術オーバーフローの場合、オーバーフロー チェック コンテキスト (checked または unchecked) が結果の動作を制御します。In case of integer arithmetic overflow, an overflow checking context, which can be checked or unchecked, controls the resulting behavior:

  • checked コンテキストでは、定数式でオーバーフローが発生すると、コンパイル時エラーが発生します。In a checked context, if overflow happens in a constant expression, a compile-time error occurs. それ以外の場合は、実行時に演算が実行されると OverflowException がスローされます。Otherwise, when the operation is performed at run time, an OverflowException is thrown.
  • unchecked コンテキストでは、結果の格納先の型に収まらない上位ビットが破棄されて、結果が切り詰められます。In an unchecked context, the result is truncated by discarding any high-order bits that don't fit in the destination type.

checked と unchecked のステートメントとともに、checked 演算子と unchecked 演算子を使用して、式が評価されるオーバーフロー チェック コンテキストを制御することができます。Along with the checked and unchecked statements, you can use the checked and unchecked operators to control the overflow checking context, in which an expression is evaluated:

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

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

既定では、算術演算は unchecked コンテキストで発生します。By default, arithmetic operations occur in an unchecked context.

浮動小数点演算のオーバーフローFloating-point arithmetic overflow

float 型とdouble 型を使用した算術演算では、例外はスローされません。Arithmetic operations with the float and double types never throw an exception. これらの型を使用した算術演算の結果は、無限および数値ではないことを表す特殊な値のいずれかになる可能性があります。The result of arithmetic operations with those types can be one of special values that represent infinity and not-a-number:

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

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

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

decimal 型のオペランドの場合、算術オーバーフローは常に OverflowException をスローし、0 による除算は常に DivideByZeroException をスローします。For the operands of the decimal type, arithmetic overflow always throws an OverflowException and division by zero always throws a DivideByZeroException.

丸め誤差Round-off errors

実数の浮動小数点表記と浮動小数点演算の一般的な制限事項により、浮動小数点型を使った計算で丸め誤差が生じる可能性があります。Because of general limitations of the floating-point representation of real numbers and floating-point arithmetic, round-off errors might occur in calculations with floating-point types. つまり、式の生成された結果が、予期した数学的結果と異なる場合があります。That is, the produced result of an expression might differ from the expected mathematical result. 次の例は、こうしたいくつかのケースを示しています。The following example demonstrates several such cases:

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

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

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

詳細については、System.DoubleSystem.Single、または System.Decimal の参照ページの解説を参照してください。For more information, see remarks at the System.Double, System.Single, or System.Decimal reference pages.

演算子のオーバーロード可/不可Operator overloadability

ユーザー定義型は、単項算術演算子 (++--+-) と 2 項算術演算子 (*/%+-) をオーバーロードできます。A user-defined type can overload the unary (++, --, +, and -) and binary (*, /, %, +, and -) arithmetic operators. 2 項演算子をオーバーロードすると、対応する複合代入演算子も暗黙的にオーバーロードされます。When a binary operator is overloaded, the corresponding compound assignment operator is also implicitly overloaded. ユーザー定義型は、複合代入演算子を明示的にオーバーロードすることはできません。A user-defined type cannot explicitly overload a compound assignment operator.

C# 言語仕様C# language specification

詳細については、「C# 言語仕様」の次のセクションを参照してください。For more information, see the following sections of the C# language specification:

関連項目See also