Co to jest x po „x = x ++”?

Co się dzieje (za zasłonami), gdy jest to wykonywane?

int x = 7;
x = x++;

To znaczy, kiedy zmienna jest zwiększana i przypisywana do siebie w jednej instrukcji? Skompilowałem i wykonałem to. xwynosi wciąż 7, nawet po całym oświadczeniu . W mojej książce jest napisane, że xjest zwiększane!

xzwiększa się. Ale przypisujesz starą wartość z xpowrotem do siebie.

x = x++;

1. x++zwiększa xi zwraca starą wartość.
2. x = przypisuje starą wartość z powrotem do siebie.

W końcu xzostaje przypisany z powrotem do wartości początkowej.

x = x++;

jest równa

int tmp = x;
x++;
x = tmp;

Twierdzenie:

x = x++;

jest równa:

tmp = x;   // ... this is capturing the value of "x++"
x = x + 1; // ... this is the effect of the increment operation in "x++" which
           //     happens after the value is captured.
x = tmp;   // ... this is the effect of assignment operation which is
           //     (unfortunately) clobbering the incremented value.

Krótko mówiąc, oświadczenie nie ma wpływu.

Kluczowe punkty:

• Wartość wyrażenia inkrementacji / dekrementacji Postfix jest wartością operandu przed inkrementacją / dekrementacją. (W przypadku formularza Prefiks wartość jest wartością argumentu po operacji),

• RHS wyrażenia przypisania jest całkowicie oceniane (w tym wszelkie przyrosty, zmniejszenia i / lub inne skutki uboczne) przed przypisaniem wartości do LHS.

_{Zauważ, że w przeciwieństwie do C i C ++, kolejność oceny wyrażenia w Javie jest całkowicie określona i nie ma miejsca na zmienne specyficzne dla platformy. Kompilatory mogą zmieniać kolejność operacji tylko wtedy, gdy nie zmienia to wyniku wykonania kodu z perspektywy bieżącego wątku. W takim przypadku kompilator byłby w stanie zoptymalizować całą instrukcję, ponieważ można udowodnić, że nie działa.}

W przypadku, gdy nie jest to już oczywiste:

• „x = x ++;” jest prawie na pewno błędem w jakimkolwiek programie.
• OP (pierwotne pytanie!) Prawdopodobnie oznaczało „x ++;” zamiast „x = x ++;”.
• Stwierdzenia, które łączą auto inc / decrement i przypisanie do tej samej zmiennej są trudne do zrozumienia i dlatego należy ich unikać niezależnie od ich poprawności . Po prostu nie ma potrzeby pisania takiego kodu.

Mamy nadzieję, że weryfikatory kodu, takie jak FindBugs i PMD, oznaczą ten kod jako podejrzany.

int x = 7;
x = x++;

Niezdefiniowane zachowanie w C i dla Javy zobacz tę odpowiedź . To zależy od kompilatora, co się stanie.

Taka konstrukcja x = x++;wskazuje, że prawdopodobnie nie rozumiesz, co ++robi operator:

// original code
int x = 7;
x = x++;

Przepiszmy to, aby zrobić to samo, w oparciu o usunięcie ++operatora:

// behaves the same as the original code
int x = 7;
int tmp = x; // value of tmp here is 7
x = x + 1; // x temporarily equals 8 (this is the evaluation of ++)
x = tmp; // oops! we overwrote y with 7

Teraz przepiszmy to, aby zrobić (co myślę), co chciałeś:

// original code
int x = 7;
x++;

Subtelność polega na tym, że ++operator modyfikuje zmiennąx , w przeciwieństwie do wyrażenia takiego jak x + x, który oceniałby na wartość int, ale pozostawiał xsamą zmienną bez zmian. Rozważmy konstrukcję taką jak czcigodna forpętla:

for(int i = 0; i < 10; i++)
{
    System.out.println(i);
}

Zwróć uwagę i++na tam? To ten sam operator. Moglibyśmy przepisać tę forpętlę w ten sposób i zachowałby się tak samo:

for(int i = 0; i < 10; i = i + 1)
{
    System.out.println(i);
}

Odradzam również używanie ++operatora w większych wyrażeniach w większości przypadków. Z powodu subtelności, kiedy modyfikuje oryginalną zmienną w przyrostach przed i po ( ++xi x++odpowiednio), bardzo łatwo jest wprowadzić subtelne błędy, które są trudne do wyśledzenia.

Zgodnie z kodem bajtu uzyskanym z plików klas,

Oba przypisania zwiększają x, ale różnicą jest czas when the value is pushed onto the stack

W trybie Case1Push występuje (a następnie przypisywany) przed przyrostem (co oznacza, że ​​przyrost nie robi nic)

W Case2Przyrost występuje najpierw (co daje 8), a następnie wypychany na stos (a następnie przypisywany do x)

Przypadek 1:

int x=7;
x=x++;

Kod bajtowy:

0  bipush 7     //Push 7 onto  stack
2  istore_1 [x] //Pop  7 and store in x
3  iload_1  [x] //Push 7 onto stack
4  iinc 1 1 [x] //Increment x by 1 (x=8)
7  istore_1 [x] //Pop 7 and store in x
8  return       //x now has 7

Przypadek 2:

int x=7; 
x=++x;

Kod bajtowy

