เหตุใดการหารจำนวนเต็มใน C # จึงส่งคืนจำนวนเต็มไม่ใช่จำนวนทศนิยม

มีใครรู้บ้างว่าทำไมการหารจำนวนเต็มใน C # ส่งกลับจำนวนเต็มไม่ใช่ทศนิยม? ความคิดเบื้องหลังคืออะไร? (เป็นเพียงมรดกของ C / C ++ หรือไม่?)

ใน C #:

float x = 13 / 4;   
//== operator is overridden here to use epsilon compare
if (x == 3.0)
   print 'Hello world';

ผลลัพธ์ของรหัสนี้จะเป็น:

'Hello world'

พูดอย่างเคร่งครัดไม่มีสิ่งที่เรียกว่าการหารจำนวนเต็ม (การหารตามนิยามคือการดำเนินการที่สร้างจำนวนที่มีเหตุผลจำนวนเต็มเป็นส่วนย่อยที่เล็กมาก)

แม้ว่าโปรแกรมเมอร์มือใหม่จะทำผิดพลาดในการหารจำนวนเต็มเมื่อพวกเขาตั้งใจจะใช้การหารทศนิยม แต่ในทางปฏิบัติจริงการหารจำนวนเต็มถือเป็นการดำเนินการทั่วไป หากคุณสมมติว่าไม่ค่อยมีคนใช้และทุกครั้งที่คุณหารคุณจะต้องจำไว้เสมอว่าให้โยนไปที่จุดลอยตัวคุณจะเข้าใจผิด

ก่อนอื่นการหารจำนวนเต็มค่อนข้างเร็วกว่าเล็กน้อยดังนั้นหากคุณต้องการเพียงแค่ผลลัพธ์จำนวนเต็มเราก็ต้องการใช้อัลกอริทึมที่มีประสิทธิภาพมากขึ้น

ประการที่สองมีอัลกอริทึมจำนวนหนึ่งที่ใช้การหารจำนวนเต็มและหากผลลัพธ์ของการหารเป็นเลขทศนิยมเสมอคุณจะถูกบังคับให้ปัดเศษผลลัพธ์ทุกครั้ง ตัวอย่างหนึ่งจากด้านบนของหัวของฉันคือการเปลี่ยนฐานของตัวเลข การคำนวณแต่ละหลักเกี่ยวข้องกับการหารจำนวนเต็มของตัวเลขพร้อมกับเศษที่เหลือแทนที่จะเป็นการหารทศนิยมของจำนวน

เนื่องจากเหตุผลเหล่านี้ (และอื่น ๆ ที่เกี่ยวข้อง) การหารจำนวนเต็มจึงทำให้เกิดจำนวนเต็ม หากคุณต้องการได้การหารทศนิยมของจำนวนเต็มสองจำนวนคุณจะต้องจำไว้ว่าให้แคสต์หนึ่งเป็น a double/ float/decimal /

ดู C # ข้อกำหนด ตัวดำเนินการแบ่งมีสามประเภท

• การหารจำนวนเต็ม
• การแบ่งจุดลอยตัว
• การหารทศนิยม

ในกรณีของคุณเรามีการหารจำนวนเต็มโดยใช้กฎต่อไปนี้:

การหารจะปัดเศษผลลัพธ์ให้เป็นศูนย์และค่าสัมบูรณ์ของผลลัพธ์คือจำนวนเต็มมากที่สุดที่เป็นไปได้ซึ่งน้อยกว่าค่าสัมบูรณ์ของผลหารของตัวถูกดำเนินการสองตัว ผลลัพธ์จะเป็นศูนย์หรือเป็นบวกเมื่อตัวถูกดำเนินการทั้งสองมีเครื่องหมายเดียวกันและเป็นศูนย์หรือเป็นลบเมื่อตัวถูกดำเนินการทั้งสองมีเครื่องหมายตรงข้ามกัน

ฉันคิดว่าเหตุผลที่ C # ใช้การหารประเภทนี้สำหรับจำนวนเต็ม (บางภาษาส่งคืนผลลัพธ์แบบลอยตัว) คือฮาร์ดแวร์ - การหารจำนวนเต็มเร็วและง่ายกว่า

ข้อมูลแต่ละประเภทสามารถโอเวอร์โหลดโอเปอเรเตอร์แต่ละตัวได้ ถ้าทั้งตัวเศษและตัวส่วนเป็นจำนวนเต็มประเภทจำนวนเต็มจะดำเนินการหารและจะส่งกลับประเภทจำนวนเต็ม หากคุณต้องการแบ่งจุดลอยตัวคุณต้องโยนตัวเลขอย่างน้อยหนึ่งจำนวนเป็นประเภทจุดลอยตัวก่อนที่จะหาร ตัวอย่างเช่น:

int x = 13;
int y = 4;
float x = (float)y / (float)z;

หรือถ้าคุณใช้ตัวอักษร:

float x = 13f / 4f;

โปรดทราบว่าจุดลอยไม่แม่นยำ หากคุณสนใจเกี่ยวกับความแม่นยำให้ใช้ประเภททศนิยมแทน

