C#の除算を完全解説｜整数同士で小数にならない理由と余り・型変換の使い方

はじめに

C#で計算処理を書くとき、除算、つまり割り算はとてもよく使います。たとえば、平均点を求める、割合を計算する、ページ数を出す、時間を分や秒に分解するなど、実務でも学習でも欠かせない処理です。

しかし、C#の除算では初心者がつまずきやすいポイントがあります。特に多いのが、次のような疑問です。

「10 / 3の結果が3.333...にならないのはなぜ？」
「int同士で割り算すると小数点以下が消えるのはなぜ？」
「割り算の余りはどうやって求めるの？」
「doubleやdecimalに変換するタイミングはいつ？」

C#では、除算の結果は使う数値型によって変わります。整数同士で割るのか、小数型を含めて割るのかによって、結果が整数になる場合もあれば、小数になる場合もあります。

この記事では、C#の除算について、基本の「/」演算子から、整数除算、小数を得る方法、余りを求める「%」演算子、型変換、0除算、丸め処理、実践的なサンプルまで順番に解説します。

1. C#の除算とは？まず押さえる基本

C#の除算を理解するには、まず「どの演算子を使うのか」と「どの型で計算しているのか」を押さえる必要があります。

同じ割り算でも、int同士で計算する場合と、doubleやdecimalを使う場合では結果が変わります。

1-1. C#で割り算に使う「/」演算子

C#で割り算を行うには、/演算子を使います。

C#
int result = 10 / 2;
Console.WriteLine(result);

実行結果は次のようになります。

C#
5

10 / 2は、10を2で割る処理です。これは一般的な算数の割り算と同じです。

小数を含む計算もできます。

C#
double result = 10.0 / 4.0;
Console.WriteLine(result);

実行結果は次のとおりです。

C#
2.5

C#では、このように/演算子を使って除算を行います。ただし、結果が整数になるか小数になるかは、計算に使う値の型によって決まります。

1-2. 除算で使う主な数値型（int・double・float・decimal）

C#の除算でよく使う数値型には、次のようなものがあります。

C#
int number = 10;
double doubleValue = 10.5;
float floatValue = 10.5f;
decimal decimalValue = 10.5m;

intは整数を扱う型です。小数点以下を持つことはできません。

C#
int a = 10;
int b = 3;

doubleは小数を扱う型で、科学技術計算や一般的な小数計算でよく使われます。

C#
double a = 10.0;
double b = 3.0;

floatも小数を扱う型ですが、doubleより精度が低く、主にメモリ使用量を抑えたい場合やゲーム開発などで使われます。

C#
float a = 10.0f;
float b = 3.0f;

decimalは高精度な10進数計算に向いています。金額計算など、誤差をできるだけ避けたい場面でよく使われます。

C#
decimal price = 1000m;
decimal taxRate = 0.1m;

C#の除算では、このような型の違いが非常に重要です。

1-3. C#の除算結果は「使う型」によって変わる

C#では、同じ10 / 3でも、型によって結果が変わります。

C#
Console.WriteLine(10 / 3);
Console.WriteLine(10.0 / 3);
Console.WriteLine(10m / 3m);

実行結果は次のようになります。

C#
3
3.3333333333333335
3.3333333333333333333333333333

10 / 3は整数同士の除算なので、結果も整数になります。そのため、小数点以下は切り捨てられて3になります。

一方、10.0 / 3はdoubleを含む除算なので、結果は小数になります。

10m / 3mはdecimal同士の除算なので、より10進数に適した精度で計算されます。

このように、C#の除算では「割る数」と「割られる数」の型によって結果が決まります。

2. 整数同士の除算で小数にならない理由

C#の除算で特に重要なのが、整数同士の割り算です。

int同士で割り算をすると、数学的には小数になる場合でも、C#の結果は整数になります。

2-1. int同士の割り算は結果もintになる

次のコードを見てください。

C#
int a = 10;
int b = 3;

int result = a / b;

Console.WriteLine(result);

実行結果は次のようになります。

C#
3

10 ÷ 3 は数学的には 3.333... ですが、C#ではint同士の除算なので、結果もintになります。

int型は整数しか扱えないため、小数点以下は保持できません。その結果、3.333...ではなく3になります。

次のように、結果をdouble型の変数に代入しても同じです。

C#
int a = 10;
int b = 3;

