Java — JAVA пост-инкремент и префикс-инкремент в чем разница


Java: префикс/постфикс операторов increment/decment?

25 O_O [2011-03-24 04:05:00]

В приведенной ниже программе или здесь, почему последний вызов System.out.println(i) распечатать значение 7 ?

java post-increment pre-increment

8 ответов

54 Решение Spidy [2011-03-24 04:11:00]

Это выводит «6», потому что требуется, чтобы я добавлял его к нему и возвращал значение. 5 + 1 = 6; Это префикс, добавив номер перед использованием в операции.

Это выводит «6», потому что он принимает i, сохраняет копию, добавляет 1 и возвращает копию. Таким образом, вы получаете значение, которое я есть, но также увеличивайте его в одно и то же время. Поэтому вы печатаете старое значение, но оно увеличивается. Великолепный прирост постфикса.

Затем, когда вы печатаете i, он показывает реальное значение i, потому что он был увеличен. 7

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

Другой способ проиллюстрировать это:

++i даст результат new i , i++ даст результат оригинала i и сохранит new i для следующего действия.

Способ думать об этом — делать что-то еще внутри выражения. Когда вы печатаете текущее значение i , оно будет зависеть от того, было ли i изменено в выражении или после выражения.

i оценивается (изменяется) до вычисления результата. Печать i для этого выражения показывает измененное значение i , используемое для этого выражения.

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

Если вы сохранили согласованный шаблон и включили строки печати для всех значений:

3 Dilruk [2013-07-09 09:15:00]

Подумайте о ++i и i++ как ПОМОЩЬ к i = i+1. Хотя его не SAME. Разница заключается в том, что на самом деле i будет присвоено новое приращение.

в ++i , приращение происходит немедленно.

но если i++ , то приращение произойдет, когда программа перейдет к следующей строке.

Посмотрите на код здесь.

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

Почему переменная не была обновлена?

  • Postfix: передает текущее значение я в функцию и затем увеличивает его.
  • Префикс: увеличивает текущее значение и затем передает его функции.

Строки, в которых вы ничего не делаете, не имеют значения.


Обратите внимание, что это также верно для назначений:

Это отправляет println значение, имевшееся до этой строки кода (6), а затем увеличивает я (до 7).

Это мой ответ. Некоторые из вас могут легко понять.

Хорошо подумайте об этом с точки зрения временных переменных.

0 Lanavia [2015-03-11 19:31:00]

Возможно, вы можете лучше понять префикс/постфикс с этим примером.

Java: Префикс / постфикс операторов увеличения / уменьшения?

Из приведенной ниже программы или здесь , почему последний вызов System.out.println(i) выводит значение 7 ?

9 ответов

Это печатает «6», потому что требуется, я добавляю один к нему и возвращает значение. 5 + 1 = 6; Это префикс, добавление к номеру перед использованием его в операции.

Это печатает «6», потому что оно берет i, сохраняет копию, добавляет 1 и возвращает копию. Таким образом, вы получаете значение, которым я был, но одновременно увеличиваете его. Поэтому вы распечатываете старое значение, но оно увеличивается. Возможность увеличения постфикса.

Затем, когда вы распечатываете i, оно показывает реальное значение i, потому что оно было увеличено. 7

Думайте о ++i и i++ как о похожих на i = i+1. , но это не то же самое. Разница в том, когда i получает новое приращение.

в ++i , приращение происходит немедленно.

, но если i++ , то приращение произойдет, когда программа перейдет на следующую строку.

Посмотрите код здесь.

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

Я знаю, что на это ответили, но подумал, что может помочь другое объяснение.

Другой способ проиллюстрировать это:

++i даст результат new i , i++ даст результат оригинала i и сохранит new i для следующее действие.

1124 Способ думать об этом — делать что-то еще внутри выражения. Когда вы печатаете текущее значение i , оно будет зависеть от того, было ли изменено i в выражении или после выражения.

i оценивается (изменяется) до вычисления результата. Печать i для этого выражения показывает измененное значение i , использованное для этого выражения.

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

Если вы сохранили согласованный шаблон и включили строки печати для всех значений:

