Utilizzare sempre la printffamiglia di funzioni per questo. Anche se si desidera ottenere il valore come float, è consigliabile utilizzare snprintfper ottenere il valore arrotondato come stringa e quindi analizzarlo nuovamente con 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;
}
Lo dico perché l'approccio mostrato dalla risposta attualmente più votata e molti altri qui - moltiplicando per 100, arrotondando al numero intero più vicino e quindi dividendolo di nuovo per 100 - è imperfetto in due modi:
- Per alcuni valori, arrotonderà nella direzione sbagliata perché la moltiplicazione per 100 modifica la cifra decimale determinando la direzione di arrotondamento da 4 a 5 o viceversa, a causa dell'imprecisione dei numeri in virgola mobile
- Per alcuni valori, moltiplicare e poi dividere per 100 non andata e ritorno, il che significa che anche se non si verificano arrotondamenti, il risultato finale sarà errato
Per illustrare il primo tipo di errore - talvolta la direzione di arrotondamento è errata - prova a eseguire questo programma:
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);
}
Vedrai questo output:
x: 0.01499999999999999944488848768742172978818416595459
Rounded with snprintf: 0.01000000000000000020816681711721685132943093776703
Rounded with round, then divided: 0.02000000000000000041633363423443370265886187553406
Si noti che il valore con cui abbiamo iniziato era inferiore a 0,015, quindi la risposta matematicamente corretta quando si arrotonda a 2 decimali è 0,01. Ovviamente, 0,01 non è esattamente rappresentabile come doppio, ma prevediamo che il nostro risultato sia il doppio più vicino a 0,01. L'uso snprintfci dà quel risultato, ma l'uso round(100 * x) / 100ci dà 0,02, che è sbagliato. Perché? Perché 100 * xci dà esattamente 1,5 come risultato. Moltiplicando per 100 cambia quindi la direzione corretta in cui arrotondare.
Per illustrare il secondo tipo di errore - il risultato a volte è sbagliato a causa * 100e / 100non è realmente inverso l'uno dall'altro - possiamo fare un esercizio simile con un numero molto grande:
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);
}
Il nostro numero ora non ha nemmeno una parte frazionaria; è un valore intero, appena memorizzato con type double. Quindi il risultato dopo l'arrotondamento dovrebbe essere lo stesso numero con cui abbiamo iniziato, giusto?
Se esegui il programma sopra, vedrai:
x: 8631192423766613.0
Rounded with snprintf: 8631192423766613.0
Rounded with round, then divided: 8631192423766612.0
Ops. Il nostro snprintfmetodo restituisce di nuovo il risultato giusto, ma l'approccio moltiplica, quindi arrotonda, quindi divide. Questo perché il valore matematicamente corretto di 8631192423766613.0 * 100, 863119242376661300.0non è esattamente rappresentabile come doppio; il valore più vicino è 863119242376661248.0. Quando lo dividi per 100, ottieni8631192423766612.0 - un numero diverso da quello con cui hai iniziato.
Speriamo che sia una dimostrazione sufficiente che l'uso roundfper arrotondare a un numero di cifre decimali è rotto e che snprintfinvece dovresti usare . Se ti sembra un orribile hack, forse sarai rassicurato dalla consapevolezza che è sostanzialmente ciò che fa CPython .
float(edouble) non sono virgola mobile decimale - sono virgola mobile binaria - quindi arrotondare a posizioni decimali non ha senso. È possibile arrotondare l'output, tuttavia.