Вещественные числа

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

JavaC++PythonОтличия

double используют для хранения вещественных чисел.

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

Литералы типа double обычно записывают с точкой. Также можно использовать экспоненциальную запись с буквой E.

Тип double

Если в выражении участвуют значения типа double, результат тоже будет иметь тип double.

Выражение	Значение	Комментарий
`1.5 + 0.25`	`1.75`	сложение вещественных чисел
`1.5 - 0.25`	`1.25`	вычитание вещественных чисел
`1.5 * 2.0`	`3.0`	умножение вещественных чисел
`5.0 / 3.0`	`1.6666666666666667`	результат может быть приближённым
`5.5 % 2.0`	`1.5`	остаток тоже может быть дробным
`-1.0 / 0.0`	`-Infinity`	для `double` это не ошибка
`0.0 / 0.0`	`NaN`	специальное значение «не число»

Обратите внимание: при делении двух double дробная часть сохраняется.

Чтобы получить вещественный результат, хотя бы одно число в делении должно иметь тип double.

System.out.println(7 / 2);       // 3
System.out.println(7.0 / 2.0);   // 3.5

Ввод-вывод double

Для вывода double используют те же System.out.print(...) и System.out.println(...), что и для строк.

Обычный print и println выводят число как есть.

Если нужно вывести число с определённым количеством цифр после точки, используют printf().

Вызов	Что делает
`System.out.printf("%.2f", value)`	Выводит число, оставляя `2` цифры после точки

Основной способ вывода double через printf

double value = 3.14659;

System.out.println(value);

System.out.printf("%.1f", value);
System.out.println();

System.out.printf("%.2f", value);
System.out.println();

System.out.printf("%.3f", value);

Вывод

В записи %.2f число 2 означает: вывести 2 цифры после точки. При этом printf() округляет число только при выводе. Значение переменной не меняется.

Для ввода вещественных чисел в Java обычно используют Scanner.

Вызов	Что считывает
`in.nextDouble()`	Следующее вещественное число типа `double`

Основные способы ввода double

В вещественных числах используют точку, а не запятую.

double first = in.nextDouble();
double second = in.nextDouble();

System.out.println(first + second);

Ввод

2.5 1.75

Вывод

4.25

Смешанные выражения

Если в выражении есть и int, и double, результат становится double.

int n = 5;
double t = 2.5;

System.out.println(n + t); // 7.5
System.out.println(n * t); // 12.5

Сравнение чисел double

Для чисел типа double после вычислений лучше не проверять точное равенство через ==.

double a = 0.1 + 0.2;
double b = 0.3;

System.out.println(a);
System.out.println(a == b);

Вывод

0.30000000000000004
false

Хотя на вид кажется, что должно получиться 0.3, после вычисления значение может отличаться совсем немного. Поэтому для double проверка через == после вычислений может дать неожиданный результат.

Округление

Для округления часто используют Math.round, Math.floor, Math.ceil.

double x = 3.56;

System.out.println(Math.round(x)); // 4
System.out.println(Math.floor(x)); // 3.0
System.out.println(Math.ceil(x));  // 4.0

Примеры

Среднее арифметическое:

double a = 10.0;
double b = 20.0;
double c = 25.0;

double avg = (a + b + c) / 3.0;
System.out.println(avg);

Процент от числа:

double value = 250.0;
double p = 12.0;

double part = value * p / 100.0;
System.out.println(part);

Типы дробных чисел

В C++ для дробных значений чаще всего используют double.

double x = 7.5;
double y = 3.0;

Также есть:

float — обычно меньше точность;
long double — обычно больше точность.

Ввод и вывод

Ввод дробного числа:

double x;
cin >> x;

Обычный вывод:

cout << x << "\n";

Вывод с фиксированным числом знаков после запятой:

#include <iomanip>

cout << fixed << setprecision(2) << x << "\n";

Деление

Деление double / double сохраняет дробную часть:

double a = 7.0, b = 3.0;
cout << a / b << "\n"; // 2.33333...

Если оба операнда целые, деление будет целочисленным:

int a = 7, b = 3;
cout << a / b << "\n";                        // 2
cout << a / 3.0 << "\n";                      // 2.33333...
cout << static_cast<double>(a) / b << "\n";  // 2.33333...

Точность и сравнение

double хранит число приближенно, поэтому точное сравнение дробей часто ненадежно.

double x = 0.1 + 0.2;
double y = 0.3;
cout << (x == y) << "\n"; // чаще всего 0 (false)

Обычно сравнивают через маленькое число eps:

#include <cmath>

const double eps = 1e-9;
if (fabs(x - y) < eps) {
    cout << "equal\n";
}

Округление

Функции из <cmath>:

round(x) — округление к ближайшему целому;
floor(x) — вниз;
ceil(x) — вверх.

#include <cmath>

double x = 3.56;
cout << round(x) << "\n"; // 4
cout << floor(x) << "\n"; // 3
cout << ceil(x) << "\n";  // 4

Примеры

Среднее арифметическое:

double a = 10.0, b = 20.0, c = 25.0;
double avg = (a + b + c) / 3.0;
cout << avg << "\n";

Процент от числа:

double value = 250.0;
double p = 12.0;
double part = value * p / 100.0;
cout << part << "\n";

По материалам:
М. Густокашин. Введение в программирование на языке C++. Сириус Курсы. Перейти к курсу.

Тип

В Python дробные числа – это float.

x = 7.5
y = 3.0
print(x + y)  # 10.5

Деление

Оператор / всегда даёт дробный результат.

a = 7
b = 3

print(a / b)   # 2.3333333333333335
print(a // b)  # 2

Округление и вывод

Округление: round(x).

x = 3.56
print(round(x))  # 4

Вывод с количеством знаков часто делают через форматирование.

import math

p = math.pi
print(f"pi = {p:.2f}")
print(f"pi = {p:.4f}")

Примеры

Среднее арифметическое:

a = 10.0
b = 20.0
c = 25.0

avg = (a + b + c) / 3.0
print(avg)

Перевод градусов в радианы:

\[ \text{rad} = \text{deg} \cdot \frac{\pi}{180} \]

import math

deg = 60.0
rad = deg * math.pi / 180.0
print(rad)

Тип дробных чисел

Язык	Тип	Где часто спотыкаются
Java	`double`	целочисленное деление `int / int` даёт `int`
C++	`double`	целочисленное деление `int / int` даёт `int`
Python	`float`	`/` всегда дробное, а `//` – целая часть

Как получить дробный результат при делении целых

Java: сделать один операнд double.

int a = 7, b = 3;
System.out.println(a / 3.0);
System.out.println((double) a / b);

C++: сделать один операнд double.

int a = 7, b = 3;
std::cout << (a / 3.0) << "\n";
std::cout << (static_cast<double>(a) / b) << "\n";

Python: / уже даёт дробный результат.

a = 7
b = 3
print(a / b)

Вывод с количеством знаков после запятой

Java: printf("%.2f").

C++: std::fixed << std::setprecision(2).

Python: f"{x:.2f}".

Во всех трёх языках double/float хранят число приближённо, поэтому сравнение дробных чисел на точное равенство часто даёт неожиданные результаты.