Разница в операторе инкремента-декремента в C и JAVA


Пожалуйста, обратите внимание на следующее заявление:

По моей логике п должно быть 10. Но я получаю различный результат в с (выход 7) Однако в Java я получаю ожидаемый результат, 10. Существует ли какая-то разница в том, каким образом приращения и уменьшения работы в с и Java.

Вот моя точная с и Java-код:

Java-код с выхода: 10

В C , это неопределенное поведение. Так как C не гарантирует порядок оценки индивидуальной операции в выражении.

Что касается C от c99 проекта стандарта 6.5.2 :

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

он приводит следующие примеры кода, как быть определено:

Секция же в проекте стандарта 2011 года , а также , но он читает немного более неловко. Это хорошая ссылка на точке последовательности .

Раздел 15.7 находится соответствующий раздел из JLS :

Язык программирования Java гарантирует, что операнды операторов по всей видимости, оцениваются в определенном порядке оценки, а именно, слева направо.

Рекомендуется, чтобы код не полагаться главным образом от этой спецификации. Код, как правило, понятнее, когда каждое выражение содержит в основном один побочный эффект

Цукерберг рекомендует:  Книги - Подскажите название книги

Инкремент и декремент

Вкратце

i++ возвращает i и увеличивает его на 1

i— возвращает i и уменьшает его на 1

++i увеличивает i на 1 и возвращает новое значение

—i уменьшает i на 1 и возвращает новое значение

В языке Java есть операторы инкремент ++ и декремент — , которые очень часто встречаются вместе с циклами. Эти унарные операции увеличивают и уменьшают на единицу число, записанное в переменную, примерно как это делает сокращенное присваивание += :

Кроме постфиксной формы, у них есть и префиксная:

Кажется, что нет никакой разницы между постфиксной и префиксной формами. Но тут начинаются сложности.

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

При использовании префиксной нотации сначала происходит изменение переменной, а потом возврат получившегося значения.

При использовании постфиксной нотации — наоборот: после изменения возвращается то значение, которое было до изменения переменной.

Правило работает одинаково для инкремента и декремента. Для простоты рассмотрим только инкремент:

  1. Вывели на экран ++x . Это префиксный инкремент, поэтому сначала значение переменной увеличилось на 1, потом результат вернулся и вывелся на экран.
  2. Так как значение изменилось, System.out.println(x) вывел 6.
  3. Теперь выводим на экран x++ . Это постфиксный инкремент, поэтому сначала значение вернулось и вывелось на экран, а потом переменная увеличилась на 1.
  4. Так как значение изменилось, System.out.print(x) вывел 7.


Особенно страшным все становится тогда, когда инкремент вставляют внутрь других операций: x = i++ — 7 + —h . Понять такой код невозможно, и его написание должно рассматриваться как тяжкое преступление.

Например, в языке JavaScript линтер (программа, проверяющая код) сразу начинает ругаться, когда видит использование инкремента и декремента.

Рекомендации по использованию:

  • Никогда не мешайте в рамках одного выражения операции/функции без побочных эффектов с операциями/функциями, обладающими побочными эффектами.
  • Используйте инкремент и декремент только там, где нет разницы между префиксным и постфиксным вариантом: отдельно от всего, на своей собственной строчке кода.

Задание

Инкремент и декремент — не очень важные операции в Java, и без них всегда можно обойтись. Задание в этом уроке не связано напрямую с этой темой, но вы можете использовать инкремент и декремент, чтобы привыкнуть к ним. В остальном это упражнение — ещё одна тренировка работы с циклами, строками и условиями.

Реализуйте функцию filterString , принимающую на вход строку и символ, и возвращающую новую строку, в которой удален переданный символ во всех его позициях.

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

Я не понимаю концепцию постфиксного и префиксного инкремента или декремента. Может ли кто — нибудь дать лучшее объяснение?

9 ответов:

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

полагая, что «городская легенда» привела многих новичков (и профессионалов) в заблуждение, а именно, бесконечный поток вопросов о неопределенном поведении в выражениях.

для встроенного оператора префикса C++,

с шагом x и производит как результат выражения x как lvalue, в то время как