double result = a / b;

Console.WriteLine(result);

実行結果は次のとおりです。

C#
3

resultはdouble型ですが、右辺のa / bが先にint同士の除算として計算されます。その時点で結果は3になります。その後、3がdoubleに変換されるため、3.333...にはなりません。

2-2. 小数点以下は四捨五入ではなく切り捨てられる

整数同士の除算では、小数点以下は四捨五入されるのではなく、切り捨てられます。

C#
Console.WriteLine(5 / 2);
Console.WriteLine(9 / 4);
Console.WriteLine(1 / 2);

実行結果は次のようになります。

C#
2
2
0

5 / 2は2.5ですが、結果は2です。

9 / 4は2.25ですが、結果は2です。

1 / 2は0.5ですが、結果は0です。

つまり、整数除算では小数点以下が残りません。四捨五入して3になったり、1になったりするわけではない点に注意しましょう。

2-3. 10 / 3や5 / 2の実行結果で確認する

実際にいくつかの例で確認してみます。

C#
Console.WriteLine(10 / 3);
Console.WriteLine(5 / 2);
Console.WriteLine(100 / 30);
Console.WriteLine(7 / 7);

実行結果は次のとおりです。

C#
3
2
3
1

それぞれの計算は次のようになります。

C#
10 / 3   // 3.333... → 3
5 / 2    // 2.5      → 2
100 / 30 // 3.333... → 3
7 / 7    // 1        → 1

割り切れる場合はそのまま整数になりますが、割り切れない場合は小数点以下が切り捨てられます。

C#で小数の結果を得たい場合は、int同士で割るのではなく、少なくとも一方をdoubleやdecimalなどの小数型にする必要があります。

2-4. 負の数を割った場合の注意点

負の数を整数除算するときも注意が必要です。

C#の整数除算では、小数部分は0に近づく方向に切り捨てられます。

C#
Console.WriteLine(10 / 3);
Console.WriteLine(-10 / 3);
Console.WriteLine(10 / -3);
Console.WriteLine(-10 / -3);

実行結果は次のようになります。

C#
3
-3
-3
3

数学的に考えると、-10 / 3は約-3.333...です。これを0に近づく方向に切り捨てるため、結果は-3になります。

ここで注意したいのは、Math.Floorとは動きが異なることです。

C#
Console.WriteLine((int)(-10.0 / 3.0));
Console.WriteLine(Math.Floor(-10.0 / 3.0));

実行結果は次のようになります。

C#
-3
-4

(int)へのキャストや整数除算は0に近づく方向に切り捨てます。一方、Math.Floorはより小さい整数方向に丸めます。

正の数では同じ結果になることが多いですが、負の数では違いが出るため注意しましょう。

3. C#で小数の除算結果を得る方法

C#で割り算の結果を小数にしたい場合は、整数同士で除算しないようにする必要があります。

主な方法は次のとおりです。

• どちらか一方をdouble型にする

• 除算前にキャストする

• 数値リテラルに.0を付ける

• decimal型を使う

それぞれ詳しく見ていきましょう。

3-1. どちらか一方をdouble型にする

int同士ではなく、どちらか一方をdouble型にすると、小数の結果を得られます。

C#
int a = 10;
double b = 3;

double result = a / b;

Console.WriteLine(result);

実行結果は次のようになります。

C#
3.3333333333333335

この場合、aはintですが、bがdoubleなので、計算全体がdoubleの除算として扱われます。

次のように、割られる数だけをdoubleにしても同じです。

C#
double a = 10;
int b = 3;

double result = a / b;

Console.WriteLine(result);

実行結果は次のとおりです。

C#
3.3333333333333335

C#では、intとdoubleを一緒に計算すると、intがdoubleに変換されてから計算されます。

3-2. キャストしてから除算する

int型の変数同士を使っている場合は、除算前にどちらかをdoubleへキャストします。

C#
int a = 10;
int b = 3;

double result = (double)a / b;

Console.WriteLine(result);

実行結果は次のようになります。

C#
3.3333333333333335

重要なのは、除算する前にキャストすることです。

C#
double result = (double)(a / b);

この書き方では、先にa / bが整数除算として計算されてしまいます。そのため、結果は3.333...ではなく3になります。

正しくは次のいずれかです。

C#
double result1 = (double)a / b;
double result2 = a / (double)b;
double result3 = (double)a / (double)b;

