ого ответа на этот вопрос. В идеальном мире округление не имеет большого значения. Однако в реальных системах вам, возможно, придется столкнуться с несколькими проблемами, которые могут привести к округлению, которое может не соответствовать вашим ожиданиям. Например, вы можете выполнять финансовые расчеты, где окончательные результаты округляются и отображаются для пользователей в виде 2 десятичных знаков; эти же значения хранятся с фиксированной точностью в базе данных, которая может содержать более 2 десятичных разрядов (по разным причинам; оптимального количества мест для хранения не существует ... зависит от конкретных ситуаций, которые должна поддерживать каждая система, например, крошечные предметы, цены на которые являются доли копейки на единицу); и вычисления с плавающей запятой, выполняемые для значений, где результаты плюс / минус эпсилон. Я сталкиваюсь с этими проблемами и разрабатываю свою собственную стратегию на протяжении многих лет. Я выиграл'Не утверждаю, что я сталкивался с каждым сценарием или имею лучший ответ, но ниже приведен пример моего подхода, который преодолевает эти проблемы:

Предположим, что 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) функция, чтобы дать ожидаемый результат. В этом случае может быть любое количество трейлингов9s.

За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 - точность, которая должна поддерживаться для всех промежуточных вычислений для чисел с плавающей запятой / двойников. Это работает и на отрицательных значениях. Я не знаю, является ли этот подход математически правильным для всех возможностей.

#define roundz(x,d) ((floor(((x)*pow(10,d))+.5))/pow(10,d))

a = 8.000000
sqrt(a) = r = 2.828427
roundz(r,2) = 2.830000
roundz(r,3) = 2.828000
roundz(r,5) = 2.828430

если выИспользуя C ++, вы можете просто создать такую функцию:

string prd(const double x, const int decDigits) {
    stringstream ss;
    ss << fixed;
    ss.precision(decDigits); // set # places after decimal
    ss << x;
    return ss.str();
}

Вы можете вывести любой двойнойmyDouble сn ставит после десятичной точки такой код:

std::cout << prd(myDouble,n);

Вы все еще можете использовать:

float ceilf(float x); // don't forget #include <math.h> and link with -lm.
</math.h>

пример:

float valueToRound = 37.777779;
float roundedValue = ceilf(valueToRound * 100) / 100;

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

Если вы хотите написать в C-строку:

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

float roundf(float x)

Функции округления округляют свой аргумент до ближайшего целочисленного значения в формате с плавающей запятой, округляя полпути до нуля, независимо от текущего направления округления. " C11dr §7.12.9.5

#include <math.h>
float y = roundf(x * 100.0f) / 100.0f; 
</math.h>

В зависимости от вашегоfloat реализации, цифры, которые могут показаться на полпути не являются. поскольку плавающая точка обычно ориентирована на базу-2. Далее точно округление до ближайшего0.01 на все "наполовину" случаи самые сложные.

void r100(const char *s) {
  float x, y;
  sscanf(s, "%f", &x);
  y = round(x*100.0)/100.0;
  printf("%6s %.12e %.12e\n", s, x, y);
}

int main(void) {
  r100("1.115");
  r100("1.125");
  r100("1.135");
  return 0;
}

 1.115 1.115000009537e+00 1.120000004768e+00  
 1.125 1.125000000000e+00 1.129999995232e+00
 1.135 1.134999990463e+00 1.139999985695e+00

Хотя "1,115" является "наполовину" между 1.11 и 1.12, при конвертации вfloat, значение1.115000009537... и больше ненаполовину", но ближе к 1.12 и округляет до ближайшегоfloat из "1.120000004768...

1,125" является "наполовину" между 1.12 и 1.13, при конвертации вfloat, значение точно1.125 и является "наполовину", Это округляется к 1.13 из-за связей к четному правилу и округляется до ближайшегоfloat из1.129999995232...

Хотя "1,135" является "наполовину" между 1,13 и 1,14, при конвертации вfloat, значение1.134999990463... и больше ненаполовину", но ближе к 1.13 и округляет до ближайшегоfloat из1.129999995232...