с шагом x и выдает в результате выражения исходное значение x .

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

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

‘Post’ означает после-то есть, приращение выполняется после чтения переменной. «Pre» означает раньше — поэтому значение переменной сначала увеличивается, а затем используется в выражении.

никто не ответил на вопрос: почему это понятие сбивает с толку?

как магистр компьютерных наук мне потребовалось некоторое время, чтобы понять это из-за Как я читал код.

следующее неверно!

X равно y post инкремент. Что логически означает, что X равно значению Y после инкремент операция завершена. Post смысл после.

x = ++y
X равно y pre-инкремент. Что логически означает, что X равно значению Y до операция инкремента выполнена. Pre смысл до.


Как это работает на самом деле наоборот. Это понятие сбивает с толку, потому что язык вводит в заблуждение. В этом случае мы нельзя использовать слова для определения поведения.
x=++y фактически читается как X равно значению Y после инкремент.
x=y++ фактически читается как X равно значению Y до инкремент.

слова pre и post являются назад относительно семантики английского языка. Они только означают, где ++ находится в отношении Y. больше ничего.

лично, если бы у меня был выбор, я бы переключил значения ++Y и y++. Это просто пример идиомы, которую мне пришлось выучить.

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

Спасибо за чтение.

разницу между постфикс инкремент, x++ и префикс инкремент, ++x , находится именно в как эти два оператора оценивают свои операнды. Постфиксное приращение концептуально копирует операнд в память, увеличивает исходный операнд и, наконец, дает значение копии. Я думаю, что это лучше всего иллюстрируется реализацией оператора в коде:

приведенный выше код не будет компилироваться, потому что вы не можете переопределить операторы для примитивных типов. Компилятор также не может сказать здесь, что мы определяем постфикс оператор, а не префикс, но давайте притворимся, что это правильный и действительный C++. Вы можете видеть, что постфиксный оператор действительно действует на свой операнд, но он возвращает старое значение до приращения, поэтому результат выражения x++ значение до инкремента. x , однако, и увеличивается.

в префикс increment также увеличивает свой операнд, но он дает значение операнда после инкремент:

это означает, что выражение ++x принимает значение x после инкремент.

легко подумать, что выражение ++x поэтому эквивалентно assignmnet (x=x+1) . Это не совсем так, однако, потому что инкремент — это операция, которая может означать разные вещи в разных контекстах. В случае простого примитивного целого числа, действительно ++x — это взаимозаменяемый для (x=x+1) . Но в случае типа класса, такого как итератор связанного списка, приращение префикса итератора наиболее определенно не означает «добавление одного к объекту».

Это довольно просто. Оба будут увеличивать значение переменной. Следующие две строки равны:

Цукерберг рекомендует:  Навигационное меню с визуальным эффектом на CSS3

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

здесь обе строки увеличивают значение y на единицу. Однако первый присваивает значение y перед приращением к x, а второй присваивает значение y после приращения к x.

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

пост инкремент подразумевает значение i увеличивается после того, как он был назначен k . Однако предварительное приращение подразумевает, что значение j увеличивается до того, как оно будет присвоено l .

то же самое относится и к декременту.

от стандарта C99 (C++ должен быть таким же, за исключением странной перегрузки)

6.5.2.4 Постфиксные операторы инкремента и декремента

ограничения

1 операнд постфиксного приращения или оператор декремента должен иметь квалифицированный или неквалифицированный реальный или типа указатель и должен быть модифицируемым именующее выражение.

семантика

2 результат постфиксный++ оператор-это значение операнда. После того, как результат получен, значение операнда увеличивается. (То есть значение 1 к нему добавляется соответствующий тип.) Видеть обсуждение аддитивных операторов и сложные задания для информация об ограничениях, типах и переходы и эффекты операции над указателями. Сторона эффект обновления сохраненного значения операнд должен находиться между предыдущая и следующая последовательность точка.

3 постфиксный оператор — аналогичен к постфиксного++, за исключением что значение операнда уменьшается (то есть значение 1 соответствующий тип вычитается от него.)

6.5.3.1 префиксные операторы инкремента и декремента

ограничения