เนื่องจากคุณไม่ได้ใช้คำต่อท้ายตัวอักษร13และ4ถูกตีความเป็นจำนวนเต็ม:

คู่มือ :

intถ้าตัวอักษรไม่ได้มีคำต่อท้ายก็มีครั้งแรกของประเภทนี้ที่คุ้มค่าสามารถแสดง: uint, long, ulong,

ดังนั้นเนื่องจากคุณประกาศ13เป็นจำนวนเต็มการหารจำนวนเต็มจะดำเนินการ:

คู่มือ :

สำหรับการดำเนินการของรูปแบบ x / y ความละเอียดเกินพิกัดของตัวดำเนินการไบนารีจะถูกนำไปใช้เพื่อเลือกการใช้งานตัวดำเนินการเฉพาะ ตัวถูกดำเนินการจะถูกแปลงเป็นประเภทพารามิเตอร์ของตัวดำเนินการที่เลือกและประเภทของผลลัพธ์คือประเภทการส่งคืนของตัวดำเนินการ

ตัวดำเนินการแบ่งที่กำหนดไว้ล่วงหน้าแสดงอยู่ด้านล่าง ตัวดำเนินการทั้งหมดคำนวณผลหารของ x และ y

การหารจำนวนเต็ม:

int operator /(int x, int y);
uint operator /(uint x, uint y);
long operator /(long x, long y);
ulong operator /(ulong x, ulong y);

และการปัดเศษเกิดขึ้น:

การหารจะปัดเศษผลลัพธ์ให้เป็นศูนย์และค่าสัมบูรณ์ของผลลัพธ์คือจำนวนเต็มมากที่สุดที่เป็นไปได้ซึ่งน้อยกว่าค่าสัมบูรณ์ของผลหารของตัวถูกดำเนินการสองตัว ผลลัพธ์จะเป็นศูนย์หรือเป็นบวกเมื่อตัวถูกดำเนินการทั้งสองมีเครื่องหมายเดียวกันและเป็นศูนย์หรือเป็นลบเมื่อตัวถูกดำเนินการทั้งสองมีเครื่องหมายตรงกันข้าม

หากคุณทำสิ่งต่อไปนี้:

int x = 13f / 4f;

คุณจะได้รับข้อผิดพลาดของคอมไพเลอร์เนื่องจากการหารทศนิยม (ตัว/ดำเนินการของ13f ) ส่งผลให้เกิดการลอยซึ่งไม่สามารถส่งเป็น int โดยปริยายได้

หากคุณต้องการให้การหารเป็นทศนิยมคุณจะต้องทำให้ผลลัพธ์เป็นแบบลอย:

float x = 13 / 4;

สังเกตว่าคุณจะยังคงหารจำนวนเต็มซึ่งโดยปริยายจะถูกเหวี่ยงให้ลอย: ผลลัพธ์จะเป็น 3.0ผลจะเป็น ในการประกาศตัวถูกดำเนินการเป็น float อย่างชัดเจนโดยใช้fคำต่อท้าย ( 13f, 4f)

เพียงใช้ดำเนินงานขั้นพื้นฐาน

จำไว้ว่าเมื่อคุณเรียนรู้ที่จะแบ่งแยก 9/6 = 1 with remainder 3ในการเริ่มต้นที่เราแก้ไขได้

9 / 6 == 1  //true
9 % 6 == 3 // true

/ -operator ร่วมกับ% -operator ถูกใช้เพื่อดึงค่าเหล่านั้น

อาจมีประโยชน์:

double a = 5.0/2.0;   
Console.WriteLine (a);      // 2.5

double b = 5/2;   
Console.WriteLine (b);      // 2

int c = 5/2;   
Console.WriteLine (c);      // 2

double d = 5f/2f;   
Console.WriteLine (d);      // 2.5

ผลลัพธ์จะเป็นประเภทที่มีช่วงของตัวเศษและตัวส่วนมากกว่าเสมอ ข้อยกเว้นคือไบต์และแบบสั้นซึ่งทำให้เกิด int (Int32)

var a = (byte)5 / (byte)2;  // 2 (Int32)
var b = (short)5 / (byte)2; // 2 (Int32)
var c = 5 / 2;              // 2 (Int32)
var d = 5 / 2U;             // 2 (UInt32)
var e = 5L / 2U;            // 2 (Int64)
var f = 5L / 2UL;           // 2 (UInt64)
var g = 5F / 2UL;           // 2.5 (Single/float)
var h = 5F / 2D;            // 2.5 (Double)
var i = 5.0 / 2F;           // 2.5 (Double)
var j = 5M / 2;             // 2.5 (Decimal)
var k = 5M / 2F;            // Not allowed

ไม่มีการแปลงโดยนัยระหว่างประเภททศนิยมและประเภททศนิยมดังนั้นจึงไม่อนุญาตให้แบ่งระหว่างประเภทเหล่านี้ คุณต้องแคสต์อย่างชัดเจนและตัดสินใจว่าคุณต้องการอันไหน (ทศนิยมมีความแม่นยำมากกว่าและมีช่วงที่เล็กกว่าเมื่อเทียบกับประเภททศนิยม)