Ограничить точность с плавающей запятой?

round(x * 100) / 100.0

Если вы должны держать вещи плавающими:

roundf(x * 100) / 100.0

Гибкая версия с использованием функций стандартной библиотеки:

double GetFloatPrecision(double value, double precision)
{
    return (floor((value * pow(10, precision) + 0.5)) / pow(10, precision)); 
}

Если вы распечатываете его, вместо этого используйте любую доступную вам функцию форматирования печати.

In c++

cout << setprecision(2) << f; 

Для округления для отображения в графическом интерфейсе используйте std::ostringstream

Умножьте на 100, округлите до целого числа (как хотите), разделите на 100. Обратите внимание, что, поскольку 1/100 не может быть точно представлено в виде числа с плавающей запятой, рассмотрите возможность сохранения целых чисел с фиксированной точностью.

Для тех из вас, кто, как и я, гуглил, чтобы отформатировать поплавок в деньгах:

#include <iomanip>
#include <sstream>
#include <string>

std::string money_format (float val)
{
    std::ostringstream oss;

    oss << std::fixed << std::setfill ('0') << std::setprecision (2) << val;

    return oss.str();
}
// 12.3456 --> "12.35"
// 1.2 --> "1.20"

Вы должны вернуть его как строку. Вернув его обратно в поплавок, вы потеряете точность.

Не используйте поплавки. Используйте целые числа, хранящие количество центов, и печатайте десятичную точку перед двумя последними знаками, если вы хотите напечатать доллары. Плавающие числа почти всегда неверны для денег, если только вы не выполняете упрощенные расчеты (например, наивные экономические математические модели), где действительно имеет значение только величина чисел, и вы никогда не вычитаете близлежащие числа.

попробуйте использовать

std::cout<<std::setprecision(2)<<std::cout<<x;

должно работать, и появляются только 2 цифры после плавающей запятой.

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

#include <sstream>

template<typename T>
T toPrecision(T input, unsigned precision)
{
    static std::stringstream ss;

    T output;
    ss << std::fixed;
    ss.precision(precision);
    ss << input;
    ss >> output;
    ss.clear();

    return output;
}

template<unsigned P, typename T>
T toPrecision(T input) { return toPrecision(input, P); }

// compile-time version
double newValue = toPrecision<2>(5.9832346739); // newValue: 5.98
// run-time version
double newValue = toPrecision(3.1415, 2); // newValue: 3.14

Вы также можете добавить статические проверки для T и precision (в случае подписи времени компиляции).

Чтобы ограничить точность:
Если x — число с плавающей запятой, округление не выполняется:
(сдвиг вверх на 2 десятичных знака, удаление дроби, сдвиг вниз на 2 десятичных знака)

((int)(x*100.0)) / 100.0F

Плавающая с округлением:

((int)(x*100.0 + 0.5F)) / 100.0F

Двойной без округления:

((long int)(x*100.0)) / 100.0

Двойной с округлением:

((long int)(x*100.0 + 0.5)) / 100.0

Примечание. Поскольку x — это либо float, либо double, дробная часть всегда будет присутствовать. Это разница между тем, как представлен # (IEEE 754), и точностью #.
C99 поддерживает round()

Попробуйте это, это работает отлично

float=3576.7675745342556;
printf("%.2f",float);

изменить некоторые объекты в нем, чтобы увидеть и изучить код.