Sempre use a printffamília de funções para isso. Mesmo se você quiser obter o valor como flutuante, é melhor usá-lo snprintfpara obter o valor arredondado como uma sequência e analisá-lo novamente com 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;
}
Digo isso porque a abordagem mostrada pela resposta atualmente mais votada e várias outras aqui - multiplicando por 100, arredondando para o número inteiro mais próximo e depois dividindo por 100 novamente - é falha de duas maneiras:
- Para alguns valores, ele será arredondado na direção errada porque a multiplicação por 100 altera o dígito decimal, determinando a direção do arredondamento de 4 para 5 ou vice-versa, devido à imprecisão de números de ponto flutuante
- Para alguns valores, multiplicar e depois dividir por 100 não faz ida e volta, o que significa que, mesmo que nenhum arredondamento ocorra, o resultado final estará errado
Para ilustrar o primeiro tipo de erro - a direção do arredondamento às vezes está errada - tente executar este programa:
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);
}
Você verá esta saída:
x: 0.01499999999999999944488848768742172978818416595459
Rounded with snprintf: 0.01000000000000000020816681711721685132943093776703
Rounded with round, then divided: 0.02000000000000000041633363423443370265886187553406
Observe que o valor com o qual começamos era menor que 0,015 e, portanto, a resposta matematicamente correta ao arredondá-lo para 2 casas decimais é 0,01. Obviamente, 0,01 não é exatamente representável como um dobro, mas esperamos que nosso resultado seja o dobro mais próximo de 0,01. Usar snprintfnos dá esse resultado, mas usar round(100 * x) / 100nos dá 0,02, o que está errado. Por quê? Porque 100 * xnos dá exatamente 1,5 como resultado. Multiplicar por 100 altera a direção correta para arredondar.
Para ilustrar o segundo tipo de erro - o resultado, às vezes, é errado devido * 100e / 100não é realmente um inverso um do outro - podemos fazer um exercício semelhante com um número muito 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);
}
Nosso número agora nem tem uma parte fracionária; é um valor inteiro, apenas armazenados com o tipo double. Então o resultado após o arredondamento deve ser o mesmo número com o qual começamos, certo?
Se você executar o programa acima, verá:
x: 8631192423766613.0
Rounded with snprintf: 8631192423766613.0
Rounded with round, then divided: 8631192423766612.0
Opa Nosso snprintfmétodo retorna o resultado certo novamente, mas a abordagem de multiplicar, arredondar e dividir falha. Isso porque o valor matematicamente correta de 8631192423766613.0 * 100, 863119242376661300.0, não é exatamente representável como um duplo; o valor mais próximo é 863119242376661248.0. Quando você divide isso de volta por 100, obtém 8631192423766612.0- um número diferente do que você começou.
Espero que seja uma demonstração suficiente de que o uso roundfpara arredondar para um número de casas decimais está quebrado e que você deve usá-lo snprintf. Se isso parecer um truque horrível para você, talvez você fique tranquilo ao saber que é basicamente o que o CPython faz .
float(edouble) não são vírgulas flutuantes decimais - elas são vírgulas flutuantes binárias -, portanto, o arredondamento para as casas decimais não faz sentido. Você pode arredondar a saída, no entanto.