Что такое постфиксный инкремент
Синтаксис
Remarks
В C++ доступны префиксные и постфиксные операции инкремента и декремента. В этом разделе описываются только их постфиксные формы. (Дополнительные сведения см. в разделе Операторы инкремента и декремента префикса.) Разница между ними заключается в том, что в постфиксной нотации оператор появляется после постфиксного выражения, тогда как в нотации префикса оператор появляется перед выражением. В следующем примере показан оператор постфиксного инкремента:
Результатом применения оператора постфиксного инкремента ( ++ ) является то, что значение операнда увеличивается на одну единицу соответствующего типа. Аналогичным образом, результат применения постфиксного оператора декремента ( — ) заключается в том, что значение операнда уменьшается на одну единицу соответствующего типа.
Важно отметить, что постфиксное выражение инкремента или декремента вычисляет значение выражения до применения соответствующего оператора. Операция инкремента или декремента выполняется после вычисления операнда. Эта особенность возникает, только когда постфиксная операция инкремента или декремента выполняется в контексте выражения.
Если же постфиксный оператор применяется к аргументу функции, то инкремент или декремент значения аргумента необязательно будет выполнен до его передачи в функцию. Дополнительные сведения см. в разделе 1.9.17 стандарта C++.
Применение постфиксного оператора инкремента к указателю на массив объектов типа long фактически добавляет четыре к внутреннему представлению указателя. Это поведение приводит к тому, что указатель, который ранее ссылался на n-й элемент массива, ссылается на элемент (n+ 1) TH.
Операнды для постфиксного инкремента и постфиксных операторов декремента должны быть изменяемыми (а не const ) l-значениями арифметического типа. Тип результата такой же, как у постфиксного выражения, но больше не является l-значением.
Ниже показан пример постфиксного оператора инкремента.
Постфиксные операции инкремента или декремента для типов перечисления не поддерживаются:
Инкремент и декремент в C++
Доброго времени суток, дорогие читатели CodeLessons.ru! В данной статье пойдет речь об часто встречающейся операторах в C++: инкрементах и декрементах. Они позволяют нам упростить написание кода, а также сделать его более читабельным и наглядным для просмотра.
Что такое инкремент и декремент?
Если вы уже писали несколько программ на языке C++, то у вас наверняка была ситуация, в которой вам было нужно увеличить или уменьшить какую-либо переменную на единицу. Для этого вам приходится писать код следующего вида:
Данный код вполне дееспособен, однако сейчас мы поговорим о более компактных операторах инкремента и декремента. Они выполняют следующие функции:
Теперь давайте более подробно разберем каждый из этих операторов.
Инкремент
Как было сказано выше, инкремент позволяет увеличить значение выбранной переменной на единицу.
Чтобы увеличить переменную при помощи инкремента, вы должны после имени переменной или до него написать два плюса (++). Можно прописывать данные знаки и до переменной. Этот вопрос мы подробно рассмотрим далее в статье.
Вот пример использования инкремента в C++:
Ну вот, другое дело. Теперь давайте разберем декремент.
Декремент
Его применение аналогично инкременту. Однако для уменьшения переменной мы должны вместо двух знаком сложения прописать два минуса (—).
Записывается в программе следующим образом:
Вы уже имеете достаточно знаний, касательно операторов уменьшения и увеличения в C++. Теперь пришло время разобраться в позиционировании декрементов и инкрементов.
Постфиксный и префиксный инкремент/декремент
Давайте рассмотрим варианты записи инкрементов и декрементов относительно переменной (до нее или после). В зависимости от выбранного вами варианта переменная будет ровно также увеличена или уменьшена, однако порядок выполнения операций остальных будет несколько отличаться.
Давайте рассмотрим префиксную и постфиксную варианты записи изучаемых нами операторов:
Советую сразу запомнить данные вариации позиционирования инкрементов и декрементов, поскольку потом вы можете чесами вглядываться в программу и не понимать почему она работает некорректно.
Программирование на C, C# и Java
Уроки программирования, алгоритмы, статьи, исходники, примеры программ и полезные советы
ОСТОРОЖНО МОШЕННИКИ! В последнее время в социальных сетях участились случаи предложения помощи в написании программ от лиц, прикрывающихся сайтом vscode.ru. Мы никогда не пишем первыми и не размещаем никакие материалы в посторонних группах ВК. Для связи с нами используйте исключительно эти контакты: vscoderu@yandex.ru, https://vk.com/vscode
Инкремент и декремент
Инкремент – это операция в языках программирования, которая увеличивает переменную на единицу, если переменная числовая и возвращает следующий символ из таблицы символов, если переменная символьного типа. При этом переменная не должна принадлежать типу данных const (т.е. константе).
Операторы инкремента записывается как два плюса: ++
Существуют два вида инкрементов: преинкремент (или префиксный инкремент) и постинкремент (или постфиксный инкремент).
В синтаксисе префиксный инкремент ставится перед необходимой переменной, а постфиксный, соответственно, после.
Главное различие между ними, что при использовании операции преинкремента значение переменной сначала увеличивается на 1, а затем используется в выражении, к которому относится данная переменная. А при использовании операции постинкремента значение переменной сначала используется в выражении, а потом увеличивается на 1.
Более подробно и с примерами про это будет рассказано ниже.
Декремент – это подобная инкременту операция, с той лишь разницей, что она уменьшает числовую переменную на единицу, а для символьной переменной выбирает предшествующий ей символ из таблицы символов. Декремент также не работает с константным типом данных и также имеет два вида: предекремент (префиксный декремент) и постдекремент (постфиксный декремент).
Арифметические операторы (справочник по 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#:
5.4 – Операторы инкремента/декремента и их побочные эффекты
Инкремент и декремент переменных
Инкремент (увеличение на 1) и декремент (уменьшение на 1) переменной настолько распространены, что имеют свои собственные операторы.
Обратите внимание, что существует две версии каждого оператора – префиксная версия (где оператор стоит перед операндом) и постфиксная версия (где оператор стоит после операнда).
Префиксные операторы инкремента/декремента очень просты. Сначала операнд увеличивается или уменьшается на единицу, а затем выражение вычисляется как значение операнда. Например:
Эта программа напечатает:
Постфиксные операторы инкремента/декремента немного сложнее. Сначала создается копия операнда. Затем операнд (не копия) увеличивается или уменьшается на единицу. И, наконец, вычисляется копия (а не оригинал). Например:
Эта программа напечатает:
Следовательно, y заканчивается значением 5 (значение до инкремента), а x заканчивается значением 6 (значение после инкремента).
Обратите внимание, что постфиксная версия требует гораздо большего количества шагов и, следовательно, может быть не такой производительной, как префиксная версия.
Вот еще один пример, показывающий разницу между префиксной и постфиксной версиями:
Эта программа в результате напечатает:
В 10-й строке мы выполняем постфиксные инкремент и декремент. В этой строке в std::cout отправляются копии x и y (с ранее увеличенными и уменьшенными значениями), поэтому мы не видим здесь проявлений инкремента и декремента. Эти изменения не проявятся до следующей строки, когда x и y вычисляются снова.
Лучшая практика
Решительно отдавайте предпочтение префиксной версии операторов инкремента и декремента, поскольку они, как правило, более производительны, и у вас меньше шансов столкнуться со странными проблемами, связанными с ними.
Побочные эффекты
Говорят, что функция или выражение имеют побочный эффект, если они делают что-либо, что сохраняется за пределами срока действия самой функции или выражения.
Обобщенные примеры побочных эффектов включают в себя изменение значений объектов, выполнение ввода или вывода или обновление графического пользовательского интерфейса (например, включение или выключение кнопки).
В большинстве случаев побочные эффекты полезны:
Однако побочные эффекты также могут привести к неожиданным результатам:
Бывают и другие случаи, когда C++ не определяет порядок, в котором вычисляются определенные вещи (например, операнды операторов), поэтому разные компиляторы могут демонстрировать разное поведение. Даже там, где C++ проясняет, как следует вычислять вещи, исторически это была область, где было много багов компиляторов. Как правило, всех этих проблем можно избежать, если гарантировать, что любая переменная, к которой применен побочный эффект, используется в какой-либо заданной инструкции не более одного раза.
Предупреждение
C++ не определяет порядок вычисления аргументов функции или операндов операторов.
Предупреждение
Не используйте в какой-либо инструкции переменную, к которой применяется побочный эффект, более одного раза. Если вы это сделаете, результат может быть неопределенным.