X sau khi x = x ++ là gì?

Điều gì xảy ra (đằng sau tấm màn) khi điều này được thực thi?

int x = 7;
x = x++;

Đó là, khi một biến được tăng lên và được gán cho chính nó trong một câu lệnh? Tôi đã biên soạn và thực hiện điều này. xvẫn là 7 ngay cả sau khi toàn bộ tuyên bố . Trong cuốn sách của tôi, nó nói rằng nó xđược tăng lên!

xkhông được tăng lên. Nhưng bạn đang gán giá trị cũ xtrở lại vào chính nó.

x = x++;

1. x++tăng xvà trả về giá trị cũ của nó.
2. x = gán giá trị cũ trở lại chính nó.

Vì vậy, cuối cùng, xđược gán trở lại giá trị ban đầu của nó.

x = x++;

tương đương với

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

Tuyên bố:

x = x++;

tương đương với:

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.

Tóm lại, tuyên bố không có hiệu lực.

Những điểm chính:

• Giá trị của biểu thức tăng / giảm Postfix là giá trị của toán hạng trước khi tăng / giảm diễn ra. (Trong trường hợp biểu mẫu Tiền tố, giá trị là giá trị của toán hạng sau thao tác,)

• RHS của biểu thức gán được đánh giá hoàn toàn (bao gồm mọi mức tăng, giảm và / hoặc các tác dụng phụ khác) trước khi giá trị được gán cho LHS.

_{Lưu ý rằng không giống như C và C ++, thứ tự đánh giá biểu thức trong Java hoàn toàn được chỉ định và không có chỗ cho biến thể dành riêng cho nền tảng. Trình biên dịch chỉ được phép sắp xếp lại các hoạt động nếu điều này không thay đổi kết quả thực thi mã từ phối cảnh của luồng hiện tại. Trong trường hợp này, một trình biên dịch sẽ được phép tối ưu hóa toàn bộ câu lệnh bởi vì nó có thể được chứng minh rằng nó là không có.}

Trong trường hợp nó chưa rõ ràng:

• "x = x ++;" gần như chắc chắn là một sai lầm trong bất kỳ chương trình.
• OP (cho câu hỏi ban đầu!) Có lẽ có nghĩa là "x ++;" thay vì "x = x ++;".
• Các câu lệnh kết hợp tự động giảm / giảm và gán trên cùng một biến là khó hiểu, và do đó nên tránh bất kể tính chính xác của chúng . Đơn giản là không cần phải viết mã như thế.

Hy vọng rằng, những người kiểm tra mã như FindBugs và PMD sẽ đánh dấu mã như thế này là đáng ngờ.

int x = 7;
x = x++;

Nó có hành vi không xác định trong C và cho Java xem câu trả lời này . Nó phụ thuộc vào trình biên dịch những gì xảy ra.

Cấu trúc như x = x++;thể hiện bạn có thể hiểu sai những gì người ++vận hành làm:

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

Hãy viết lại điều này để làm điều tương tự, dựa trên việc loại bỏ ++toán tử:

// 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

Bây giờ, hãy viết lại để làm (những gì tôi nghĩ) bạn muốn:

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

Sự tinh tế ở đây là ++toán tử sửa đổi biếnx , không giống như một biểu thức x + x, như sẽ đánh giá một giá trị int nhưng xkhông thay đổi chính biến đó. Hãy xem xét một cấu trúc như forvòng lặp đáng kính :

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

Thông báo i++trong đó? Đó là cùng một nhà điều hành. Chúng ta có thể viết lại forvòng lặp này như thế này và nó sẽ hoạt động giống nhau:

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

Tôi cũng khuyên bạn không nên sử dụng ++toán tử trong các biểu thức lớn hơn trong hầu hết các trường hợp. Do sự tinh tế khi nó sửa đổi biến ban đầu theo mức tăng trước so với sau tăng ( ++xvà x++, tương ứng), nên rất dễ đưa ra các lỗi tinh vi rất khó theo dõi.

Theo mã Byte thu được từ các tệp lớp,

Cả hai bài tập tăng x, nhưng sự khác biệt là thời gian của when the value is pushed onto the stack

Trong Case1, Đẩy xảy ra (và sau đó được gán) trước khi tăng (về cơ bản có nghĩa là gia số của bạn không làm gì cả)

Trong Case2, Tăng xảy ra đầu tiên (làm cho nó 8) và sau đó được đẩy lên ngăn xếp (và sau đó được gán cho x)

Trường hợp 1:

int x=7;
x=x++;

Mã byte:

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

Trường hợp 2:

int x=7; 
x=++x;

Mã byte

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

• Stack ở đây đề cập đến Toán tử Stack, local: x index: 1 type: int

Nó tăng lên sau " x = x++;". Sẽ là 8 nếu bạn làm " x = ++x;".

Toán tử Post Post hoạt động như sau:

