Арифметические операторы в C++

Арифметические операторы

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

В C++ основные арифметические операторы:

Оператор	Назначение	Пример
`+`	Сложение	`5 + 3`
`-`	Вычитание	`5 - 3`
`*`	Умножение	`5 * 3`
`/`	Деление	`6 / 3`
`%`	Остаток от деления целых чисел	`7 % 3`
`++`	Увеличение на единицу	`value++`
`--`	Уменьшение на единицу	`value--`

Сложение (`+`)

Оператор + складывает два значения и возвращает результат.

1int a = 10;2int b = 5;34int result = a + b;

В переменной result будет храниться значение 15.

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

 1#include <iostream> 2 3int main() { 4    int health = 75; 5    int bonus = 20; 6 7    std::cout << health + bonus << '\n'; 8 9    return 0;10}

Вывод:

Вычитание (`-`)

Оператор - вычитает второе значение из первого.

1int health = 100;2int damage = 25;34int remainingHealth = health - damage;

После вычисления remainingHealth будет равен 75.

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

1int money = 500;2int purchasePrice = 150;34money = money - purchasePrice;

Теперь в переменной money хранится 350.

Умножение (`*`)

Оператор * умножает два значения.

1int price = 50;2int quantity = 4;34int total = price * quantity;

Результат — 200.

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

1double speed = 3.5;2double time = 4.0;34double distance = speed * time;

В переменной distance будет храниться 14.0.

Деление (`/`)

Оператор / делит первое значение на второе.

1int a = 20;2int b = 4;34int result = a / b;

Результат — 5.

Однако при делении целых чисел важно учитывать особенность C++: дробная часть результата отбрасывается.

1int result = 7 / 2;

В результате переменная result получит значение 3, а не 3.5.

Если необходимо получить дробный результат, используй float или double.

1double result = 7.0 / 2.0;

Результат — 3.5.

Тип переменной, в которую записывается результат, сам по себе не делает целочисленное деление дробным:

1double result = 7 / 2; // Получится 3.0

Оба операнда здесь имеют тип int, поэтому сначала выполняется целочисленное деление. Только после этого результат преобразуется в double.

Правильный вариант:

1double result = 7.0 / 2;

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

Остаток от деления (`%`)

Оператор % возвращает остаток от деления целых чисел.

1int result = 10 % 3;

Результат — 1, поскольку \(10 = 3 \cdot 3 + 1\).

Ещё несколько примеров:

1int a = 12 % 5; // 22int b = 15 % 4; // 33int c = 20 % 2; // 0

Оператор % часто используется для проверки чётности числа.

