Tại sao điều này đi vào một vòng lặp vô hạn?

Tôi có đoạn mã sau:

public class Tests {
    public static void main(String[] args) throws Exception {
        int x = 0;
        while(x<3) {
            x = x++;
            System.out.println(x);
        }
    }
}

Chúng tôi biết anh ta nên viết chỉ x++hoặc x=x+1, nhưng x = x++trước tiên nó nên thuộc tính xcho chính nó, và sau đó tăng nó. Tại sao xtiếp tục với 0giá trị?

- ngày

Đây là mã byte:

public class Tests extends java.lang.Object{
public Tests();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[])   throws java.lang.Exception;
  Code:
   0:   iconst_0
   1:   istore_1
   2:   iload_1
   3:   iconst_3
   4:   if_icmpge   22
   7:   iload_1
   8:   iinc    1, 1
   11:  istore_1
   12:  getstatic   #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   15:  iload_1
   16:  invokevirtual   #3; //Method java/io/PrintStream.println:(I)V
   19:  goto    2
   22:  return

}

Tôi sẽ đọc về các hướng dẫn để cố gắng hiểu ...

Lưu ý : Ban đầu tôi đã đăng mã C # trong câu trả lời này cho mục đích minh họa, vì C # cho phép bạn truyền inttham số bằng cách tham chiếu với reftừ khóa. Tôi đã quyết định cập nhật nó với mã Java hợp pháp thực tế bằng cách sử dụng MutableIntlớp đầu tiên tôi tìm thấy trên Google để sắp xếp gần đúng những gì reftrong C #. Tôi thực sự không thể biết nếu điều đó giúp hoặc làm tổn thương câu trả lời. Tôi sẽ nói rằng cá nhân tôi đã không thực hiện tất cả sự phát triển Java đó; vì vậy đối với tất cả tôi biết có thể có nhiều cách thành ngữ hơn để minh họa điểm này.

Có lẽ nếu chúng ta viết ra một phương pháp để làm tương đương với những gì x++nó sẽ làm cho điều này rõ ràng hơn.

public MutableInt postIncrement(MutableInt x) {
    int valueBeforeIncrement = x.intValue();
    x.add(1);
    return new MutableInt(valueBeforeIncrement);
}

Đúng? Tăng giá trị được thông qua và trả về giá trị ban đầu: đó là định nghĩa của toán tử postrement.

Bây giờ, hãy xem cách hành vi này diễn ra trong mã ví dụ của bạn:

MutableInt x = new MutableInt();
x = postIncrement(x);

postIncrement(x)Làm gì? Tăng x, vâng. Và sau đó trả về những gì x là trước khi tăng . Giá trị trả về này sau đó được gán cho x.

Vì vậy, thứ tự của các giá trị được gán xlà 0, rồi 1, rồi 0.

Điều này có thể rõ ràng hơn nếu chúng ta viết lại ở trên:

MutableInt x = new MutableInt();    // x is 0.
MutableInt temp = postIncrement(x); // Now x is 1, and temp is 0.
x = temp;                           // Now x is 0 again.

Sự cố định của bạn về thực tế là khi bạn thay thế xở phía bên trái của bài tập trên y, "bạn có thể thấy rằng nó đầu tiên tăng x, và sau đó quy nó thành y" khiến tôi bối rối. Nó không phải xlà được giao cho y; nó là giá trị trước đây được gán chox . Thực sự, tiêm ykhiến mọi thứ không khác với kịch bản trên; chúng tôi chỉ đơn giản là có:

MutableInt x = new MutableInt();    // x is 0.
MutableInt y = new MutableInt();    // y is 0.
MutableInt temp = postIncrement(x); // Now x is 1, and temp is 0.
y = temp;                           // y is still 0.

Vì vậy, rõ ràng: x = x++hiệu quả không thay đổi giá trị của x. Nó luôn khiến x có các giá trị x ₀ , sau đó x ₀ + 1 và sau đó x ₀ lần nữa.

Cập nhật : Ngẫu nhiên, e rằng bạn nghi ngờ rằng xđã từng được gán cho 1 "giữa" thao tác tăng và phép gán trong ví dụ trên, tôi đã đưa ra một bản demo nhanh để minh họa rằng giá trị trung gian này thực sự "tồn tại", mặc dù nó sẽ không bao giờ được "nhìn thấy" trên luồng thực thi.

