Verwenden Sie dazu immer die printfFunktionsfamilie. Selbst wenn Sie den Wert als Float erhalten möchten, verwenden Sie am besten snprintfden gerundeten Wert als Zeichenfolge und analysieren ihn anschließend mit 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;
}
Ich sage dies, weil der Ansatz, den die derzeit am besten gewählte Antwort und einige andere hier zeigen - Multiplizieren mit 100, Runden auf die nächste ganze Zahl und erneutes Teilen durch 100 - in zweierlei Hinsicht fehlerhaft ist:
- Bei einigen Werten wird in die falsche Richtung gerundet, da durch die Multiplikation mit 100 die Dezimalstelle, die die Rundungsrichtung bestimmt, aufgrund der Ungenauigkeit der Gleitkommazahlen von 4 auf 5 oder umgekehrt geändert wird
- Bei einigen Werten führt das Multiplizieren und anschließende Teilen durch 100 nicht zu einem Roundtrip, was bedeutet, dass das Endergebnis falsch ist, selbst wenn keine Rundung stattfindet
Führen Sie dieses Programm aus, um die erste Art von Fehler zu veranschaulichen - die Rundungsrichtung ist manchmal falsch.
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);
}
Sie sehen diese Ausgabe:
x: 0.01499999999999999944488848768742172978818416595459
Rounded with snprintf: 0.01000000000000000020816681711721685132943093776703
Rounded with round, then divided: 0.02000000000000000041633363423443370265886187553406
Beachten Sie, dass der Wert, mit dem wir begonnen haben, weniger als 0,015 betrug. Daher lautet die mathematisch korrekte Antwort beim Runden auf 2 Dezimalstellen 0,01. Natürlich ist 0,01 nicht genau als Double darstellbar, aber wir erwarten, dass unser Ergebnis das Double ist, das 0,01 am nächsten kommt. Die Verwendung snprintfgibt uns dieses Ergebnis, aber die Verwendung round(100 * x) / 100gibt uns 0,02, was falsch ist. Warum? Denn 100 * xgibt uns genau 1,5 als Ergebnis. Das Multiplizieren mit 100 ändert somit die richtige Richtung zum Runden.
Um die zweite Art von Fehler zu veranschaulichen - das Ergebnis ist manchmal falsch * 100und / 100nicht wirklich umgekehrt - können wir eine ähnliche Übung mit einer sehr großen Anzahl durchführen:
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);
}
Unsere Zahl hat jetzt nicht einmal einen Bruchteil; Es ist ein ganzzahliger Wert, der nur mit Typ gespeichert wird double. Das Ergebnis nach dem Runden sollte also dieselbe Zahl sein, mit der wir begonnen haben, oder?
Wenn Sie das obige Programm ausführen, sehen Sie:
x: 8631192423766613.0
Rounded with snprintf: 8631192423766613.0
Rounded with round, then divided: 8631192423766612.0
Hoppla. Unsere snprintfMethode liefert wieder das richtige Ergebnis, aber der Ansatz "Multiplizieren, Runden, Teilen" schlägt fehl. Das ist , weil der mathematisch korrekte Wert 8631192423766613.0 * 100, 863119242376661300.0ist nicht exakt darstellbar als Doppel; der nächste Wert ist 863119242376661248.0. Wenn Sie das durch 100 teilen, erhalten Sie 8631192423766612.0- eine andere Zahl als die, mit der Sie begonnen haben.
Hoffentlich ist dies eine ausreichende Demonstration, dass die Verwendung roundfzum Runden auf eine Anzahl von Dezimalstellen fehlerhaft ist und dass Sie snprintfstattdessen verwenden sollten. Wenn sich das für Sie wie ein schrecklicher Hack anfühlt, werden Sie vielleicht durch das Wissen beruhigt sein, dass es im Grunde das ist, was CPython tut .
float(unddouble) keine dezimalen Gleitkommazahlen sind - sie sind binäre Gleitkommazahlen -, sodass das Runden auf Dezimalstellen bedeutungslos ist. Sie können die Ausgabe jedoch runden.