1int number = 8;23if (number % 2 == 0) {4    // Число чётное5}

Если остаток от деления на 2 равен нулю, число чётное. В противном случае оно нечётное.

Оператор % применяется к целочисленным операндам. Для вычисления остатка от деления дробных чисел можно использовать функцию std::fmod из заголовка <cmath>.

Приоритет арифметических операторов

Если выражение содержит несколько операторов, C++ вычисляет его с учётом правил приоритета и ассоциативности.

Например:

1int result = 2 + 3 * 4;

Сначала выполняется умножение, затем сложение. Результат — 14.

Основной порядок приоритета арифметических операторов от высокого к низкому:

Унарные +, -, ++, --.
Умножение, деление и остаток: *, /, %.
Сложение и вычитание: +, -.

Скобки позволяют явно задать порядок вычислений:

1int a = 2 + 3 * 4;   // 142int b = (2 + 3) * 4; // 20

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

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

Инкремент (`++`)

Инкремент увеличивает значение переменной на единицу.

1int count = 5;23count++;

Теперь count равен 6.

Есть две формы инкремента: постфиксная и префиксная.

Постфиксный инкремент

При записи value++ значение выражения определяется до увеличения переменной.

1int value = 5;2int result = value++;3

После выполнения:

result равен 5;
value равен 6.

Префиксный инкремент

При записи ++value переменная сначала увеличивается, после чего выражение получает новое значение.

1int value = 5;2int result = ++value;

После выполнения:

result равен 6;
value равен 6.

Если нужно просто увеличить переменную, обе формы подходят:

1value++;2++value;

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

Декремент (`--`)

Декремент уменьшает значение переменной на единицу.

1int count = 10;23count--;

Теперь count равен 9.

Как и инкремент, декремент имеет две формы.

1int a = 5;2int first = a--; // first = 5, a = 434int b = 5;5int second = --b; // second = 4, b = 4

Постфиксная форма возвращает старое значение выражения, а префиксная — новое.

Составные операторы присваивания

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

Оператор	Эквивалентная запись
`+=`	`a = a + b`
`-=`	`a = a - b`
`*=`	`a = a * b`
`/=`	`a = a / b`
`%=`	`a = a % b`

Например:

1int score = 100;23score += 20; // 1204score -= 10; // 1105score *= 2;  // 2206score /= 4;  // 55

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

Обрати внимание: для /= и %= действуют те же ограничения, что и для соответствующих операторов деления и остатка.

Арифметические операторы с разными типами

Если операнды имеют разные числовые типы, C++ применяет правила преобразования типов.

1int a = 10;2double b = 2.5;34double result = a + b;

В этом случае a преобразуется к подходящему дробному типу, а результат будет равен 12.5.

При смешивании знаковых и беззнаковых целых чисел правила преобразования могут приводить к неожиданным результатам. Поэтому при сравнении и вычислениях важно учитывать типы обоих операндов.

Пример: расчёт урона и оставшегося здоровья

Рассмотрим небольшую программу, которая использует арифметические операторы для изменения характеристик персонажа.

 1#include <iostream> 2 3int main() { 4    int health = 100; 5    int damage = 25; 6    int healing = 10; 7 8    health -= damage; 9    health += healing;1011    std::cout << "Здоровье: " << health << '\n';1213    return 0;14}

Результат:

1Здоровье: 85

Сначала из здоровья вычитается урон, а затем добавляется восстановленное здоровье:

Начальное значение: 100.
После получения урона: 75.
После лечения: 85.

Обрати внимание: арифметические операторы сами по себе не ограничивают результат диапазоном от 0 до 100. Если такие ограничения необходимы, их нужно реализовать отдельно.

Частые ошибки

Ожидание дробного результата от целочисленного деления

1double result = 5 / 2; // 2.0, а не 2.5

Чтобы получить дробный результат, хотя бы один операнд должен иметь дробный тип:

1double result = 5.0 / 2;

Деление на ноль

1int a = 10;2int b = 0;34// int result = a / b; // Нельзя выполнять

Перед делением проверь, что делитель не равен нулю.

Неправильное понимание остатка

1int result = 10 % 4; // 2

Оператор % возвращает остаток, а не результат деления.

Путаница между `value++` и `++value`

1int value = 5;2int a = value++; // a = 5, value = 6

Если требуется использовать новое значение сразу, можно применить префиксную форму:

1int value = 5;2int a = ++value; // a = 6, value = 6

Переполнение знакового целого типа

Значение знакового целочисленного типа нельзя безопасно увеличивать за пределы его представимого диапазона. Такое переполнение приводит к неопределённому поведению.

1#include <limits>23int value = std::numeric_limits<int>::max();45// value++; // Переполнение знакового типа

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

Итог

+, -, * и / выполняют основные арифметические операции.
% возвращает остаток от деления целых чисел.
++ и -- увеличивают и уменьшают значение на единицу.
Префиксная и постфиксная формы отличаются значением выражения.
Составные операторы +=, -=, *=, /= и %= упрощают изменение переменных.
Приоритет операторов определяет порядок вычислений, а скобки позволяют задать его явно.
Целочисленное деление отбрасывает дробную часть.
Перед делением нужно проверять делитель, а при работе с целыми числами — учитывать диапазон типа.