4.8 – Числовые типы с плавающей точкой

Целочисленные типы отлично подходят для подсчета целых чисел, но иногда нам нужно хранить очень большие числа или числа с дробной частью. Переменная типа с плавающей точкой (запятой) – это переменная, которая может содержать действительное число, например 4320,0, -3,33 или 0,01226. «Плавающая» в названии «с плавающей точкой» указывает на то, что десятичная точка может «плавать»; то есть она может поддерживать переменное количество цифр до и после себя.

Существует три разных типа данных с плавающей точкой: float, double и long double. Как и в случае с целыми числами, C++ не определяет фактические размеры этих типов (но гарантирует минимальные размеры). В современных архитектурах представление с плавающей точкой почти всегда соответствует двоичному формату IEEE 754. В этом формате float составляет 4 байта, double – 8, а long double может быть эквивалентно double (8 байтов), 80 битам (часто с дополнением до 12 байтов) или 16 байтам.

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

Ниже показан пример определения чисел с плавающей запятой:

float fValue;
double dValue;
long double ldValue;

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

int x{5};      // 5 означает целое число
double y{5.0}; // 5.0 - литерал с плавающей точкой (отсутствие суффикса по умолчанию означает тип double)
float z{5.0f}; // 5.0 - литерал с плавающей точкой, суффикс f означает тип float

Обратите внимание, что по умолчанию литералы с плавающей точкой по умолчанию имеют тип double. Суффикс f используется для обозначения литерала типа float.

Печать чисел с плавающей точкой

Теперь рассмотрим следующую простую программу:

#include <iostream>
 
int main()
{
	std::cout << 5.0 << '\n';
	std::cout << 6.7f << '\n';
	std::cout << 9876543.21 << '\n';
}

Результаты работы этой, казалось бы, простой программы могут вас удивить:

5
6.7
9.87654e+06

В первом случае std::cout напечатал 5, хотя мы ввели 5.0. По умолчанию std::cout не будет печатать дробную часть числа, если она равна 0.

Во втором случае число печатается так, как мы и ожидали.

В третьем случае напечаталось число в экспоненциальном представлении (если вам нужно освежить в памяти экспоненциальное представление, смотрите урок «4.7 – Введение в экспоненциальную запись»).

Диапазоны значений типов с плавающей точкой

Предполагая, что используется представление IEEE 754:

80-битный тип с плавающей запятой – это своего рода историческая аномалия. На современных процессорах он обычно реализуется с использованием 12 или 16 байтов (что является более естественным размером для обработки процессорами).

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

Точность с типов плавающей запятой

Рассмотрим дробь 1/3. Десятичное представление этого числа – 0,33333333333333… с тройками, уходящими в бесконечность. Если бы вы писали это число на листе бумаги, ваша рука в какой-то момент устала бы, и вы, в конце концов, прекратили бы писать. И число, которое у вас осталось, будет близко к 0,3333333333…. (где 3-ки уходят в бесконечность), но не совсем.

На компьютере число бесконечной длины потребует для хранения бесконечной памяти, но обычно у нас есть только 4 или 8 байтов. Эта ограниченная память означает, что числа с плавающей запятой могут хранить только определенное количество значащих цифр – и что любые дополнительные значащие цифры теряются. Фактически сохраненное число будет близко к необходимому, но не точно.

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

При выводе чисел с плавающей точкой std::cout по умолчанию имеет точность 6, то есть предполагает, что все переменные с плавающей точкой имеют только до 6 значащих цифр (минимальная точность с плавающей точкой), и, следовательно, он будет отсекать всё, что идет дальше.

Следующая программа показывает усечение std::cout до 6 цифр:

#include <iostream>
 
int main()
{
    std::cout << 9.87654321f << '\n';
    std::cout << 987.654321f << '\n';
    std::cout << 987654.321f << '\n';
    std::cout << 9876543.21f << '\n';
    std::cout << 0.0000987654321f << '\n';
 
    return 0;
}

Эта программа выводит:

9.87654
987.654
987654
9.87654e+006
9.87654e-005

Обратите внимание, что каждое из напечатанных значений имеет только 6 значащих цифр.

Также обратите внимание, что std::cout в некоторых случаях переключился на вывод чисел в экспоненциальном представлении. В зависимости от компилятора показатель степени обычно дополняется до минимального количества цифр. Не беспокойтесь, 9.87654e+006 – это то же самое, что 9.87654e6, только с некоторым количеством дополнительных нулей. Минимальное количество отображаемых цифр показателя степени зависит от компилятора (Visual Studio использует 3, некоторые другие в соответствии со стандартом C99 используют 2).

Число цифр точности переменной с плавающей запятой зависит как от размера (у float точность меньше, чем у double), так и от конкретного сохраняемого значения (некоторые значения имеют большую точность, чем другие). Значения float имеют точность от 6 до 9 цифр, при этом большинство значений float имеют не менее 7 значащих цифр. Значения double имеют от 15 до 18 цифр точности, при этом большинство значений double имеют не менее 16 значащих цифр. Значения long double имеет минимальную точность 15, 18 или 33 значащих цифр в зависимости от того, сколько байтов этот тип занимает.

Мы можем переопределить точность по умолчанию, которую показывает std::cout, используя функцию манипулятора вывода с именем std::setprecision(). Манипуляторы вывода изменяют способ вывода данных и определяются в заголовке iomanip.

#include <iostream>
#include <iomanip> // для манипулятора вывода std::setprecision()
 
