如果只是为了输出而四舍五入，则“%.”2f”格式的字符串确实是正确的答案。然而，如果你真的想要四舍五入浮点值以进行进一步的计算，像下面这样的方法是可行的:

#include <math.h>

float val = 37.777779;

float rounded_down = floorf(val * 100) / 100;   /* Result: 37.77 */
float nearest = roundf(val * 100) / 100;  /* Result: 37.78 */
float rounded_up = ceilf(val * 100) / 100;      /* Result: 37.78 */

请注意，您可能想要选择三种不同的舍入规则:向下舍入(即，在小数点后两位截断)、四舍五入到最接近的位置和向上舍入。通常，你要绕到最近的地方。

正如其他几个人指出的那样，由于浮点表示法的特殊性，这些四舍五入的值可能并不完全是“明显的”十进制值，但它们非常非常接近。

有关舍入的更多信息，特别是舍入到最近的平局规则，请参阅维基百科关于舍入的文章。

printf("%.2f", 37.777779);

如果你想写入C-string:

char number[24]; // dummy size, you should take care of the size!
sprintf(number, "%.2f", 37.777779);

假设你谈论的是打印的值，那么Andrew Coleson和AraK的答案是正确的:

printf("%.2f", 37.777779);

但请注意，如果你的目标是将数字四舍五入到37.78以供内部使用(例如与另一个值进行比较)，那么这不是一个好主意，因为浮点数的工作方式:你通常不想对浮点数进行相等比较，而是使用一个目标值+/-一个sigma值。或者将数字编码为具有已知精度的字符串，并进行比较。

请参阅Greg Hewgill对相关问题的回答中的链接，其中还涵盖了为什么不应该使用浮点数进行财务计算。

为此，始终使用printf系列函数。即使你想获得浮点值，你最好使用snprintf以字符串形式获得四舍五入的值，然后用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;
}

我这么说是因为目前投票最多的答案和其他几个答案所显示的方法- 乘以100，四舍五入到最接近的整数，然后再除以100——在两个方面有缺陷:

对于某些值，由于浮点数的不精确性，它会向错误的方向四舍五入，因为乘以100会将决定四舍五入方向的十进制数字从4更改为5，反之亦然 对于某些值，乘以再除以100并不会发生往返，这意味着即使没有发生舍入，最终结果也会是错误的

为了说明第一种错误-舍入方向有时是错误的-试着运行这个程序:

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

你会看到这样的输出:

x: 0.01499999999999999944488848768742172978818416595459
Rounded with snprintf: 0.01000000000000000020816681711721685132943093776703
Rounded with round, then divided: 0.02000000000000000041633363423443370265886187553406

请注意，我们开始时的值小于0.015，因此当四舍五入到小数点后两位时，数学上的正确答案是0.01。当然，0.01不能精确地表示为二重数，但我们期望我们的结果是最接近0.01的二重数。使用snprintf会得到这个结果，但是使用round(100 * x) / 100会得到0.02，这是错误的。为什么?因为100 * x的结果正好是1.5。因此，乘以100将正确的方向改为四舍五入。

为了说明第二种错误——有时结果是错误的，因为* 100和/ 100不是彼此的倒数——我们可以用一个非常大的数字做类似的练习:

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

我们的数字甚至没有小数部分;它是一个整数值，只是以double类型存储。四舍五入后的结果应该和一开始的数一样，对吧?

如果你运行上面的程序，你会看到:

x: 8631192423766613.0
Rounded with snprintf: 8631192423766613.0
Rounded with round, then divided: 8631192423766612.0

哦。我们的snprintf方法再次返回正确的结果，但是先乘后舍再除的方法失败了。这是因为数学上正确的值8631192423766613.0 * 100,863119242376661300.0不能精确地表示为double;最接近的值是863119242376661248.0。当你把它除以100，你得到8631192423766612.0 -一个不同于你开始的数字。

希望这足以说明使用roundf舍入到小数点后几位是错误的，应该使用snprintf。如果你觉得这是一个可怕的黑客，也许你会放心，因为这基本上就是CPython所做的。

Let me first attempt to justify my reason for adding yet another answer to this question. In an ideal world, rounding is not really a big deal. However, in real systems, you may need to contend with several issues that can result in rounding that may not be what you expect. For example, you may be performing financial calculations where final results are rounded and displayed to users as 2 decimal places; these same values are stored with fixed precision in a database that may include more than 2 decimal places (for various reasons; there is no optimal number of places to keep...depends on specific situations each system must support, e.g. tiny items whose prices are fractions of a penny per unit); and, floating point computations performed on values where the results are plus/minus epsilon. I have been confronting these issues and evolving my own strategy over the years. I won't claim that I have faced every scenario or have the best answer, but below is an example of my approach so far that overcomes these issues:

假设小数点后6位被认为是浮点数/双精度数计算的足够精度(这是对特定应用的任意决定)，使用以下舍入函数/方法:

double Round(double x, int p)
{
    if (x != 0.0) {
        return ((floor((fabs(x)*pow(double(10.0),p))+0.5))/pow(double(10.0),p))*(x/fabs(x));
    } else {
        return 0.0;
    }
}

四舍五入到小数点后2位的结果可以这样表示:

double val;
// ...perform calculations on val
String(Round(Round(Round(val,8),6),2));

对于val = 6.825，结果是预期的6.83。

对于val = 6.824999，结果为6.82。这里假设计算结果正好是6.824999，小数点后第7位为零。

对于val = 6.8249999，结果为6.83。在这种情况下，小数点后第7位是9，使Round(val,6)函数给出预期的结果。在这种情况下，后面可能有任意数量的9。

对于val = 6.824999499999，结果为6.83。作为第一步，舍入到小数点后第8位，即Round(val,8)，解决了一个棘手的情况，即计算的浮点结果计算为6.8249995，但在内部表示为6.824999499999....

最后，问题中的例子…Val = 37.777779的结果是37.78。

这种方法可以进一步概括为:

double val;
// ...perform calculations on val
String(Round(Round(Round(val,N+2),N),2));

其中N是浮点数/双精度数上所有中间计算所要维持的精度。这也适用于负值。我不知道这种方法在数学上是否适用于所有可能性。

这个怎么样:

float value = 37.777779;
float rounded = ((int)(value * 100 + .5) / 100.0);