C’è una funzione per arrotondare un float in C o devo scrivere il mio?

C’è una funzione per arrotondare un float in C o devo scrivere il mio?

float conver = 45. 59 2346543;

Vorrei arrotondare il valore reale a una cifra decimale, conver = 45. 6 .

Come detto da Rob, probabilmente si desidera stampare il float al 1 decimale. In questo caso, puoi fare qualcosa di simile al seguente:

#include  #include  int main() { float conver = 45.592346543; printf("conver is %0.1f\n",conver); return 0; } 

Se vuoi effettivamente arrotondare il valore memorizzato, è un po ‘più complicato. Per esempio, la tua rappresentazione con un solo decimale raramente avrà un analogico esatto in virgola mobile. Se vuoi semplicemente avvicinarti il ​​più ansible, qualcosa del genere potrebbe fare il trucco:

 #include  #include  #include  int main() { float conver = 45.592346543; printf("conver is %0.1f\n",conver); conver = conver*10.0f; conver = (conver > (floor(conver)+0.5f)) ? ceil(conver) : floor(conver); conver = conver/10.0f; //If you're using C99 or better, rather than ANSI C/C89/C90, the following will also work. //conver = roundf(conver*10.0f)/10.0f; printf("conver is now %f\n",conver); return 0; } 

Dubito che questo secondo esempio sia quello che stai cercando, ma l’ho incluso per completezza. Se è necessario rappresentare i numeri in questo modo internamente, e non solo sull’output, considerare l’utilizzo di una rappresentazione a virgola fissa .

Certo, puoi usare roundf () . Se vuoi arrotondare a un decimale, puoi fare qualcosa come: roundf(10 * x) / 10

Solo per generalizzare la risposta di Rob un po ‘, se non lo stai facendo in uscita, puoi comunque usare la stessa interfaccia con sprintf() .

Penso che ci sia un altro modo per farlo, però. Puoi provare ceil() e floor() per arrotondare su e giù. Un bel trucco è aggiungere 0,5, quindi qualcosa di più di 0.5 rounds, ma tutto sotto di esso arrotonda. ceil() e floor() funzionano solo su double s.

EDIT: Inoltre, per i float, puoi usare truncf() per troncare i float. Lo stesso trucco +0.5 dovrebbe funzionare per arrotondare in modo accurato.

Esiste una funzione round() , anche fround() , che arrotonderà al numero intero più vicino express come double. Ma non è quello che vuoi.

Ho avuto lo stesso problema e ho scritto questo:

 #include  double db_round(double value, int nsig) /* =============== ** ** Rounds double  to  significant figures. Always rounds ** away from zero, so -2.6 to 1 sig fig will become -3.0. ** **  should be in the range 1 - 15 */ { double a, b; long long i; int neg = 0; if(!value) return value; if(value < 0.0) { value = -value; neg = 1; } i = nsig - log10(value); if(i) a = pow(10.0, (double)i); else a = 1.0; b = value * a; i = b + 0.5; value = i / a; return neg ? -value : value; } 

Per stampare un valore arrotondato, @Matt J risponde alla domanda.

 float x = 45.592346543; printf("%0.1f\n", x); // 45.6 

Poiché la maggior parte del floating point (FP) è basata su binari , l’ arrotondamento esatto a una posizione decimale non è ansible quando la risposta matematicamente corretta è x.1, x.2, ...

Per convertire il numero FP in 0.1 è un’altra questione.

Overflow : si avvicina alla prima scala per 10 (o 100, 1000, ecc.) Che può traboccare per x grande.

 float round_tenth1(float x) { x = x * 10.0f; ... } 

Doppio arrotondamento : l’aggiunta di 0.5f e l’utilizzo di floorf(x*10.0f + 0.5f)/10.0 restituisce il risultato errato quando la sum intermedia x*10.0f + 0.5f raggiunge un nuovo numero intero.

 // Fails to round 838860.4375 correctly, comes up with 838860.5 // 0.4499999880790710449 fails as it rounds to 0.5 float round_tenth2(float x) { if (x < 0.0) { return ceilf(x*10.0f + 0.5f)/10.0f; } return floorf(x*10.0f + 0.5f)/10.0f; } 

Il lancio su int ha il problema ovvio quando float x è molto maggiore di INT_MAX .


Usare roundf() e famiglia, disponibile in è l'approccio migliore.

 float round_tenthA(float x) { double x10 = 10.0 * x; return (float) (round(x10)/10.0); } 

Per evitare di usare il double , prova semplicemente se il numero ha bisogno di arrotondare.

 float round_tenthB(float x) { const float limit = 1.0/FLT_EPSILON; if (fabsf(x) < limit) { return roundf(x*10.0f)/10.0f; } return x; } 
 #include  double round(double x); float roundf(float x); 

Non dimenticare di collegarti con -lm. Vedi anche ceil (), floor () e trunc ().

puoi usare #define round (a) (int) (a + 0.5) come macro così ogni volta che scrivi round (1.6) restituisce 2 e ogni volta che scrivi round (1.3) restituisce 1.