Почему не может левая сторона присвоения быть инкрементным выражением?
Мог любой говорить мне значение "++" с массивом в следующем коде в Java:
int [ ] arr = new int[ 4 ];
for(int i = 0; i < arr.length; i++){
arr[ i ] = i + 1;
System.out.println(arr[ i ]++);
}
что arr[ i ]++ значение в вышеупомянутом коде, и почему мы не можем сделать как:
arr[ i ]++ = i + 1;
6 ответов
Обсуждаемый здесь оператор называется оператором постфиксного приращения ( JLS 15.14.2 ). Он должен вести себя следующим образом:
- Во время выполнения, если оценка выражения операнда завершается внезапно, тогда выражение постфиксного приращения завершается внезапно по той же причине и никакого приращения не происходит.
- В противном случае значение 1 добавляется к значению переменной, и сумма сохраняется обратно в переменную.
- Перед добавлением двоичное числовое продвижение (§5.6. 2) выполняется для значения 1 и значения переменной.
- При необходимости сумма сужается с помощью сужающего примитивного преобразования (§5.1.3) и / или подвергается упаковочному преобразованию (§5.1.7) в тип переменной перед ее сохранением.
- Значение выражения приращения постфикса - значение переменной до сохранения нового значения .
Последний пункт является ключевым для этого вопроса: причина, по которой вы не можете сделать arr [i] ++ = v; , точно такая же причина, почему вы не можете делать х ++ = v; ; выражение постфиксного приращения возвращает значение , а не переменную .
Из JLS 15.1 Оценка, обозначение и результат :
Когда выражение в программе оценивается (выполняется), результат обозначает одно из трех:
- Переменная [... ] (в C это будет называться lvalue)
- Значение [...]
- Ничего (выражение считается недействительным)
Для присвоения требуется переменная в левой части, а значение НЕ является переменной, и поэтому вы не можете сделать х ++ = v; .
Из JLS 15.26 Операторы присваивания :
Результатом первого операнда оператора присваивания должна быть переменная, в противном случае возникает ошибка времени компиляции . Этот операнд может быть именованной переменной [...] или вычисляемой переменной, что может быть результатом доступа к полю [...] или массиву. [...]
В следующем фрагменте показаны ошибочные попытки присвоить значение , переходящие от довольно тонкого к более очевидному:
int v = 42;
int x = 0;
x = v; // OKAY!
x++ = v; // illegal!
(x + 0) = v; // illegal!
(x * 1) = v; // illegal!
42 = v; // illegal!
// Error message: "The left-hand side of an assignment must be a variable"
Обратите внимание, что вы можете использовать постфикс оператор инкремента где-то слева от оператора присваивания, если конечным результатом является переменная.
int[] arr = new int[3];
int i = 0;
arr[i++] = 2;
arr[i++] = 3;
arr[i++] = 5;
System.out.println(Arrays.toString(arr)); // prints "[2, 3, 5]"
Оператор ++ не имеет ничего общего с массивами. Он увеличивает любую целочисленную переменную (или, в более общем смысле, любое lvalue) на 1. Это то же самое, что и i ++ в цикле.
Вы можете написать ++ x или x ++. Оба они увеличивают x, но имеют разные значения: ++ x возвращает новое значение x, а x ++ возвращает старое значение. Таким образом, ваш код печатает 1, 2, 3, 4 вместо 2, 3, 4, 5.
Код System.out.println (arr [i] ++) означает следующее:
int tmp = arr[i];
arr[i] = arr[i] + 1;
System.out.println(tmp);
Ваш второй пример не имеет смысла, потому что вы не можете использовать ++ оператор для значения.
arr[i]++ означает "увеличить значение arr[i] на 1" и вернуть старое значение. Итак, ваш код сначала устанавливает arr[i] в i+1, используя arr[ i ] = i + 1;. Затем он увеличивает его до i + 2 с помощью arr[ i ]++ и печатает значение, которое он имел до его увеличения во второй раз, то есть i + 1.
Вы не можете использовать arr[ i ] = arr[i] + 1; вместо этого, потому что это означает "увеличить значение arr[i] на 1 и вернуть новое значение".
Вы не можете сделать arr[ i ]++ = i + 1;, потому что это не имеет смысла.
arr[i]++ - это увеличить значение arr[i] на единицу и присвоить
как для arr[ i ]++ = i + 1; Эта фраза означает что-то совсем другое, я не знаю, что это вообще валидная java, если честно. Я бы, если это работает, инкрементировал значение в arr[i], а затем присвоил его индексу + 1;
arr[ i ]++ увеличивает arr[i] на 1. Это может выглядеть так:
arr[i] = i + 1;
Что касается arr[ i ]++ = i + 1; пожалуйста, не пытайтесь писать такой код. Даже если он скомпилируется, это будет загадкой для вас или для других.
PS Я бы предпочел:
++arr[i];