Что такое сокращенная форма арифметического оператора
Что такое сокращенная форма арифметического оператора
Арифметические операторы используются для сложения, вычитания, умножения и деления чисел. Список основных арифметических операторов, которые используются в С++, приведён в таблице 1.3.
| Таблица 1.3 Арифметические операторы С++ | |
| Оператор | Назначение |
| + | Сложение |
| — | Вычитание |
| * | Умножение |
| / | Деление |
| % | Остаток от деления(деление по модулю) |
| ++ | Инкремент |
| — | Декремент |
Первые пять операторов являются бинарными, то есть используются с двумя операндами. За исключением операторов деления по модулю(остаток от целочисленного деления), инкремента и декремента, операторы совпадают с соответствующими математическими операторами. Если оператор деления по модулю особых комментариев не требует, то операторы инкремента и декремента в определённом смысле являются визитной карточкой языка С++. Оператор инкремента даже присутствует в названии языка.
Разница между префиксной и постфиксной формами операторов инкремента и декремента проявляются в ситуации, когда эти операторы использованы в выражениях. Естественным образом возникает вопрос относительно переменной-операнда, по отношению к которой применяется операция инкремента или декремента и которая является составной частью более сложного выражения: следует ли сначала вычислить выражение и затем изменить значение переменной или сначала следует изменить значение переменной, а уж потом вычислять выражение?
Ответ следующий: для префиксной формы сперва изменяется значение переменной, а затем рассчитывается выражение, а для постфиксной формы выражение вычисляется со старым значением переменной, а только после этого изменяется значение этой переменной.
В этом и состоит разница между префиксной и постфиксной формами операторов инкремента и декремента.
Проиллюстрируем сказанное на примере.
В листинге 1.5 приведён код программы, в которой использованы операторы инкремента и декремента в префиксной и постфиксной формах.
==========> Листинг 1.5 Код программы с операторами инкремента и декремента
#include
using namespace std;
int main() <
int n,m,i=3,j=3;
cout
cout
cout
cout
cout ==========> Конец Листинга 1.5 Компилированный исполняемый файл листинга 1.5(120Кб, rar)
В начале программы инициализируются две переменные i и j с одинаковыми начальными значениями, равными 3. Разница между префиксной и постфиксной формами операторов инкремента и декремента иллюстрируются простыми командами: n=i++ и m=++j. В результате обе переменные i и j увеличивают своё значение на единицу: после выполнения команд они равняются 4.
Однако ситуация не всегда так однозначна
Например, если после означенных выше команд выполнить команду n=(—i)*(i—), получим для переменной i значение 2, адля переменной n значение 9. Алгоритм вычисления переменных при этом следующий. Поскольку выражение, на основе которого вычисляется значение переменной n, является произведением двух выражений(то есть (—i) и (i—)), то предварительно рассчитываются эти выражения. Результатом выражения (—i) является число 3(значение i уменьшенное на единицу), причем это же значение присваивается переменной i. Такое же значение возвращается выражением (i—), а после присваивания переменной n переменная i будет уменьшена ещё на единицу.
Если воспользоваться командой m=(—j)*(—j), то получим для j значение 2(дважды значение j уменьшается на единицу), и как результат для m получаем значение 4
Напротив, после выполнения команды n=(—i)*(i++) имеем для i значение 2 и для n значение 1: уменьшается на единицу переменная i(станивится равной 1), при данном значении i вычисляется величина n(равна 1), после этого значение i увеличивается на единицу(становится равным 2).
Несложно понять, что в результате выполнения команды m=(j—)*(++j) переменная m примет значение 9, а переменная j будет равняться 2.
Наконеч, команду n=(—i)*(++i) следует понимать так: уменьшаем на единицу переменную i(равняется 1), увеличиваем на единицу переменную i(равняется 2), после чего вычисляем значение переменной n(равняется 4)
! Хотя операторы декремента и инкремента достаточно удобны, использовать их в выражениях следует крайне осторожно.
Например, команда х+=3 эквивалентна команде х=х+3, а команду а=а*b можно записать как a*=b.
Сокращенная формаарифметических операторов позволяет сущестенно упростить код и очень чато используется на практике.
Основные операции с переменными в Java
Ну, как же обойтись в программировании без возможности что-то складывать, вычитать, умножать и т.д.? Такую возможность в Java обеспечивают так называемые операторы. В Java все операторы можно разбить на 3 группы:
В этой статье мы рассмотрим:
Логические и побитовые операции мы рассмотрим с Вами в отдельных статьях. На данном этапе Вам будет достаточно только понимания того, что такое арифметические операции. Итак, приступим!
Арифметические операторы
На самом деле, со многими арифметическими операторами Вы уже знакомы со школы :
Давайте попробуем разобраться с этими операторами на примере.
Пример №1
Если Вы попробуете запустить этот код на своём компьютере, то в консоль у Вас будут выведены вот такие числа:
Комментарии:
Давайте разберём каждую строчку кода.
Здесь мы объявили переменную k и присвоили ей значение 70, затем объявили переменную p и присвоили ей значение 10, а потом объявили еще переменную f и присвоили ей значение 5.
Затем объявили переменную m и присвоили ей значение, равное сумме k и p. А k у нас равно 70, p равно 10, соответственно, m будет равно 80.
Затем вывели в консоль значение m. И, действительно, в консоли мы видим 80.
В этой строчке мы сказали, что переменной m должно быть присвоено новое значение, которое должно быть равно m-30. m у нас было равно 80, поэтому новое значение m будет равно 80-30, то есть 50.
Выводим в консоль новое значение m и, действительно, в консоли видим 50.
Объявляем переменную s и присваиваем ей значение равное m*f. Поскольку m у нас равно 50, а f равно 5, то при умножении 50 на 5 получаем 250. Значит, s равно 250.
Выводим в консоль значение переменной s. И, действительно, видим в консоли 250.
Присваиваем новое значение переменной s, которое равно s/f. Знаком / обозначается деление в Java. Переменная s у нас сейчас равна 250, а f равно 5. Поэтому при деление 250 на 5 получим 50. То есть новое значение переменной s равно 50.
Выводим в консоль новое значение переменной s. И, действительно, в консоли видим 50.
Обратите внимание: в Java деление обозначается знаком /
Сокращённые арифметические операторы
Также к арифметическим операторам относят так называемые сокращённые арифметически операторы. Вы должны знать, что есть 2 формы записи основных арифметических операций. Например:
m += 7; // это всё равно, что m = m+7;
m*= 7; // это всё равно, что m = m*7;
m/= 7; // это всё равно, что m = m/7;
Чтобы убедиться в том, что сокращённые арифметические операторы в коде дают такой же результат, что и полная форма арифметических операций, предлагаем Вам запустить на своём компьютере вот эти 2 небольшие программы. И в примере №2, и в примере №3 в консоль у Вас будет выведено число 9.
Пример №2
Если Вы попробуете запустить этот код на своём компьютере, то в консоль у Вас будет выведено вот такое число:
Пример №3
Если Вы попробуете запустить этот код на своём компьютере, то в консоль у Вас будет выведено вот такое число:
Инкремент и декремент
Ну что ж, мы с Вами уже рассмотрели операции в Java, которые очень похожи на те, что мы знаем со школы. Теперь самое время перейти к операциям в Java, которые, если Вы ранее не программировали, будут для Вас в новинку. Хотя ничего сложного в них нет.
Дело в том, что в программировании очень часто приходится выполнять операции, когда:
Поэтому придумали отдельные операции с переменными, которые называются инкремент и декремент.
Инкремент и декремент в Java
Что за операторы такие, зачем им префиксная и постфиксная формы, и как вычислять сложные выражения с ними (пригодится на экзамене и собеседовании).
В программировании часто приходится выполнять операции (вычислять результат выражений), в которых переменная должна увеличиться или уменьшиться на единицу.
Программист, преподаватель Skillbox. Пишет про Java.
Пример 1
Тут всё просто, достаточно удостовериться, что значения переменных поменялись.
Примечание. Инкремент и декремент относятся к арифметическим операторам. Мы помним, что операнды арифметических операторов должны быть числового типа. Однако в Java допустим и тип char, потому что здесь это по сути разновидность типа int.
Проверим, как это работает с инкрементом и декрементом.
Пример 2
Пример 3
На каждой итерации цикла значение переменной i выводится в консоль, а сама переменная увеличивается на один после каждого витка.
Примечание: если в примере выше заменить i++ на ++i, то результат в консоли не поменяется — проверьте.
Дело в том, что преинкремент и постинкремент в условии цикла for можно сравнить с вызовом двух разных функций. Каждая из них делает одно и то же — увеличивает переменную i (после выполнения тела цикла), и только возвращаемые ими значения различаются.
Однако возвращаемое инкрементом значение в условии цикла использовать негде (нет выражения для вычисления) — поэтому оно просто выбрасывается.
Вот почему на работе цикла подобная замена не отразилась.
Пример 4
Перепишем пример с циклом так:
Как видим, вывод снова не изменился.
Всё потому, что в метод System. out.println () передаётся текущее значение переменной i, и лишь потом оно увеличивается на единицу.
За это отвечает постфиксная форма записи инкремента. А ещё есть префиксная. И для декремента тоже.
Префиксная и постфиксная формы
Синтаксис тут такой ( x — переменная):
| Операция | Постфиксная версия | Префиксная версия |
|---|---|---|
| Инкремент | x++ | ++x |
| Декремент | х— | —х |
Различия в работе:
Обратите внимание на слово потом. Потом — это когда? После вычисления всего выражения? Чтобы понять это, разберёмся с порядком вычисления инкрементов и декрементов.
Порядок вычисления выражений с операторами ++ и −−
Значения, которые инкременты возвращают в выражение, вычисляются до выполнения других операций. И то же самое для декрементов.
О приоритете и ассоциативности
Не путайте приоритет с обычным порядком выполнения операторов. Все инструкции Java выполняет в привычном нам направлении (слева направо), и операнды операторов вычисляет так же.
Приоритеты же определяют порядок выполнения операторов, которые сами являются частью более сложного (составного) арифметического или логического выражения.
Если на одном уровне встречаются операции одинакового приоритета, то какие из них выполнять первыми — определяет уже ассоциативность.
Пример 5
Разберём пример выше.
x = 3. Найдём значение выражения 2 * x++:
Значение b стало равным 4, а y равен 2.
Выражение с несколькими инкрементами/декрементами
В этом случае стоит помнить, что:
Если в выражении много инкрементов/декрементов одной переменной
Тогда входным значением переменной для вычисления каждого последующего инкремента или декремента будет значение этой переменной после вычисления предыдущего инкремента или декремента.
То есть инкременты/декременты в выражении обрабатываются не одновременно, а по очереди, порядок в которой определяется ассоциативностью и приоритетом этих операторов в Java.
Арифметические операторы (справочник по C#)
Следующие операторы выполняют арифметические операции с операндами числовых типов:
Эти операторы поддерживаются всеми целочисленными типами и типами с плавающей запятой.
Оператор инкремента ++
Оператор инкремента ++ увеличивает операнд на 1. Операндом должна быть переменная, свойство или индексатор.
Оператор инкремента поддерживается в двух формах: постфиксный оператор инкремента ( x++ ) и префиксный оператор инкремента ( ++x ).
Постфиксный оператор приращения
Результатом x++ является значение x перед выполнением операции, как показано в следующем примере:
Префиксный оператор инкремента
Результатом ++x является значение x после выполнения операции, как показано в следующем примере:
Постфиксный оператор уменьшения
Результатом x— является значение x перед выполнением операции, как показано в следующем примере:
Префиксный оператор декремента
Операторы унарного плюса и минуса
Оператор умножения *
Оператор умножения * вычисляет произведение операндов:
Оператор деления /
Оператор деления / делит левый операнд на правый.
Деление целых чисел
Для операндов цельночисленных типов результат оператора / является целочисленным типом, который равен частному двух операндов, округленному в сторону нуля:
Деление чисел с плавающей запятой
Оператор остатка %
Оператор остатка % вычисляет остаток от деления левого операнда на правый.
Целочисленный остаток
Используйте метод Math.DivRem для вычисления результатов как целочисленного деления, так и определения остатка.
Остаток с плавающей запятой
Этот метод вычисления остатка аналогичен тому, который использовался для целочисленных операндов, но отличается от спецификации IEEE 754. Если вам нужна операция вычисления остатка, которая соответствует спецификации IEEE 754, используйте метод Math.IEEERemainder.
Сведения о поведение оператора % в случае неконечных операндов см. в разделе Оператор остаткаспецификации языка C#.
Для операндов decimal оператор остатка % эквивалентен оператору остатка типа System.Decimal.
В следующем примере показано поведение оператора остатка для операндов с плавающей запятой:
Оператор сложения +
Оператор сложения + вычисляет сумму своих операндов:
Составное присваивание
Для бинарного оператора op выражение составного присваивания в форме
за исключением того, что x вычисляется только один раз.
Следующий пример иллюстрирует использование составного присваивания с арифметическими операторами:
Приоритет и ассоциативность операторов
В следующем списке перечислены арифметические операторы в порядке убывания приоритета:
Бинарные арифметические операторы имеют левую ассоциативность. То есть операторы с одинаковым приоритетом вычисляются в направлении слева направо.
Порядок вычисления, определяемый приоритетом и ассоциативностью операторов, можно изменить с помощью скобок ( () ).
Полный список операторов C#, упорядоченный по уровню приоритета, можно найти в разделе Приоритет операторов статьи Операторы C#.
Арифметическое переполнение и деление на нуль
Если результат арифметической операции выходит за пределы диапазона возможных конечных значений соответствующего числового типа, поведение арифметического оператора зависит от типа его операндов.
Целочисленное арифметическое переполнение
Деление целого числа на ноль всегда вызывает исключение DivideByZeroException.
В случае целочисленного арифметического переполнения итоговое поведение определяется контекстом проверки переполнения, который может быть проверяемым или непроверяемым:
По умолчанию арифметические операции выполняются в непроверяемом контексте.
Арифметическое переполнение с плавающей запятой
Арифметические операции с типами float и double никогда не вызывают исключение. Результатом арифметических операций с этими типами может быть одно из специальных значений, представляющих бесконечность и объект, не являющийся числовым:
Для операндов типа decimal арифметическое переполнение всегда вызывает исключение OverflowException, а деление на нуль всегда вызывает исключение DivideByZeroException.
Ошибки округления
Из-за общих ограничений, касающихся представления вещественных чисел в форме с плавающей запятой и арифметических операций с плавающей запятой, при вычислениях с использованием типов с плавающей запятой могут возникать ошибки округления. То есть полученный результат выражения может отличаться от ожидаемого математического результата. В следующем примере показано несколько таких случаев:
См. заметки в справочной документации по System.Double, System.Single и System.Decimal.
Возможность перегрузки оператора
Спецификация языка C#
Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:
§ 8.5. Целые типы. Преобразование типов. Сокращенные операции. Операции инкремента и декремента
Содержание
Общие сведения о целых типах
Целочисленный тип данных является одним из фундаментальных типов и относится (наряду с вещественными) к арифметическим типам. Он представлен в виде знаковых и беззнаковых разновидностей типов.
С помощью модификаторов типа можно получить всё разнообразие целых типов (перечисленных в таблице 1). Модификаторы типа могут определять знак и/или размер. Знак определяют модификаторы:
Таблица 1. Спецификаторы целых типов
Как видно из таблицы, знаковые типы могут принимать как отрицательные, так и положительные значения, в то время как беззнаковые типы только положительные и ноль. В стандарте C++ не определяются размеры того или иного типа. Стандарт дает лишь гарантию, что:
Литералы целых типов представлены в двоичной, восьмеричной, шестнадцатеричной и десятичной системах счисления:
Целочисленные типы определяют лишь небольшое множество соответствующих значений из бесконечной совокупности целых чисел. Чем больше количество различных значений, которые могут принимать переменные данного типа, тем шире используемый тип.
Стандартных средств контроля переполнения типа C++ не имеет! Вся ответственность за соблюдения выхода за границы ширины типа целиком лежит на разработчике алгоритма.
size_t
Преобразования типов
Мы уже показывали, что в выражении могут участвовать разные типы. С++ дает возможность преобразовать объекты одного типа в объекты другого типа. Различают два вида преобразования:
- Неявные преобразованияЯвное преобразование
- Преобразования при инициализации и присваиванииПреобразования при передаче аргументовАрифметические преобразования ( arithmetic conversion )
Преобразования при инициализации и присваивании
Здесь для нас важно не сами правила преобразования, а те требования, которые нужно соблюдать для сохранения точности вычислений:
- чтобы получить предсказуемый результат (без потери точности) необходимо типу с большим диапазоном присваивать тип с меньшим диапазоном, с учетом знака; избегать в присваиваниях знаковому типу значение беззнакового типа и наоборот.
Арифметические преобразования
Арифметические преобразования ( arithmetic conversion ) происходят в выражениях с арифметическими операциями в которых операнды имеют разные числовые типы. Арифметические преобразования выполняются по следующим правилам:
Для выражений в которых имеется знаковый, и беззнаковый тип:
если беззнаковый тип операнда старше, чем операнд со знаком, то последний преобразуется в тип беззнакового операнда; иначе, если тип со знаком может представить весь диапазон беззнакового типа, беззнаковый операнд преобразуется к типу операнда со знаком; иначе операнды преобразуются в беззнаковую версию типа со знаком