Bản demo gọi x = x++;trong một vòng lặp trong khi một luồng riêng biệt liên tục in giá trị của xbàn điều khiển.

public class Main {
    public static volatile int x = 0;

    public static void main(String[] args) {
        LoopingThread t = new LoopingThread();
        System.out.println("Starting background thread...");
        t.start();

        while (true) {
            x = x++;
        }
    }
}

class LoopingThread extends Thread {
    public @Override void run() {
        while (true) {
            System.out.println(Main.x);
        }
    }
}

Dưới đây là một đoạn trích của đầu ra của chương trình trên. Lưu ý sự xuất hiện bất thường của cả 1 và 0.

Bắt đầu chủ đề nền ...
0
0
1
1
0
0
0
0
0
0
0
0
0
0
1
0
1

x = x++ hoạt động theo cách sau:

• Đầu tiên nó đánh giá biểu thức x++. Đánh giá biểu thức này tạo ra một giá trị biểu thức (là giá trị của xtrước khi tăng) và gia số x.
• Sau đó, nó gán giá trị biểu thức cho x, ghi đè giá trị tăng dần.

Vì vậy, chuỗi các sự kiện trông như sau (đó là một mã byte được dịch ngược thực tế, như được tạo bởi javap -c, với các nhận xét của tôi):

   8: iload_1 // Ghi nhớ giá trị hiện tại của x trong ngăn xếp
   9: iinc 1, 1 // Tăng x (không thay đổi ngăn xếp)
   12: istore_1 // Viết giá trị được ghi nhớ từ ngăn xếp vào x

Để so sánh , x = ++x:

   8: iinc 1, 1 // Tăng x
   11: iload_1 // Đẩy giá trị của x lên ngăn xếp
   12: istore_1 // Giá trị pop từ ngăn xếp đến x

Điều này xảy ra bởi vì giá trị của xkhông được tăng lên chút nào.

x = x++;

tương đương với

int temp = x;
x++;
x = temp;

Giải trình:

Hãy xem mã byte cho thao tác này. Xem xét một lớp mẫu:

class test {
    public static void main(String[] args) {
        int i=0;
        i=i++;
    }
}

Bây giờ đang chạy trình phân tách lớp trên này, chúng tôi nhận được:

$ javap -c test
Compiled from "test.java"
class test extends java.lang.Object{
test();
  Code:
   0:    aload_0
   1:    invokespecial    #1; //Method java/lang/Object."<init>":()V
   4:    return

public static void main(java.lang.String[]);
  Code:
   0:    iconst_0
   1:    istore_1
   2:    iload_1
   3:    iinc    1, 1
   6:    istore_1
   7:    return
}

Bây giờ Java VM được xếp chồng dựa trên nghĩa là cho mỗi thao tác, dữ liệu sẽ được đẩy lên ngăn xếp và từ ngăn xếp, dữ liệu sẽ bật ra để thực hiện thao tác. Ngoài ra còn có một cấu trúc dữ liệu khác, điển hình là một mảng để lưu trữ các biến cục bộ. Các biến cục bộ được cung cấp id chỉ là các chỉ mục cho mảng.

Chúng ta hãy nhìn vào các mnemonics trong main()phương pháp:

• iconst_0: Giá trị không đổi 0 được đẩy vào ngăn xếp.
• istore_1: Phần tử trên cùng của ngăn xếp được bật ra và được lưu trữ trong biến cục bộ với chỉ mục 1
  là x.
• iload_1: Giá trị tại vị trí 1là giá trị của x nó 0, được đẩy vào ngăn xếp.
• iinc 1, 1: Giá trị tại vị trí bộ nhớ 1được tăng lên theo 1. Vì vậy, xbây giờ trở thành 1.
• istore_1: Giá trị ở đầu ngăn xếp được lưu trữ vào vị trí bộ nhớ 1. Điều đó được 0chỉ định để x ghi đè giá trị gia tăng của nó.

Do đó giá trị của xkhông thay đổi dẫn đến vòng lặp vô hạn.