0  bipush 7     //Push 7 onto stack
2  istore_1 [x] //Pop 7 and store in x
3  iinc 1 1 [x] //Increment x by 1 (x=8)
6  iload_1  [x] //Push x onto stack
7  istore_1 [x] //Pop 8 and store in x
8  return       //x now has 8

• Stos tutaj odnosi się do stosu operandu, lokalny: x indeks: 1 typ: int

Jest zwiększany po „ x = x++;”. Byłoby to 8, gdybyś zrobił „ x = ++x;”.

Operator Post Increment działa w następujący sposób:

1. Przechowuj poprzednią wartość argumentu.
2. Zwiększ wartość argumentu.
3. Zwraca poprzednią wartość argumentu.

Więc oświadczenie

int x = 7;
x = x++; 

zostanie oceniony w następujący sposób:

1. x jest inicjowany wartością 7
2. operator przyrostu post przechowuje poprzednią wartość x, tj. 7, do zwrócenia.
3. Zwiększa x, więc teraz x wynosi 8
4. Zwraca poprzednią wartość x, tj. 7, i jest ona przypisywana z powrotem do x, więc x ponownie staje się 7

Tak więc x jest rzeczywiście zwiększony, ale ponieważ x ++ przypisuje wynik z powrotem do x, więc wartość x jest zastępowana do poprzedniej wartości.

Inkrementacja następuje po wywołaniu x, więc x nadal wynosi 7. ++ x będzie równe 8, gdy x zostanie wywołane

Po ponownym przypisaniu wartości xnadal jest to 7. Spróbuj, x = ++xa dostaniesz 8 innych do zrobienia

x++; // don't re-assign, just increment
System.out.println(x); // prints 8

ponieważ x ++ zwiększa wartość PO przypisaniu jej do zmiennej. i podczas wykonywania tego wiersza:

x++;

varialbe x nadal będzie miał oryginalną wartość (7), ale użyje x ponownie w innym wierszu, takim jak

System.out.println(x + "");

da ci 8.

jeśli chcesz użyć zwiększonej wartości x na wyciągu przypisania, użyj

++x;

To zwiększy x o 1, NASTĘPNIE przypisze tę wartość do zmiennej x.

[Edytuj] zamiast x = x ++, to tylko x ++; ten pierwszy przypisuje sobie oryginalną wartość x, więc w rzeczywistości nie robi nic w tym wierszu.

Co się stanie kiedy int x = 7; x = x++;?

ans -> x++oznacza najpierw użyj wartości x dla wyrażenia, a następnie zwiększ ją o 1.
Tak dzieje się w twoim przypadku. Wartość x na RHS jest kopiowana do zmiennej x na LHS, a następnie wartość xjest zwiększana o 1.

Podobnie ++x oznacza ->zwiększenie wartości x najpierw o jeden, a następnie użycie wyrażenia.
Więc w twoim przypadku x = ++x ; // where x = 7
otrzymasz wartość 8.

Dla większej przejrzystości spróbuj dowiedzieć się, ile instrukcji printf wykona następujący kod

while(i++ <5)   
  printf("%d" , ++i);   // This might clear your concept upto  great extend

++xjest przyrostem ->x jest zwiększany przed użyciem
x++jest przyrostem ->x jest zwiększany po użyciu

int x = 7; -> x get 7 value <br>
x = x++; -> x get x value AND only then x is incremented

Oznacza to, że: x++nie jest równyx = x+1

ponieważ:

int x = 7; x = x++;
x is 7

int x = 7; x = x = x+1;
x is 8

a teraz wydaje się to trochę dziwne:

int x = 7; x = x+=1;
x is 8

bardzo zależy od kompilatora!

x = x ++;

To jest operator post-increment. Należy to rozumieć jako „Użyj wartości operandu, a następnie zwiększ operand”.

Jeśli chcesz, aby miało miejsce odwrotność, tj. „Zwiększ operand, a następnie użyj wartości operandu”, musisz użyć operatora wstępnej inkrementacji, jak pokazano poniżej.

x = ++ x;

Ten operator najpierw zwiększa wartość x o 1, a następnie przypisuje wartość z powrotem do x.

Myślę, że ten spór można rozwiązać bez wchodzenia w kod i myślenia.

Rozważ i ++ i ++ i jako funkcje, powiedzmy Func1 i Func2.

Teraz i = 7;
Func1 (i ++) zwraca 7, Func2 (++ i) zwraca 8 (wszyscy to wiedzą). Wewnętrznie obie funkcje zwiększają i do 8, ale zwracają różne wartości.

Więc i = i ++ wywołuje funkcję Func1. Wewnątrz funkcji zwiększa się do 8, ale po zakończeniu funkcja zwraca 7.

Ostatecznie 7 zostaje przydzielonych do i. (Więc w końcu i = 7)

Wynika to z faktu, że użyłeś operatora post-increment. W następującym wierszu kodu

x = x++;

Tak się składa, że ​​przypisujesz wartość x do x. przyrosty x ++ x po przypisaniu wartości x do x. Tak działają operatorzy działający po dodaniu. Działają po wykonaniu instrukcji. Więc w twoim kodzie x jest zwracane najpierw, a następnie zwiększane.

Jeśli tak

x = ++x;

Odpowiedź brzmiałaby 8, ponieważ użyłeś operatora wstępnego przyrostu. To zwiększa wartość najpierw przed zwróceniem wartości x.