どれも小数の結果を得られます。

3-3. 数値リテラルに「.0」を付ける

数値を直接書く場合は、.0を付けることでdoubleとして扱えます。

C#
Console.WriteLine(10 / 3);
Console.WriteLine(10.0 / 3);
Console.WriteLine(10 / 3.0);

実行結果は次のようになります。

C#
3
3.3333333333333335
3.3333333333333335

10は整数リテラルですが、10.0はdoubleリテラルです。

そのため、10.0 / 3はdoubleの除算になります。

次のように平均を求める場合にも便利です。

C#
int total = 250;
int count = 6;

double average = total / 6.0;

Console.WriteLine(average);

ただし、変数を使う場合は、.0よりもキャストを使ったほうが意図が明確な場合もあります。

C#
double average = (double)total / count;

3-4. decimal型を使って正確な小数計算を行う

金額計算などでは、doubleよりもdecimalを使うことが多いです。

C#
decimal price = 1000m;
decimal rate = 3m;

decimal result = price / rate;

Console.WriteLine(result);

実行結果は次のようになります。

C#
333.33333333333333333333333333

decimal型のリテラルには、末尾にmまたはMを付けます。

C#
decimal taxRate = 0.1m;

decimalは10進数の計算に向いているため、金額や税率などの計算でよく使われます。

C#
decimal price = 1200m;
decimal taxRate = 0.10m;

decimal tax = price * taxRate;
decimal total = price + tax;

Console.WriteLine(total);

doubleは2進浮動小数点数なので、10進数の小数を厳密に表せないことがあります。金額計算では誤差が問題になる場合があるため、decimalを選ぶのが一般的です。

3-5. float・double・decimalの使い分け

C#で小数の除算を行う場合、float、double、decimalのどれを使うか迷うことがあります。

基本的な使い分けは次のとおりです。

floatは、精度よりもメモリ効率を重視する場合に使います。ゲーム開発や大量の数値データを扱う場面で使われることがあります。

C#
float a = 10.0f;
float b = 3.0f;
float result = a / b;

doubleは、一般的な小数計算でよく使われます。特別な理由がなければ、小数計算ではdoubleを使うことが多いです。

C#
double a = 10.0;
double b = 3.0;
double result = a / b;

decimalは、金額や税率など、10進数としての正確さを重視する計算に向いています。

C#
decimal price = 1000m;
decimal count = 3m;
decimal result = price / count;

ただし、decimalはdoubleより計算コストが高くなることがあります。そのため、すべての小数計算にdecimalを使えばよいというわけではありません。

目安としては、次のように考えるとよいでしょう。

C#
// 一般的な小数計算
double result1 = 10.0 / 3.0;

// 金額計算
decimal result2 = 1000m / 3m;

// メモリ効率重視
float result3 = 10.0f / 3.0f;

4. C#で除算の余りを求める方法

C#では、割り算の商だけでなく、余りを求めることもできます。

余りを求めるには、%演算子を使います。

4-1. 余りを求める「%」演算子

%演算子は、除算したときの余りを返します。

C#
int result = 10 % 3;

Console.WriteLine(result);

実行結果は次のようになります。

C#
1

10を3で割ると、商は3、余りは1です。

C#
10 / 3  // 商は3
10 % 3  // 余りは1

他の例も見てみましょう。

C#
Console.WriteLine(10 % 2);
Console.WriteLine(10 % 4);
Console.WriteLine(15 % 6);

実行結果は次のとおりです。

C#
0
2
3

10 % 2は割り切れるので余りは0です。

10 % 4は、4で2回割ると8になり、余りは2です。

15 % 6は、6で2回割ると12になり、余りは3です。

4-2. 商と余りを同時に求める基本例

商と余りを同時に求める場合は、/と%を組み合わせます。

C#
int a = 17;
int b = 5;

int quotient = a / b;
int remainder = a % b;

Console.WriteLine($"商: {quotient}");
Console.WriteLine($"余り: {remainder}");

実行結果は次のようになります。

C#
商: 3
余り: 2

17を5で割ると、5が3回入り、余りは2です。

このような処理は、ページング、時間の分解、グループ分けなどでよく使います。

4-3. 奇数・偶数判定に使う例

%演算子は、奇数・偶数の判定によく使われます。

C#
int number = 7;