1. Ký hiệu tiền tố sẽ tăng biến TRƯỚC KHI biểu thức được ước tính.
2. Ký hiệu postfix sẽ tăng SAU khi đánh giá biểu thức.

Tuy nhiên " =" có quyền ưu tiên toán tử thấp hơn " ++".

Vậy x=x++;nên đánh giá như sau.

1. x chuẩn bị cho nhiệm vụ (đánh giá)
2. x tăng lên
3. Giá trị trước xđược gán cho x.

Không có câu trả lời nào khá đúng, vì vậy hãy vào đây:

Khi bạn viết int x = x++, bạn không chỉ định xlà chính nó ở giá trị mới, bạn đang gán xlà giá trị trả về của x++biểu thức. Điều này xảy ra là giá trị ban đầu của x, như được gợi ý trong câu trả lời của Colin Cochrane .

Để giải trí, hãy kiểm tra mã sau:

public class Autoincrement {
        public static void main(String[] args) {
                int x = 0;
                System.out.println(x++);
                System.out.println(x);
        }
}

Kết quả sẽ là

0
1

Giá trị trả về của biểu thức là giá trị ban đầu của x, bằng không. Nhưng sau này, khi đọc giá trị của x, chúng tôi nhận được giá trị cập nhật, đó là một giá trị.

Nó đã được giải thích tốt bởi khác. Tôi chỉ bao gồm các liên kết đến các phần đặc tả Java có liên quan.

x = x ++ là một biểu thức. Java sẽ tuân theo thứ tự đánh giá . Đầu tiên, nó sẽ đánh giá biểu thức x ++, sẽ tăng x và đặt giá trị kết quả thành giá trị trước đó của x . Sau đó, nó sẽ gán kết quả biểu thức cho biến x. Cuối cùng, x trở lại giá trị trước đó.

Tuyên bố này:

x = x++;

đánh giá như thế này:

1. Đẩy xlên ngăn xếp;
2. Tăng x;
3. Pop xtừ ngăn xếp.

Vì vậy, giá trị là không thay đổi. So sánh với:

x = ++x;

được đánh giá là:

1. Tăng x;
2. Đẩy xlên ngăn xếp;
3. Pop xtừ ngăn xếp.

Những gì bạn muốn là:

while (x < 3) {
  x++;
  System.out.println(x);
}

Câu trả lời là khá đơn giản. Nó phải làm với thứ tự được đánh giá. x++trả về giá trị xsau đó tăng dần x.

Do đó, giá trị của biểu thức x++là 0. Vì vậy, bạn đang chỉ định x=0mỗi lần trong vòng lặp. Chắc chắn x++tăng giá trị này, nhưng điều đó xảy ra trước khi chuyển nhượng.

Từ http://doad.oracle.com/javase/tutorial/java/nutsandbolts/op1.html

Các toán tử tăng / giảm có thể được áp dụng trước (tiền tố) hoặc sau (hậu tố) toán hạng. Kết quả mã ++; và kết quả ++; cả hai sẽ kết thúc trong kết quả được tăng lên bởi một. Sự khác biệt duy nhất là phiên bản tiền tố (kết quả ++) ước tính giá trị tăng dần, trong khi phiên bản hậu tố (kết quả ++) ước tính giá trị ban đầu . Nếu bạn chỉ thực hiện một mức tăng / giảm đơn giản, thì việc bạn chọn phiên bản nào thực sự không quan trọng. Nhưng nếu bạn sử dụng toán tử này trong một phần của biểu thức lớn hơn, thì biểu thức bạn chọn có thể tạo ra sự khác biệt đáng kể.

Để minh họa, hãy thử như sau:

    int x = 0;
    int y = 0;
    y = x++;
    System.out.println(x);
    System.out.println(y);

Mà sẽ in 1 và 0.

Bạn thực sự có được các hành vi sau đây.

1. lấy giá trị của x (bằng 0) làm "kết quả" của bên phải
2. tăng giá trị của x (vì vậy x bây giờ là 1)
3. gán kết quả của phía bên phải (được lưu là 0) cho x (x bây giờ là 0)

Ý tưởng là toán tử tăng sau (x ++) tăng biến đó trong câu hỏi SAU trả về giá trị của nó để sử dụng trong phương trình mà nó được sử dụng trong.

