¿Hay una función para redondear un flotador en C o tengo que escribir la mía?

¿Hay una función para redondear un flotador en C o tengo que escribir la mía?

flotador conver = 45. 59 2346543;

Me gustaría redondear el valor real a un decimal, conver = 45. 6 .

Como mencionó Rob, es probable que solo desee imprimir el flotador en 1 lugar decimal. En este caso, puede hacer algo como lo siguiente:

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

Si realmente quiere redondear el valor almacenado, eso es un poco más complicado. Por un lado, su representación de un lugar decimal raramente tendrá un análogo exacto en coma flotante. Si solo quieres acercarte lo más posible, algo como esto podría hacer el truco:

 #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; } 

Dudo que este segundo ejemplo sea lo que estás buscando, pero lo incluí para completarlo. Si necesita representar sus números de esta manera internamente, y no solo en la salida, considere usar una representación de punto fijo en su lugar.

Claro, puedes usar roundf () . Si desea redondear a un decimal, entonces podría hacer algo como: roundf(10 * x) / 10

Solo para generalizar un poco la respuesta de Rob, si no lo está haciendo en la salida, aún puede usar la misma interfaz con sprintf() .

Creo que hay otra manera de hacerlo, sin embargo. Puedes probar ceil() y floor() para redondear hacia arriba y hacia abajo. Un buen truco es agregar 0.5, por lo que cualquier cosa por encima de 0.5 redondea hacia arriba, pero todo lo que está debajo se redondea hacia abajo. ceil() y floor() solo funcionan en double s sin embargo.

EDITAR: También, para flotantes, puede usar truncf() para truncar flotantes. El mismo truco de +0.5 debería funcionar para hacer un redondeo preciso.

Hay una función round() , también fround() , que redondeará al entero más cercano expresado como un doble. Pero eso no es lo que quieres.

Tuve el mismo problema y escribí esto:

 #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; } 

Para imprimir un valor redondeado, @Matt J responde bien la pregunta.

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

Como la mayoría de los puntos flotantes (FP) son basados ​​en binarios , el redondeo exacto a un lugar decimal no es posible cuando la respuesta matemáticamente correcta es x.1, x.2, ...

Convertir el número de FP a 0.1 más cercano es otro asunto.

Desbordamiento : los enfoques que primero escalan por 10 (o 100, 1000, etc.) pueden desbordarse para x grande.

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

Doble redondeo : Agregar 0.5f y luego usar floorf(x*10.0f + 0.5f)/10.0 devuelve el resultado incorrecto cuando la sum intermedia x*10.0f + 0.5f redondea a un nuevo entero.

 // 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; } 

Casting to int tiene el problema obvio cuando float x es mucho mayor que INT_MAX .


Usar roundf() y familia, disponible en es el mejor enfoque.

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

Para evitar usar el double , simplemente prueba si el número necesita redondeo.

 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); 

No te olvides de vincular con -lm. Ver también ceil (), floor () y trunc ().

puede usar #define round (a) (int) (a + 0.5) como macro, de modo que cada vez que escriba round (1.6) devuelva 2 y cada vez que escriba round (1.3) devuelva 1.