int main()
{
    std::cout << std::setprecision(16); // показать с точностью 16 цифр
    std::cout << 3.33333333333333333333333333333333333333f <<'\n'; // суффикс f означает float
    std::cout << 3.33333333333333333333333333333333333333 << '\n'; // отсутствие суффикса означает double
    return 0;
}

Вывод программы:

3.333333253860474
3.333333333333334

Поскольку с помощью std::setprecision() мы устанавливаем точность в 16 цифр, каждое из приведенных выше чисел печатается с 16 цифрами. Но, как видите, числа определенно неточны до 16 цифр! А поскольку числа float менее точны, чем числа double, число ошибок у float больше.

Проблемы с точностью влияют не только на дробные числа, они влияют на любое число со слишком большим количеством значащих цифр. Рассмотрим большое число:

#include <iomanip> // для std::setprecision()
#include <iostream>
 
int main()
{
    float f { 123456789.0f };          // f имеет 10 значащих цифр
    std::cout << std::setprecision(9); // чтобы показать 9 цифр в f
    std::cout << f << '\n';
    return 0;
}

Вывод программы:

123456792

123456792 больше, чем 123456789. Значение 123456789.0 имеет 10 значащих цифр, но значения float обычно имеют точность 7 цифр (и результат 123456792 точен только до 7 значащих цифр). Мы потеряли точность! Когда теряется точность из-за того, что число не может быть точно сохранено, это называется ошибкой округления.

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

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

С числами с плавающей запятой сложно работать из-за неочевидных различий между двоичными (как хранятся данные) и десятичными (как мы думаем) числами. Рассмотрим дробь 1/10. В десятичном формате ее легко представить как 0,1, и мы привыкли думать о 0,1 как о легко представимом числе с 1 значащей цифрой. Однако в двоичном формате 0,1 представлен бесконечной последовательностью: 0,00011001100110011… Из-за этого, когда мы присваиваем 0,1 числу с плавающей точкой, мы сталкиваемся с проблемами точности.

Эффект от этого можно увидеть в следующей программе:

#include <iomanip> // для std::setprecision()
#include <iostream>
 
int main()
{
    double d{0.1};
    std::cout << d << '\n'; // использовать точность cout по умолчанию, равную 6
    std::cout << std::setprecision(17);
    std::cout << d << '\n';
    return 0;
}

Эта программ выводит следующее:

0.1
0.10000000000000001

Как и ожидалось, в первой строке std::cout печатает 0,1.

Во второй строке, где std::cout показывает нам 17-значную точность, мы видим, что d на самом деле не совсем равно 0,1! Это связано с тем, что из-за ограниченной памяти double пришлось усекать приближение. В результате получается число с точностью до 16 значащих цифр (что гарантирует тип double), но это число не равно 0,1. Ошибки округления могут сделать число немного меньше или немного больше, в зависимости от того, где происходит усечение.

Ошибки округления также могут иметь неожиданные последствия:

#include <iomanip> // для std::setprecision()
#include <iostream>
 
int main()
{
    std::cout << std::setprecision(17);
 
    double d1{ 1.0 };
    std::cout << d1 << '\n';
	
    double d2{ 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 }; // должно быть равно 1.0
    std::cout << d2 << '\n';
}

1
0.99999999999999989

Хотя можно было ожидать, что d1 и d2 должны быть равны, мы видим, что это не так. Если бы мы сравнивали d1 и d2 в программе, программа, вероятно, не работала бы так, как ожидалось. Поскольку числа с плавающей запятой имеют тенденцию быть неточными, их сравнение обычно проблематично – мы обсудим эту тему (и решения) подробнее в уроке «5.6 – Операторы отношения и сравнение значений с плавающей запятой».

Последнее замечание об ошибках округления: математические операции (такие как сложение и умножение), как правило, приводят к увеличению ошибок округления. Таким образом, даже несмотря на то, что 0,1 имеет ошибку округления в 17-й значащей цифре, когда мы складываем 0,1 десять раз, ошибка округления добралась бы и до 16-й значащей цифры. Продолжение операций приведет к тому, что эта ошибка станет всё более значительной.

NaN и Inf

Существует две особые категории чисел с плавающей запятой. Первая – Inf, которая представляет бесконечность. Inf может быть положительной или отрицательной. Вторая – NaN, что означает «Not a Number» (не число). Существует несколько различных типов NaN (которые мы здесь обсуждать не будем). NaN и Inf доступны только в том случае, если компилятор для чисел с плавающей запятой использует определенный формат (IEEE 754). Если используется другой формат, следующий код приводит к неопределенному поведению.

Ниже приведена программа, показывающая все эти три категории чисел с плавающей точкой:

#include <iostream>
 
int main()
{
    double zero {0.0};
    double posinf { 5.0 / zero };  // положительная бесконечность
    std::cout << posinf << '\n';
 
    double neginf { -5.0 / zero }; // отрицательная бесконечность
    std::cout << neginf << '\n';
 
    double nan { zero / zero };   // не число (математически неверно)
    std::cout << nan << '\n';
 
    return 0;
}

И результаты работы этой программы при использовании Visual Studio 2008 в Windows:

1.#INF
-1.#INF
1.#IND

INF означает бесконечность, а IND означает неопределенность. Обратите внимание, что результаты печати Inf и NaN зависят от платформы, поэтому ваши результаты могут отличаться.

Заключение

Подводя итог, вы должны помнить две вещи о числах с плавающей запятой:

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

Теги