1 операнд приращения префикса или оператор декремента должен иметь квалифицированный или неквалифицированный реальный или типа указатель и должен быть модифицируемым именующее выражение.


семантика

2 Значение операнда префикс ++ оператор увеличивается на единицу. Этот результатом является новое значение операнда после инкремента. Выражение ++E эквивалентно (E+=1). См. обсуждение аддитивных операторов и составное назначение для информации о ограничения, типы, побочные эффекты и переходы и эффекты операции над указателями.

3 префикс-оператор является аналогом к оператору prefix++, за исключением того, что значение операнда равно уменьшенный.

Как правильно работать с преинкрементом и постинкрементом?

Не могу никак понять как правильно работать с этими операторами

int i = 2;
i = i++;
System.out.println(i); // 2
i = i++;
System.out.println(i); // 2

int j = 7;
j = ++j;
System.out.println(j); // 8
j = ++j;
System.out.println(j); // 9

  • Вопрос задан более трёх лет назад
  • 6772 просмотра

Основное различие между операторами постинкремента и преинкремента заключаются в следующем:
При постинкременте вызывающий код в начале получает значение переменной, а затем значение переменной увеличивается на единицу.
При преинкременте в начале значение переменной увеличивается на единицу, а затем вызывающий код получает значение переменной.

В джаве все не так.
И пре и пост сделают свои дела сразу на месте.

Т.е. в вашем примере в обоих случаях 10\x это по сути 10\1.

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

Java: Префикс / постфикс операторов инкремента / декремента?

November 2020

79.8k раз

Из приведенной ниже или программы здесь , почему последний вызов System.out.println(i) напечатает значение 7 ?

9 ответы

Ну подумайте об этом с точки зрения временных переменных.

Может быть, вы можете лучше понять префикс / постфикс с этим примером.

Это мой ответ. Некоторые из вас могут найти его легко понять.

Это печатает «6», потому что он принимает я прибавляет к нему и возвращает значение. 5 + 1 = 6; Это префиксы, добавляя к числу, прежде чем использовать его в работе.

Это печатает «6», поскольку она занимает I, сохраняет копию, добавляет 1 и возвращает копию. Таким образом, вы получаете значение, которое я был, но и увеличить его в то же время. Поэтому распечатайте старое значение, но оно получает приращение. Beautfy из приращения постфикса.


Затем, когда вы распечатайте я, это показывает реальное значение I, поскольку оно было увеличено. 7

Подумайте ++i и i++ как аналог i = i+1. Но это не то же самое. Разница в том , когда i получает новый прирост.

в ++i , приращение происходит немедленно.

но если i++ есть прирост будет происходить , когда программа переходит к следующей строке.

Посмотрите на код здесь.

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

Почему бы не переменные были обновлены?

  • Постфикс: передает текущее значение I к функции, а затем увеличивает его.
  • Префикс: увеличивает текущее значение, а затем передает его функции.

Линии, где вы ничего не делать с я не делают никакой разницы.

Обратите внимание на то, что это верно и для выполнения заданий:

Это посылает println значение я имел до этой строки кода (6), а затем увеличивает I (до 7).

Он печатает 7 для последнего утверждения, потому в приведенном выше заявлении, это значение равно 6 , и она увеличивается до 7 , когда печатается последнее заявление

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

Другой способ проиллюстрировать это:

++i даст в результате new i , i++ даст результат оригинала i и хранить new i для следующего действия.

Способ думать об этом, делать что — то другое в выражении. Когда вы печатаете текущее значение i , это будет зависеть от того , i была изменена в выражении или после выражения.

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

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

Если вы сохранили систематическую и включены печатные линии для всех значений:

Программирование на C, C# и Java

Уроки программирования, алгоритмы, статьи, исходники, примеры программ и полезные советы

ОСТОРОЖНО МОШЕННИКИ! В последнее время в социальных сетях участились случаи предложения помощи в написании программ от лиц, прикрывающихся сайтом vscode.ru. Мы никогда не пишем первыми и не размещаем никакие материалы в посторонних группах ВК. Для связи с нами используйте исключительно эти контакты: vscoderu@yandex.ru, https://vk.com/vscode

