Luôn luôn sử dụng printfhọ các chức năng cho việc này. Ngay cả khi bạn muốn nhận giá trị dưới dạng float, tốt nhất bạn nên sử dụng snprintfđể lấy giá trị làm tròn dưới dạng chuỗi và sau đó phân tích lại bằng atof:
#include <math.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
double dround(double val, int dp) {
int charsNeeded = 1 + snprintf(NULL, 0, "%.*f", dp, val);
char *buffer = malloc(charsNeeded);
snprintf(buffer, charsNeeded, "%.*f", dp, val);
double result = atof(buffer);
free(buffer);
return result;
}
Tôi nói điều này bởi vì cách tiếp cận được hiển thị bởi câu trả lời được bình chọn hàng đầu hiện tại và một số cách khác ở đây - nhân với 100, làm tròn đến số nguyên gần nhất, sau đó chia cho 100 lần nữa - bị sai theo hai cách:
- Đối với một số giá trị, nó sẽ làm tròn sai hướng vì phép nhân với 100 thay đổi chữ số thập phân xác định hướng làm tròn từ 4 sang 5 hoặc ngược lại, do sự thiếu chính xác của các số dấu phẩy động
- Đối với một số giá trị, nhân và sau đó chia cho 100 không đi khứ hồi, có nghĩa là ngay cả khi không làm tròn số thì kết quả cuối cùng sẽ sai
Để minh họa loại lỗi đầu tiên - hướng làm tròn đôi khi bị sai - hãy thử chạy chương trình này:
int main(void) {
// This number is EXACTLY representable as a double
double x = 0.01499999999999999944488848768742172978818416595458984375;
printf("x: %.50f\n", x);
double res1 = dround(x, 2);
double res2 = round(100 * x) / 100;
printf("Rounded with snprintf: %.50f\n", res1);
printf("Rounded with round, then divided: %.50f\n", res2);
}
Bạn sẽ thấy đầu ra này:
x: 0.01499999999999999944488848768742172978818416595459
Rounded with snprintf: 0.01000000000000000020816681711721685132943093776703
Rounded with round, then divided: 0.02000000000000000041633363423443370265886187553406
Lưu ý rằng giá trị chúng tôi bắt đầu bằng nhỏ hơn 0,015 và vì vậy câu trả lời đúng về mặt toán học khi làm tròn nó đến 2 chữ số thập phân là 0,01. Tất nhiên, 0,01 không thể biểu diễn chính xác như một đôi, nhưng chúng tôi hy vọng kết quả của chúng tôi sẽ là gấp đôi gần nhất với 0,01. Sử dụng snprintfcho chúng ta kết quả đó, nhưng sử dụng round(100 * x) / 100cho chúng ta 0,02, đó là sai. Tại sao? Bởi vì 100 * xcho chúng tôi chính xác 1,5 như kết quả. Nhân với 100 do đó thay đổi hướng chính xác để làm tròn.
Để minh họa loại lỗi thứ hai - kết quả đôi khi bị sai do * 100và / 100không thực sự là nghịch đảo của nhau - chúng ta có thể thực hiện một bài tập tương tự với một số rất lớn:
int main(void) {
double x = 8631192423766613.0;
printf("x: %.1f\n", x);
double res1 = dround(x, 2);
double res2 = round(100 * x) / 100;
printf("Rounded with snprintf: %.1f\n", res1);
printf("Rounded with round, then divided: %.1f\n", res2);
}
Số của chúng tôi bây giờ thậm chí không có một phần nhỏ; nó là một giá trị nguyên, chỉ được lưu trữ với loại double. Vì vậy, kết quả sau khi làm tròn nó sẽ là cùng một số chúng ta bắt đầu, phải không?
Nếu bạn chạy chương trình trên, bạn sẽ thấy:
x: 8631192423766613.0
Rounded with snprintf: 8631192423766613.0
Rounded with round, then divided: 8631192423766612.0
Giáo sư. snprintfPhương pháp của chúng tôi trả về kết quả đúng một lần nữa, nhưng cách tiếp cận nhân-sau-vòng-sau-sau-chia-thất bại. Đó là bởi vì giá trị chính xác về mặt toán học của 8631192423766613.0 * 100,, 863119242376661300.0không thể biểu diễn chính xác như một đôi; giá trị gần nhất là 863119242376661248.0. Khi bạn chia lại cho 100, bạn nhận được8631192423766612.0 - một số khác với số bạn đã bắt đầu.
Hy vọng rằng đó là một minh chứng đầy đủ rằng việc sử dụng roundfđể làm tròn đến một số vị trí thập phân bị hỏng và snprintfthay vào đó bạn nên sử dụng . Nếu điều đó cảm thấy như một vụ hack khủng khiếp đối với bạn, có lẽ bạn sẽ yên tâm bởi kiến thức rằng về cơ bản đó là những gì CPython làm .
float(vàdouble) không phải là dấu phẩy động thập phân - chúng là dấu phẩy động nhị phân - vì vậy làm tròn đến vị trí thập phân là vô nghĩa. Bạn có thể làm tròn đầu ra, tuy nhiên.