Tại sao phép chia số nguyên trong C # trả về một số nguyên mà không phải là số float?

Có ai biết tại sao phép chia số nguyên trong C # trả về một số nguyên mà không phải là số float không? Ý tưởng đằng sau nó là gì? (Có phải nó chỉ là một di sản của C / C ++?)

Trong C #:

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

Kết quả của mã này sẽ là:

'Hello world'

Nói một cách chính xác, không có thứ gọi là phép chia số nguyên (chia theo định nghĩa là một phép toán tạo ra một số hữu tỷ, số nguyên là một tập hợp con rất nhỏ trong đó.)

Mặc dù thông thường, lập trình viên mới mắc lỗi này khi thực hiện phép chia số nguyên khi họ thực sự có ý định sử dụng phép chia dấu phẩy động, trong thực tế, phép chia số nguyên là một thao tác rất phổ biến. Nếu bạn cho rằng mọi người hiếm khi sử dụng nó, và mỗi khi bạn thực hiện phép chia, bạn sẽ luôn cần nhớ chuyển sang các điểm nổi, thì bạn đã nhầm.

Trước hết, phép chia số nguyên nhanh hơn một chút, vì vậy nếu bạn chỉ cần một kết quả số nguyên, người ta sẽ muốn sử dụng thuật toán hiệu quả hơn.

Thứ hai, có một số thuật toán sử dụng phép chia số nguyên và nếu kết quả của phép chia luôn là số dấu phẩy động, bạn sẽ bị buộc phải làm tròn kết quả mỗi lần. Một ví dụ ngoài đỉnh đầu của tôi là thay đổi cơ sở của một số. Tính toán mỗi chữ số liên quan đến phép chia số nguyên của một số cùng với phần còn lại, chứ không phải là phép chia dấu phẩy động của số.

Vì những lý do này (và các lý do liên quan khác), phân chia số nguyên dẫn đến một số nguyên. Nếu bạn muốn có được phép chia dấu phẩy động của hai số nguyên, bạn chỉ cần nhớ chuyển một thành một double/ float/ decimal.

Xem thông số kỹ thuật C # . Có ba loại toán tử phân chia

• Bộ phận nguyên
• Phân chia điểm nổi
• Phân chia thập phân

Trong trường hợp của bạn, chúng tôi có phân chia Integer, với các quy tắc sau được áp dụng:

Phép chia làm tròn kết quả về 0 và giá trị tuyệt đối của kết quả là số nguyên lớn nhất có thể nhỏ hơn giá trị tuyệt đối của thương số của hai toán hạng. Kết quả bằng 0 hoặc dương khi hai toán hạng có cùng dấu và 0 hoặc âm khi hai toán hạng có dấu trái ngược nhau.

Tôi nghĩ lý do tại sao C # sử dụng loại phân chia này cho số nguyên (một số ngôn ngữ trả về kết quả nổi) là phần cứng - phân chia số nguyên nhanh hơn và đơn giản hơn.

Mỗi loại dữ liệu có khả năng quá tải mỗi toán tử. Nếu cả tử số và mẫu số đều là số nguyên, kiểu số nguyên sẽ thực hiện thao tác chia và nó sẽ trả về một kiểu số nguyên. Nếu bạn muốn phân chia điểm nổi, bạn phải bỏ một hoặc nhiều số cho các loại dấu phẩy động trước khi chia chúng. Ví dụ:

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

hoặc, nếu bạn đang sử dụng chữ:

float x = 13f / 4f;

Hãy ghi nhớ, các điểm nổi không chính xác. Thay vào đó, nếu bạn quan tâm đến độ chính xác, hãy sử dụng một cái gì đó như kiểu thập phân.

Vì bạn không sử dụng bất kỳ hậu tố nào, các chữ 13và 4được hiểu là số nguyên:

Hướng dẫn sử dụng :

Nếu theo nghĩa đen không có hậu tố, nó có là người đầu tiên của các loại, trong đó giá trị của nó có thể được biểu: int, uint, long, ulong.

Do đó, vì bạn khai báo 13là số nguyên, phép chia số nguyên sẽ được thực hiện:

Hướng dẫn sử dụng :

Đối với một hoạt động có dạng x / y, độ phân giải quá tải toán tử nhị phân được áp dụng để chọn một triển khai toán tử cụ thể. Các toán hạng được chuyển đổi thành các loại tham số của toán tử được chọn và loại kết quả là kiểu trả về của toán tử.

Các toán tử phân chia được xác định trước được liệt kê dưới đây. Các toán tử đều tính thương số của x và y.

Bộ phận nguyên:

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

Và vì vậy, làm tròn xuống xảy ra:

Phép chia làm tròn kết quả về 0 và giá trị tuyệt đối của kết quả là số nguyên lớn nhất có thể nhỏ hơn giá trị tuyệt đối của thương số của hai toán hạng. Kết quả bằng 0 hoặc dương khi hai toán hạng có cùng dấu và 0 hoặc âm khi hai toán hạng có dấu trái ngược nhau.

Nếu bạn làm như sau:

int x = 13f / 4f;

Bạn sẽ nhận được một lỗi biên dịch, vì một phép chia dấu phẩy động ( /toán tử của 13f) dẫn đến một số float, không thể chuyển thành int ngầm.

Nếu bạn muốn phân chia là phân chia dấu phẩy động, bạn sẽ phải làm cho kết quả nổi:

float x = 13 / 4;

Lưu ý rằng bạn vẫn sẽ phân chia số nguyên, sẽ hoàn toàn được bỏ qua để nổi: kết quả sẽ là 3.0. Để khai báo rõ ràng các toán hạng là float, sử dụng fhậu tố ( 13f, 4f).

Nó chỉ là một hoạt động cơ bản .

Hãy nhớ khi bạn học cách chia. Ban đầu chúng tôi đã giải quyết 9/6 = 1 with remainder 3.

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

/ -Operator kết hợp với% -operator được sử dụng để truy xuất các giá trị đó.

Có thể hữu ích:

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

Kết quả sẽ luôn thuộc loại có phạm vi tử số và mẫu số lớn hơn. Các ngoại lệ là byte và ngắn, tạo ra 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

Không có chuyển đổi ngầm giữa các loại dấu phẩy động và loại thập phân, vì vậy không được phép phân chia giữa chúng. Bạn phải phân vai rõ ràng và quyết định cái nào bạn muốn (Decimal có độ chính xác cao hơn và phạm vi nhỏ hơn so với các loại dấu phẩy động).