Если код используется

y = roundf(x*100.0f)/100.0f;

Хотя "1,135" является "наполовину" между 1,13 и 1,14, при конвертации вfloat, значение1.134999990463... и больше ненаполовину", но ближе к 1.13 ноневерно раунды вfloat из1.139999985695... из-за более ограниченной точностиfloat противdouble, Это неправильное значение может рассматриваться как правильное, в зависимости от целей кодирования.

float другомуfloat потому что округлыеfloat может не быть представимым (ограничение чисел с плавающей точкой). Например, допустим, вы округлили с 37,777779 до 37,78, но ближайшим представимым числом является 37,781.

Тем не менее, выМожно "круглыйfloat с помощью функции форматирования строки.

double f_round(double dval, int n)
{
    char l_fmtp[32], l_buf[64];
    char *p_str;
    sprintf (l_fmtp, "%%.%df", n);
    if (dval>=0)
            sprintf (l_buf, l_fmtp, dval);
    else
            sprintf (l_buf, l_fmtp, dval);
    return ((double)strtod(l_buf, &p_str));

}

n это число десятичных знаков

пример:

double d = 100.23456;

printf("%f", f_round(d, 4));// result: 100.2346

printf("%f", f_round(d, 2));// result: 100.23

это в свой заголовок / существо файла

#define ROUNDF(f, c) (((float)((int)((f) * (c))) / (c)))

Вот пример:

float x = ROUNDF(3.141592, 100)

х равен 3,14 :)

эта функция принимает число и точность и возвращает округленное число

float roundoff(float num,int precision)
{
      int temp=(int )(num*pow(10,precision));
      int num1=num*pow(10,precision+1);
      temp*=10;
      temp+=5;
      if(num1>=temp)
              num1+=10;
      num1/=10;
      num1*=10;
      num=num1/pow(10,precision+1);
      return num;
}

он преобразует число с плавающей точкой в int, сдвигая точку влево и проверяя условие больше пяти

"%.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 */
</math.h>

Обратите внимание, что есть три различных правила округления, которые вы можете выбрать: округление в меньшую сторону (т.е. усечение после двух десятичных знаков), округление до ближайшего и округление в большую сторону. Обычно вы хотите округлить до ближайшего.

Как отметили некоторые другие, из-за причуд представления с плавающей запятой, эти округленные значения могут быть не совсем "очевидно» десятичные значения, но они будут очень и очень близки.

Для получения гораздо (намного!) Дополнительной информации о округлении, и особенно о правилах разрыва связи для округления до ближайшего, см.статья в Википедии о округлении.

что выговорим о значении для печати, тоЭндрю Колсон а такжеарак»ответ правильный:

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

Но учтите, что если выповторно округлить число до точно 37,78 для внутреннего использования (например, сравнить с другим значением), тогда это не 'Это хорошая идея, так как числа с плавающей запятой работают: вы обычно нене хочу сравнивать равенство для чисел с плавающей запятой, вместо этого используйте целевое значение +/- сигма-значение. Или закодируйте число в виде строки с известной точностью и сравните это.

Смотрите ссылку вГрег Хьюгиллответ на связанный вопрос, который также охватывает, почему вы не должныt использовать плавающую точку для финансовых расчетов.

/* Function to control # of decimal places to be output for x */
double showDecimals(const double& x, const int& numDecimals) {
    int y=x;
    double z=x-y;
    double m=pow(10,numDecimals);
    double q=z*m;
    double r=round(q);

    return static_cast<double>(y)+(1.0/m)*r;
}
</double>

затемstd::cout << showDecimals(37.777779,2); будет производить: 37,78.

Очевидно, ты неМне действительно нужно создать все 5 переменных в этой функции, но я оставляю их там, чтобы вы могли видеть логику. Возможно, есть более простые решения, но это хорошо работает для меня - тем более что это позволяет мне корректировать количество цифр после десятичного знака по мере необходимости.

Как насчет этого:

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

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