if (number % 2 == 0)
{
    Console.WriteLine("偶数です");
}
else
{
    Console.WriteLine("奇数です");
}

実行結果は次のとおりです。

C#
奇数です

2で割った余りが0なら偶数、1なら奇数です。

C#
number % 2 == 0

この条件は、C#で非常によく使われる書き方です。

複数の数値を判定する例も見てみましょう。

C#
for (int i = 1; i <= 5; i++)
{
    if (i % 2 == 0)
    {
        Console.WriteLine($"{i}は偶数です");
    }
    else
    {
        Console.WriteLine($"{i}は奇数です");
    }
}

実行結果は次のようになります。

C#
1は奇数です
2は偶数です
3は奇数です
4は偶数です
5は奇数です

4-4. 倍数判定に使う例

%演算子は、ある数が別の数の倍数かどうかを判定するときにも使えます。

C#
int number = 15;

if (number % 3 == 0)
{
    Console.WriteLine("3の倍数です");
}

実行結果は次のとおりです。

C#
3の倍数です

ある数で割った余りが0なら、その数の倍数です。

たとえば、5の倍数を判定するなら次のように書きます。

C#
int number = 25;

if (number % 5 == 0)
{
    Console.WriteLine("5の倍数です");
}

3の倍数かつ5の倍数を判定することもできます。

C#
int number = 30;

if (number % 3 == 0 && number % 5 == 0)
{
    Console.WriteLine("3と5の両方の倍数です");
}

このように、%演算子は条件分岐と組み合わせてよく使います。

4-5. 負の数で剰余を使うときの注意点

C#で負の数に対して%を使う場合、余りの符号に注意が必要です。

C#
Console.WriteLine(10 % 3);
Console.WriteLine(-10 % 3);
Console.WriteLine(10 % -3);
Console.WriteLine(-10 % -3);

実行結果は次のようになります。

C#
1
-1
1
-1

C#の整数の剰余では、余りの符号は左側の値、つまり割られる数の符号と同じになります。

C#
-10 % 3  // -1
10 % -3  // 1

負の数を扱う処理では、この仕様を理解しておかないと、想定と違う結果になることがあります。

たとえば、インデックスを循環させるような処理で負の値が入る可能性がある場合は、次のように補正することがあります。

C#
int index = -1;
int length = 5;

int normalized = ((index % length) + length) % length;

Console.WriteLine(normalized);

実行結果は次のとおりです。

C#
4

負の数を含む剰余計算では、必要に応じて正の範囲に補正しましょう。

5. 除算でよく使う型変換の基本

C#の除算では、型変換が重要です。

特に、int同士の除算で小数を得たい場合は、除算前に型を変換する必要があります。

5-1. 暗黙的な型変換と明示的な型変換

C#の型変換には、大きく分けて「暗黙的な型変換」と「明示的な型変換」があります。

暗黙的な型変換は、自動的に行われる変換です。

C#
int a = 10;
double b = a;

この場合、intの10がdoubleの10.0として扱われます。intからdoubleへの変換は安全に行えるため、明示的なキャストは不要です。

一方、明示的な型変換は、キャストを使って自分で指定する変換です。

C#
double a = 10.5;
int b = (int)a;

この場合、10.5はintに変換され、10になります。小数点以下が失われる可能性があるため、明示的なキャストが必要です。

除算では、次のようなキャストをよく使います。

C#
int a = 10;
int b = 3;

double result = (double)a / b;

5-2. intからdoubleへ変換して割り算する

int同士の割り算で小数を得たい場合は、どちらか一方をdoubleに変換します。

C#
int total = 10;
int count = 3;

double average = (double)total / count;

Console.WriteLine(average);

実行結果は次のようになります。

C#
3.3333333333333335

(double)totalによって、totalがdoubleに変換されます。そのため、countも計算時にdoubleとして扱われ、結果もdoubleになります。

次のように書いても同じです。

C#
double average = total / (double)count;

ただし、読みやすさを考えると、割られる数をキャストする書き方がよく使われます。

C#
double average = (double)total / count;

5-3. 除算後にキャストしても小数が戻らない理由

初心者がよく間違えるのが、除算後にキャストする書き方です。

C#
int a = 10;
int b = 3;

double result = (double)(a / b);

Console.WriteLine(result);

実行結果は次のようになります。

C#
3