1. Lưu trữ giá trị trước đó của toán hạng.
2. Tăng giá trị của toán hạng.
3. Trả về giá trị trước đó của toán hạng.

Vì vậy, tuyên bố

int x = 7;
x = x++; 

sẽ được đánh giá như sau:

1. x được khởi tạo với giá trị 7
2. toán tử gia tăng lưu trữ giá trị trước đó của x tức là 7 để trả về.
3. Tăng x, vì vậy bây giờ x là 8
4. Trả về giá trị trước đó của x tức là 7 và nó được gán lại cho x, do đó x lại trở thành 7

Vì vậy, x thực sự tăng nhưng vì x ++ đang gán kết quả cho x nên giá trị của x bị ghi đè lên giá trị trước đó.

Gia số xảy ra sau khi x được gọi, vì vậy x vẫn bằng 7. ++ x sẽ bằng 8 khi x được gọi

Khi bạn gán lại giá trị cho xnó vẫn là 7. Hãy thử x = ++xvà bạn sẽ nhận được 8 cái khác làm

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

bởi vì x ++ tăng giá trị SAU khi gán nó cho biến. và trong quá trình thực hiện dòng này:

x++;

varialbe x vẫn sẽ có giá trị ban đầu (7), nhưng sử dụng lại x trên một dòng khác, chẳng hạn như

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

sẽ cung cấp cho bạn 8.

nếu bạn muốn sử dụng giá trị tăng của x trên câu lệnh gán của mình, hãy sử dụng

++x;

Điều này sẽ tăng x thêm 1, THEN gán giá trị đó cho biến x.

[Chỉnh sửa] thay vì x = x ++, đó chỉ là x ++; cái trước gán giá trị ban đầu của x cho chính nó, vì vậy nó thực sự không làm gì trên dòng đó.

Điều gì xảy ra khi int x = 7; x = x++;nào?

ans -> x++có nghĩa là giá trị sử dụng đầu tiên của x cho biểu thức và sau đó tăng nó lên 1.
Đây là những gì xảy ra trong trường hợp của bạn. Giá trị của x trên RHS được sao chép vào biến x trên LHS và sau đó giá trị của xđược tăng thêm 1.

Tương tự ++x có nghĩa là ->tăng giá trị của x trước một và sau đó sử dụng trong biểu thức.
Vì vậy, trong trường hợp của bạn nếu bạn làm, x = ++x ; // where x = 7
bạn sẽ nhận được giá trị 8.

Để rõ ràng hơn, hãy thử tìm hiểu có bao nhiêu câu lệnh printf sẽ thực thi đoạn mã sau

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

++xđược pre-increment ->x được tăng lên trước khi được sử dụng
x++là hậu increment ->x được tăng lên sau khi được sử dụng

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

Vì vậy, điều này có nghĩa là: x++không bằngx = x+1

bởi vì:

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

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

và bây giờ có vẻ hơi lạ:

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

rất phụ thuộc trình biên dịch!

x = x ++;

Đây là toán tử tăng sau. Nó nên được hiểu là "Sử dụng giá trị của toán hạng và sau đó tăng toán hạng".

Nếu bạn muốn điều ngược lại xảy ra, tức là "Tăng toán hạng và sau đó sử dụng giá trị của toán hạng", bạn phải sử dụng toán tử tăng trước như dưới đây.

x = ++ x;

Toán tử này trước tiên tăng giá trị của x lên 1 và sau đó gán giá trị lại cho x.

Tôi nghĩ rằng tranh cãi này có thể được giải quyết mà không cần đi sâu vào mã & chỉ cần suy nghĩ.

Hãy coi i ++ & ++ i là các hàm, giả sử Func1 & Func2.

Bây giờ tôi = 7;
Func1 (i ++) trả về 7, Func2 (++ i) trả về 8 (mọi người đều biết điều này). Bên trong cả hai hàm tăng i lên 8, nhưng chúng trả về các giá trị khác nhau.

Vì vậy, i = i ++ gọi hàm Func1. Bên trong hàm i tăng lên 8, nhưng khi hoàn thành, hàm trả về 7.

Vì vậy, cuối cùng 7 được phân bổ cho i. (Vì vậy, cuối cùng, i = 7)

Điều này là do bạn đã sử dụng một toán tử tăng sau. Trong dòng mã sau đây

x = x++;

Điều gì xảy ra là, bạn đang gán giá trị của x cho x. x ++ tăng x sau khi giá trị của x được gán cho x. Đó là cách các toán tử tăng sau làm việc. Họ làm việc sau khi một tuyên bố đã được thực thi. Vì vậy, trong mã của bạn, x được trả về trước sau đó tăng dần.

Nếu bạn đã làm

x = ++x;

Câu trả lời sẽ là 8 vì bạn đã sử dụng toán tử tăng trước. Điều này làm tăng giá trị trước khi trả về giá trị của x.