Chỉnh sửa: Thêm một chút vì nhận xét. Hãy xem xét nó như sau.

x = 1;        // x == 1
x = x++ * 5;
              // First, the right hand side of the equation is evaluated.
  ==>  x = 1 * 5;    
              // x == 2 at this point, as it "gave" the equation its value of 1
              // and then gets incremented by 1 to 2.
  ==>  x = 5;
              // And then that RightHandSide value is assigned to 
              // the LeftHandSide variable, leaving x with the value of 5.

Bạn không thực sự cần mã máy để hiểu những gì đang xảy ra.

Theo định nghĩa:

1. Toán tử gán đánh giá biểu thức phía bên phải và lưu trữ nó trong một biến tạm thời.

   1.1. Giá trị hiện tại của x được sao chép vào biến tạm thời này

   1.2. x được tăng lên ngay bây giờ.

2. Biến tạm thời sau đó được sao chép vào phía bên trái của biểu thức, là x tình cờ! Vì vậy, đó là lý do tại sao giá trị cũ của x lại được sao chép vào chính nó.

Nó khá đơn giản.

Điều này là do nó không bao giờ được tăng lên trong trường hợp này. x++sẽ sử dụng giá trị của nó trước khi tăng như trong trường hợp này, nó sẽ giống như:

x = 0;

Nhưng nếu bạn làm ++x;điều này sẽ tăng lên.

Giá trị giữ ở mức 0 vì giá trị x++là 0. Trong trường hợp này, không có vấn đề gì nếu giá trị của xtăng hay không, việc gán x=0được thực thi. Điều này sẽ ghi đè lên giá trị tăng tạm thời của x(là 1 trong "thời gian rất ngắn").

Điều này hoạt động như thế nào bạn mong đợi người khác. Đó là sự khác biệt giữa tiền tố và hậu tố.

int x = 0; 
while (x < 3)    x = (++x);

Hãy nghĩ về x ++ như một lời gọi hàm "trả về" giá trị X trước khi tăng (đó là lý do tại sao nó được gọi là tăng sau).

Vì vậy, thứ tự thao tác là:
1: cache giá trị của x trước khi tăng
2: tăng x
3: trả về giá trị được lưu (x trước khi tăng)
4: giá trị trả về được gán cho x

Khi ++ ở trên rhs, kết quả được trả về trước khi số được tăng lên. Thay đổi thành ++ x và nó sẽ ổn thôi. Java sẽ tối ưu hóa điều này để thực hiện một thao tác duy nhất (gán x cho x) thay vì tăng.

Theo như tôi có thể thấy, lỗi xảy ra, do việc gán ghi đè giá trị tăng dần, với giá trị trước khi tăng, tức là nó hoàn tác gia tăng.

Cụ thể, biểu thức "x ++", có giá trị 'x' trước khi tăng so với "++ x" có giá trị 'x' sau khi tăng.

Nếu bạn quan tâm đến việc điều tra mã byte, chúng tôi sẽ xem xét ba dòng trong câu hỏi:

 7:   iload_1
 8:   iinc    1, 1
11:  istore_1

7: iload_1 # Sẽ đặt giá trị của biến cục bộ thứ 2 trên ngăn xếp
8: iinc 1,1 # sẽ tăng biến cục bộ thứ 2 lên 1, lưu ý rằng nó sẽ không bị ảnh hưởng!
9: istore_1 # Sẽ bật đầu ngăn xếp và lưu giá trị của phần tử này vào biến cục bộ thứ 2
(Bạn có thể đọc các hiệu ứng của từng lệnh JVM tại đây )

Đây là lý do tại sao đoạn mã trên sẽ lặp vô hạn, trong khi phiên bản có ++ x thì không. Mã byte cho ++ x sẽ trông khá khác biệt, theo như tôi nhớ từ trình biên dịch Java 1.3 tôi đã viết cách đây một năm, mã byte phải đi như thế này:

iinc 1,1
iload_1
istore_1

Vì vậy, chỉ cần hoán đổi hai dòng đầu tiên, thay đổi ngữ nghĩa sao cho giá trị còn lại trên đỉnh ngăn xếp, sau giá trị tăng (tức là 'giá trị' của biểu thức) là giá trị sau khi tăng.

    x++