一見するとdoubleに変換しているように見えますが、(a / b)が先に計算されます。

aもbもintなので、a / bは整数除算です。この時点で結果は3になります。

その後に3をdoubleへ変換しても、失われた小数点以下は戻りません。

C#
(double)(a / b)  // 先に 10 / 3 が int として計算される

正しくは次のように、除算前にキャストします。

C#
double result = (double)a / b;

型変換の位置は、C#の除算で非常に重要です。

5-4. Convert.ToDoubleとの違い

doubleに変換する方法として、Convert.ToDoubleを使うこともできます。

C#
int a = 10;
int b = 3;

double result = Convert.ToDouble(a) / b;

Console.WriteLine(result);

実行結果は次のようになります。

C#
3.3333333333333335

Convert.ToDouble(a)によって、aがdoubleに変換されてから除算されます。

キャストとの違いは、主に書き方と用途です。

C#
double result1 = (double)a / b;
double result2 = Convert.ToDouble(a) / b;

単純に数値型を変換するだけなら、キャストのほうが短く書けます。

一方、文字列などを数値に変換する場合は、Convert.ToDoubleやdouble.Parseを使うことがあります。

C#
string text = "10.5";

double value = Convert.ToDouble(text);
Console.WriteLine(value / 2);

ただし、文字列変換では入力値が不正な場合に例外が発生することがあります。安全に変換したい場合は、double.TryParseも検討しましょう。

5-5. decimalに変換するときの書き方

decimalに変換して除算する場合も、除算前に変換する必要があります。

C#
int a = 10;
int b = 3;

decimal result = (decimal)a / b;

Console.WriteLine(result);

実行結果は次のようになります。

C#
3.3333333333333333333333333333

decimalリテラルを使う場合は、数値の末尾にmを付けます。

C#
decimal result = 10m / 3m;

doubleとdecimalはそのまま混在できないため、次のようなコードはエラーになります。

C#
decimal price = 1000m;
double rate = 0.1;

decimal result = price * rate; // コンパイルエラー

decimalで計算するなら、関係する値をすべてdecimalにそろえます。

C#
decimal price = 1000m;
decimal rate = 0.1m;

decimal result = price * rate;

金額計算では、途中でdoubleを混ぜないことが大切です。

6. C#の除算で起こりやすいエラーと対処法

C#の除算で特に注意したいのが、0で割る処理です。

0除算は、型によって動きが変わります。整数やdecimalでは例外が発生しますが、doubleやfloatではInfinityなどの特殊な値になる場合があります。

6-1. 0で割ったときに発生するエラー

整数を0で割ると、実行時エラーが発生します。

C#
int a = 10;
int b = 0;

int result = a / b;

Console.WriteLine(result);

このコードを実行すると、DivideByZeroExceptionが発生します。

0で割ることは数学的に定義できないため、C#でも整数除算では例外になります。

余りを求める場合も同じです。

C#
int result = 10 % 0;

この場合も、0で割っているため例外が発生します。

6-2. DivideByZeroExceptionとは

DivideByZeroExceptionは、0で除算しようとしたときに発生する例外です。

C#
try
{
    int result = 10 / 0;
    Console.WriteLine(result);
}
catch (DivideByZeroException)
{
    Console.WriteLine("0で割ることはできません。");
}

実行結果は次のようになります。

C#
0で割ることはできません。

DivideByZeroExceptionは、整数型やdecimal型の除算で0除算をした場合に発生します。

C#
decimal a = 10m;
decimal b = 0m;

decimal result = a / b; // DivideByZeroException

0で割る可能性がある処理では、事前チェックを行うか、例外処理を用意しておきましょう。

6-3. doubleやfloatで0除算した場合の結果

doubleやfloatでは、0で割っても必ず例外になるわけではありません。

C#
Console.WriteLine(10.0 / 0.0);
Console.WriteLine(-10.0 / 0.0);
Console.WriteLine(0.0 / 0.0);

実行結果は次のようになります。

C#
Infinity
-Infinity
NaN

10.0 / 0.0は正の無限大を表すInfinityになります。

-10.0 / 0.0は負の無限大を表す-Infinityになります。

0.0 / 0.0は数値として定義できないため、NaNになります。

これらはdoubleの特殊な値です。

C#
double result = 10.0 / 0.0;

Console.WriteLine(double.IsInfinity(result));

実行結果は次のようになります。

