Utilisez toujours la printffamille de fonctions pour cela. Même si vous souhaitez obtenir la valeur sous forme de flottant, il vaut mieux utiliser snprintfpour obtenir la valeur arrondie sous forme de chaîne, puis l'analyser à nouveau avec 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;
}
Je dis cela parce que l'approche montrée par la réponse actuellement la plus votée et plusieurs autres ici - multiplier par 100, arrondir à l'entier le plus proche, puis diviser par 100 à nouveau - est défectueuse de deux manières:
- Pour certaines valeurs, il arrondira dans la mauvaise direction car la multiplication par 100 modifie le chiffre décimal déterminant la direction d'arrondi de 4 à 5 ou vice versa, en raison de l'imprécision des nombres à virgule flottante
- Pour certaines valeurs, la multiplication puis la division par 100 ne sont pas aller-retour, ce qui signifie que même si aucun arrondi n'a lieu, le résultat final sera erroné
Pour illustrer le premier type d'erreur - la direction d'arrondi étant parfois erronée - essayez d'exécuter ce programme:
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);
}
Vous verrez cette sortie:
x: 0.01499999999999999944488848768742172978818416595459
Rounded with snprintf: 0.01000000000000000020816681711721685132943093776703
Rounded with round, then divided: 0.02000000000000000041633363423443370265886187553406
Notez que la valeur avec laquelle nous avons commencé était inférieure à 0,015, et donc la réponse mathématiquement correcte lors de l'arrondi à 2 décimales est 0,01. Bien sûr, 0,01 n'est pas exactement représentable comme un double, mais nous nous attendons à ce que notre résultat soit le double le plus proche de 0,01. L'utilisation snprintfnous donne ce résultat, mais l'utilisation round(100 * x) / 100nous donne 0,02, ce qui est faux. Pourquoi? Parce que cela 100 * xnous donne exactement 1,5 comme résultat. La multiplication par 100 change donc la direction correcte pour arrondir.
Pour illustrer le deuxième type d'erreur - le résultat étant parfois erroné à cause de * 100et / 100pas vraiment inverses les uns des autres - nous pouvons faire un exercice similaire avec un très grand nombre:
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);
}
Notre nombre n'a désormais même plus de partie fractionnaire; c'est une valeur entière, juste stockée avec le typedouble . Donc, le résultat après arrondi devrait être le même nombre que celui avec lequel nous avons commencé, non?
Si vous exécutez le programme ci-dessus, vous verrez:
x: 8631192423766613.0
Rounded with snprintf: 8631192423766613.0
Rounded with round, then divided: 8631192423766612.0
Oups. Notre snprintfméthode renvoie à nouveau le bon résultat, mais l'approche multiplier puis arrondir puis diviser échoue. En effet , la valeur mathématiquement correcte 8631192423766613.0 * 100, 863119242376661300.0n'est pas exactement représentable comme un double; la valeur la plus proche est 863119242376661248.0. Lorsque vous divisez cela par 100, vous obtenez 8631192423766612.0- un nombre différent de celui avec lequel vous avez commencé.
J'espère que c'est une démonstration suffisante que l'utilisation roundfde l'arrondi à un certain nombre de décimales est rompue et que vous devriez utiliser à la snprintfplace. Si cela vous semble un horrible hack, vous serez peut-être rassuré par la connaissance que c'est essentiellement ce que fait CPython .
float(etdouble) ne sont pas des virgules flottantes décimales - ce sont des virgules flottantes binaires - donc l'arrondi aux positions décimales n'a pas de sens. Vous pouvez cependant arrondir la sortie.