=: (x = x + 1) - 1

Vì thế:

   x = x++;
=> x = ((x = x + 1) - 1)
=> x = ((x + 1) - 1)
=> x = x; // Doesn't modify x!

Trong khi

   ++x
=: x = x + 1

Vì thế:

   x = ++x;
=> x = (x = x + 1)
=> x = x + 1; // Increments x

Tất nhiên kết quả cuối cùng cũng giống như chỉ x++;hoặc ++x;trên một dòng.

 x = x++; (increment is overriden by = )

vì tuyên bố trên x không bao giờ đạt 3;

Tôi tự hỏi nếu có bất cứ điều gì trong đặc tả Java xác định chính xác hành vi của điều này. (Hàm ý rõ ràng của câu nói đó là tôi quá lười kiểm tra.)

Lưu ý từ mã byte của Tom, các dòng chính là 7, 8 và 11. Dòng 7 tải x vào ngăn xếp tính toán. Dòng 8 tăng x. Dòng 11 lưu giá trị từ ngăn xếp trở lại x. Trong trường hợp bình thường khi bạn không gán lại giá trị cho mình, tôi không nghĩ sẽ có bất kỳ lý do nào khiến bạn không thể tải, lưu trữ, sau đó tăng dần. Bạn sẽ nhận được kết quả tương tự.

Giống như, giả sử bạn có một trường hợp bình thường hơn khi bạn viết một cái gì đó như: z = (x ++) + (y ++);

Cho dù nó nói (mã giả để bỏ qua kỹ thuật)

load x
increment x
add y
increment y
store x+y to z

hoặc là

load x
add y
store x+y to z
increment x
increment y

nên không liên quan. Hoặc là thực hiện nên hợp lệ, tôi sẽ nghĩ.

Tôi cực kỳ thận trọng về việc viết mã phụ thuộc vào hành vi này. Nó trông rất phụ thuộc vào việc thực hiện, giữa các vết nứt đối với tôi. Lần duy nhất nó sẽ tạo ra sự khác biệt là nếu bạn làm điều gì đó điên rồ, như ví dụ ở đây hoặc nếu bạn có hai luồng đang chạy và phụ thuộc vào thứ tự đánh giá trong biểu thức.

Tôi nghĩ bởi vì trong Java ++ có độ ưu tiên cao hơn = (gán) ... Phải không? Hãy xem http://www.cs.uwf.edu/~eelsheik/cop2253/resource/op_precedence.html ...

Cách tương tự nếu bạn viết x = x + 1 ... + có độ ưu tiên cao hơn = (gán)

Các x++biểu thức đánh giá đến x. Phần ++ảnh hưởng đến giá trị sau khi đánh giá , không phải sau tuyên bố . vì vậy x = x++được dịch thành hiệu quả

int y = x; // evaluation
x = x + 1; // increment part
x = y; // assignment

Trước khi tăng giá trị lên một, giá trị được gán cho biến.

Nó xảy ra bởi vì nó tăng bài. Nó có nghĩa là biến được tăng lên sau khi biểu thức được ước tính.

int x = 9;
int y = x++;

x bây giờ là 10, nhưng y là 9, giá trị của x trước khi nó được tăng lên.

Xem thêm trong Định nghĩa của bài tăng .

Kiểm tra mã dưới đây,

    int x=0;
    int temp=x++;
    System.out.println("temp = "+temp);
    x = temp;
    System.out.println("x = "+x);

đầu ra sẽ là,

temp = 0
x = 0

post incrementcó nghĩa là tăng giá trị và trả về giá trị trước khi tăng . Đó là lý do tại sao giá trị templà 0. Vì vậy, những gì nếu temp = ivà đây là trong một vòng lặp (ngoại trừ dòng mã đầu tiên). giống như trong câu hỏi !!!!

Toán tử gia tăng được áp dụng cho cùng một biến như bạn đang gán. Đó là yêu cầu rắc rối. Tôi chắc chắn rằng bạn có thể thấy giá trị của biến x của mình trong khi chạy chương trình này .... điều đó sẽ làm rõ lý do tại sao vòng lặp không bao giờ kết thúc.