C#
True

NaNかどうかを確認するには、double.IsNaNを使います。

C#
double result = 0.0 / 0.0;

Console.WriteLine(double.IsNaN(result));

floatの場合も同様に、float.IsInfinityやfloat.IsNaNを使えます。

6-4. 事前チェックで0除算を防ぐ方法

0除算を防ぐ最も基本的な方法は、割る数が0でないか事前にチェックすることです。

C#
int a = 10;
int b = 0;

if (b != 0)
{
    int result = a / b;
    Console.WriteLine(result);
}
else
{
    Console.WriteLine("0で割ることはできません。");
}

このように、除算の前にb != 0を確認すれば、DivideByZeroExceptionを防げます。

平均値を求める場合も、件数が0でないか確認する必要があります。

C#
int total = 100;
int count = 0;

if (count > 0)
{
    double average = (double)total / count;
    Console.WriteLine(average);
}
else
{
    Console.WriteLine("件数が0のため平均を計算できません。");
}

実務では、ユーザー入力やデータベースの値など、割る数が必ず0でないとは限りません。除算前のチェックを習慣にしましょう。

6-5. try-catchで例外処理する方法

0除算が起こる可能性がある場合は、try-catchで例外処理することもできます。

C#
try
{
    int a = 10;
    int b = 0;

    int result = a / b;

    Console.WriteLine(result);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("0で割ることはできません。");
    Console.WriteLine(ex.Message);
}

tryブロック内で例外が発生すると、catchブロックが実行されます。

ただし、0除算は事前にチェックできることが多いため、基本的には次のようなチェックを行うほうが分かりやすいです。

C#
if (b == 0)
{
    Console.WriteLine("0で割ることはできません。");
}
else
{
    Console.WriteLine(a / b);
}

try-catchは、予測が難しいエラーや外部入力によるエラーに備える場合に使うとよいでしょう。

7. 除算結果の丸め・切り上げ・切り捨て

C#で除算結果を扱うとき、小数点以下をどう処理するかも重要です。

切り捨て、切り上げ、四捨五入を行うには、Math.Floor、Math.Ceiling、Math.Roundなどを使います。

7-1. Math.Floorで小数点以下を切り捨てる

Math.Floorは、指定した数値以下の最大の整数値を返します。

C#
double value = 3.8;

double result = Math.Floor(value);

Console.WriteLine(result);

実行結果は次のようになります。

C#
3

正の数では、小数点以下を切り捨てる動きになります。

C#
Console.WriteLine(Math.Floor(3.1));
Console.WriteLine(Math.Floor(3.9));

実行結果は次のとおりです。

C#
3
3

ただし、負の数では注意が必要です。

C#
Console.WriteLine(Math.Floor(-3.1));
Console.WriteLine(Math.Floor(-3.9));

実行結果は次のようになります。

C#
-4
-4

Math.Floorは「小さい方向」に丸めるため、-3.1は-4になります。

7-2. Math.Ceilingで切り上げる

Math.Ceilingは、指定した数値以上の最小の整数値を返します。

C#
double value = 3.2;

double result = Math.Ceiling(value);

Console.WriteLine(result);

実行結果は次のようになります。

C#
4

正の数では、小数点以下があれば切り上げる動きになります。

C#
Console.WriteLine(Math.Ceiling(3.1));
Console.WriteLine(Math.Ceiling(3.9));
Console.WriteLine(Math.Ceiling(3.0));

実行結果は次のとおりです。

C#
4
4
3

ページ数を求めるときなどに便利です。

C#
int itemCount = 101;
int pageSize = 10;

int pageCount = (int)Math.Ceiling((double)itemCount / pageSize);

Console.WriteLine(pageCount);

実行結果は次のようになります。

C#
11

101件のデータを1ページ10件で表示する場合、必要なページ数は11ページです。

7-3. Math.Roundで四捨五入する

Math.Roundを使うと、小数を丸めることができます。

C#
double value = 3.6;

double result = Math.Round(value);

Console.WriteLine(result);

実行結果は次のようになります。

C#
4

桁数を指定することもできます。

C#
double value = 3.14159;

double result = Math.Round(value, 2);

Console.WriteLine(result);

実行結果は次のとおりです。

C#
3.14

ただし、Math.Roundの既定の動作には注意が必要です。