Инкремент и декремент

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

Операторы инкремента записывается как два плюса: ++


Существуют два вида инкрементов: преинкремент (или префиксный инкремент) и постинкремент (или постфиксный инкремент).
В синтаксисе префиксный инкремент ставится перед необходимой переменной, а постфиксный, соответственно, после.
Главное различие между ними, что при использовании операции преинкремента значение переменной сначала увеличивается на 1, а затем используется в выражении, к которому относится данная переменная. А при использовании операции постинкремента значение переменной сначала используется в выражении, а потом увеличивается на 1.
Более подробно и с примерами про это будет рассказано ниже.

Цукерберг рекомендует:  Script - Помощь с Unity

Декремент – это подобная инкременту операция, с той лишь разницей, что она уменьшает числовую переменную на единицу, а для символьной переменной выбирает предшествующий ей символ из таблицы символов. Декремент также не работает с константным типом данных и также имеет два вида: предекремент (префиксный декремент) и постдекремент (постфиксный декремент).

Эти виды декрементов работают абсолютно так же, как и инкременты с той лишь разницей, что происходит уменьшение значения на единицу. Префиксный декремент уменьшает переменную до её использования в других выражениях, а постфиксный декремент, наоборот, уменьшает переменную только после того, как она будет использована в выражении.
Декремент записывается как два минуса: – – . В коде предекремент ставится перед переменной, а постдекремент – после.
Обе эти операции были созданы для удобства пользователей – для сокращения количества кода и для уменьшения времени его написания:

Основные операции с переменными в 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;

m/= 7; // это всё равно, что m = m/7;

Зачем придумали сокращённые арифметические операторы? Да потому что лень — двигатель прогресса! Когда пишешь много-много строчек кода, каждый лишний символ отнимает силы и время. Проще использовать сокращённые арифметические операторы.

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

Пример №2

Если Вы попробуете запустить этот код на своём компьютере, то в консоль у Вас будет выведено вот такое число:

Пример №3

Если Вы попробуете запустить этот код на своём компьютере, то в консоль у Вас будет выведено вот такое число:

Теперь давайте рассмотрим ещё один арифметический оператор — оператор деления по модулю . Мы ему посвятили отдельную статью — «Деление по модулю в Java». А когда Вы прочитаете эту статью, мы с Вами перейдём к операторам инкремента и декремента — см. ниже

Инкремент и декремент

Ну что ж, мы с Вами уже рассмотрели операции в Java, которые очень похожи на те, что мы знаем со школы. Теперь самое время перейти к операциям в Java, которые, если Вы ранее не программировали, будут для Вас в новинку. Хотя ничего сложного в них нет.

Дело в том, что в программировании очень часто приходится выполнять операции, когда:

  • переменная должна увеличиться на единицу
  • переменная должна уменьшиться на единицу

Поэтому придумали отдельные операции с переменными, которые называются инкремент и декремент.

  1. Инкремент — отвечает за увеличение переменной на единицу. Обозначается как ++. Например, если у нас есть переменная i и мы к ней применим инкремент, тогда это будет записано как i++. А это значит, что значение переменной i должно быть увеличено на 1.
  2. Декремент — отвечает за уменьшение переменной на единицу. Обозначается как —. Например, если у нас есть переменная n и мы к ней применим декремент, тогда это будет записано как n —. А это значит, что значение переменной n должно быть уменьшено на 1.

Java / Работа пост и пред инкремента (что напечатается в консоле)

Автор: lurkinme ← к списку ← →

В первом случае, k = 5 +1, затем k = 5; Пост инкремент не передает значение сразу. Ответ 5.

В втором случае, сначала инкременты, второй инкремент получает уже инкрементное значение. Т.к. это пост-инкременты конечно выражение i = 5 +6; Ответ 11.

В третьем, похоже на второй, только конечное выражение будет таким i = 5 + 7; Ответ 12.

В четвертом, аналагично, только конечное выражение i = 6 +7; Ответ 13.

Если Вам понравился вопрос, проголосуйте за него

Понравилась статья? Поделиться с друзьями:
Все языки программирования для начинающих