C#のMath.Roundは、ちょうど中間の値を丸めるときに、既定では偶数に丸める方式を使います。

C#
Console.WriteLine(Math.Round(2.5));
Console.WriteLine(Math.Round(3.5));

実行結果は次のようになります。

C#
2
4

一般的な「0.5以上を切り上げる」四捨五入にしたい場合は、MidpointRounding.AwayFromZeroを指定します。

C#
Console.WriteLine(Math.Round(2.5, MidpointRounding.AwayFromZero));
Console.WriteLine(Math.Round(3.5, MidpointRounding.AwayFromZero));

実行結果は次のとおりです。

C#
3
4

丸め処理では、どのルールで丸めたいのかを明確にすることが大切です。

7-4. int除算の切り捨てとMath.Floorの違い

int同士の除算とMath.Floorは、似ているようで完全には同じではありません。

正の数では、同じような結果になります。

C#
Console.WriteLine(10 / 3);
Console.WriteLine(Math.Floor(10.0 / 3.0));

実行結果は次のようになります。

C#
3
3

しかし、負の数では違いが出ます。

C#
Console.WriteLine(-10 / 3);
Console.WriteLine(Math.Floor(-10.0 / 3.0));

実行結果は次のとおりです。

C#
-3
-4

整数除算は0に近づく方向に切り捨てます。

一方、Math.Floorは小さい方向に丸めます。

C#
-10 / 3                // -3
Math.Floor(-10.0 / 3)  // -4

負の数を扱う場合は、整数除算とMath.Floorを同じものとして扱わないようにしましょう。

7-5. 表示桁数を指定して小数を整える方法

計算結果そのものを丸めるのではなく、表示だけ整えたい場合は、書式指定を使います。

C#
double result = 10.0 / 3.0;

Console.WriteLine(result.ToString("F2"));

実行結果は次のようになります。

C#
3.33

F2は小数点以下2桁で表示する指定です。

文字列補間でも書けます。

C#
double result = 10.0 / 3.0;

Console.WriteLine($"{result:F2}");

パーセント表示にすることもできます。

C#
double rate = 0.1234;

Console.WriteLine($"{rate:P1}");

実行結果は次のようになります。

C#
12.3 %

注意したいのは、表示形式を変えても元の数値が変わるわけではないという点です。

C#
double result = 10.0 / 3.0;

Console.WriteLine($"{result:F2}");
Console.WriteLine(result);

F2は表示上の桁数を整えるだけです。計算結果そのものを丸めたい場合は、Math.Roundを使いましょう。

8. 実践で使うC#の除算サンプル

ここからは、実際のプログラムでよく使うC#の除算サンプルを紹介します。

整数除算、小数除算、余り、型変換、丸め処理を組み合わせることで、さまざまな計算ができます。

8-1. 平均点を正しく計算する

平均点を求めるときに、int同士で割ると小数点以下が消えてしまいます。

C#
int total = 250;
int count = 6;

double average = total / count;

Console.WriteLine(average);

実行結果は次のようになります。

C#
41

本来は約41.666...ですが、total / countがint同士の除算なので、結果は41になります。

正しく小数で求めるには、除算前にdoubleへ変換します。

C#
int total = 250;
int count = 6;

double average = (double)total / count;

Console.WriteLine(average);

実行結果は次のとおりです。

C#
41.666666666666664

表示を小数点以下1桁にしたい場合は、次のように書けます。

C#
Console.WriteLine($"{average:F1}");

実行結果は次のようになります。

C#
41.7

8-2. 割引率や割合を計算する

割合を計算するときも、整数除算に注意が必要です。

C#
int discount = 20;
int price = 100;

double rate = discount / price;

Console.WriteLine(rate);

実行結果は次のようになります。

C#
0

20 / 100は整数除算なので、0.2ではなく0になります。

正しくは次のように書きます。

C#
int discount = 20;
int price = 100;

double rate = (double)discount / price;

Console.WriteLine(rate);
Console.WriteLine($"{rate:P0}");

実行結果は次のとおりです。

C#
0.2
20 %

割合や率を計算するときは、少なくとも一方をdoubleに変換しましょう。

金額を扱う場合は、decimalを使うこともあります。

C#
decimal price = 1000m;
decimal discountRate = 0.2m;

decimal discountAmount = price * discountRate;
decimal finalPrice = price - discountAmount;

Console.WriteLine(finalPrice);