x หลัง“ x = x ++” คืออะไร?

เกิดอะไรขึ้น (ด้านหลังม่าน) เมื่อดำเนินการสิ่งนี้

int x = 7;
x = x++;

นั่นคือเมื่อตัวแปรถูกโพสต์เพิ่มขึ้นและกำหนดให้กับตัวเองในหนึ่งคำสั่ง? ฉันรวบรวมและดำเนินการนี้ xยังคงเป็น 7 แม้หลังจากคำสั่งทั้งหมด ในหนังสือของฉันมันบอกว่าxมันเพิ่มขึ้น!

xจะได้รับเพิ่มขึ้น แต่คุณกำลังกำหนดค่าเก่าของxกลับเข้าไปในตัวมันเอง

x = x++;

1. x++เพิ่มxและคืนค่าเดิม
2. x = กำหนดค่าเก่าให้กับตัวเอง

ดังนั้นในที่สุดxได้รับมอบหมายกลับไปที่ค่าเริ่มต้น

x = x++;

เทียบเท่ากับ

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

คำสั่ง:

x = x++;

เทียบเท่ากับ:

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.

ในระยะสั้นคำสั่งไม่มีผล

ประเด็นสำคัญ:

• ค่าของนิพจน์การเพิ่ม / ลดการ Postfix คือค่าของตัวถูกดำเนินการก่อนที่จะมีการเพิ่ม / ลดลง (ในกรณีของแบบฟอร์มคำนำหน้าค่าเป็นค่าของตัวถูกดำเนินการหลังจากการดำเนินการ)

• RHS ของการแสดงออกที่ได้รับมอบหมายจะถูกประเมินอย่างสมบูรณ์ (รวมถึงการเพิ่มขึ้นการลดลงและ / หรือผลข้างเคียงอื่น ๆ ) ก่อนที่ค่าจะถูกกำหนดให้กับ LHS

_{โปรดทราบว่าไม่เหมือนกับ C และ C ++ ลำดับการประเมินผลของนิพจน์ใน Java ถูกระบุโดยสิ้นเชิงและไม่มีที่ว่างสำหรับรูปแบบเฉพาะแพลตฟอร์ม คอมไพเลอร์ได้รับอนุญาตให้เรียงลำดับการดำเนินการใหม่หากไม่เปลี่ยนผลลัพธ์ของการเรียกใช้โค้ดจากมุมมองของเธรดปัจจุบัน ในกรณีนี้คอมไพเลอร์จะได้รับอนุญาตให้เพิ่มประสิทธิภาพคำสั่งทั้งหมดออกไปเพราะสามารถพิสูจน์ได้ว่ามันเป็นแบบไม่มี op}

ในกรณีที่ไม่ชัดเจน:

• "x = x ++;" เป็นความผิดพลาดอย่างแน่นอนในโปรแกรมใด ๆ
• OP (สำหรับคำถามเดิม!) อาจหมายถึง "x ++;" แทนที่จะเป็น "x = x ++;"
• งบที่รวม Inc อัตโนมัติ / ลดลงและการมอบหมายในตัวแปรเดียวกันจะยากที่จะเข้าใจและดังนั้นจึงควรหลีกเลี่ยงโดยไม่คำนึงถึงความถูกต้องของพวกเขา ไม่จำเป็นต้องเขียนโค้ดอย่างนั้น

หวังว่าผู้ตรวจสอบรหัสเช่น FindBugs และ PMD จะทำเครื่องหมายรหัสเช่นนี้ว่าเป็นที่น่าสงสัย

int x = 7;
x = x++;

มันมีพฤติกรรมที่ไม่ได้กำหนดใน Cและสำหรับ Java เห็นคำตอบนี้ มันขึ้นอยู่กับคอมไพเลอร์ว่าเกิดอะไรขึ้น

โครงสร้างอย่างx = x++;บ่งชี้ว่าคุณอาจเข้าใจผิดว่าตัว++ดำเนินการทำอะไร:

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

ลองเขียนสิ่งนี้ใหม่เพื่อทำสิ่งเดียวกันโดยยึดการลบ++โอเปอเรเตอร์:

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

ตอนนี้เรามาเขียนใหม่เพื่อทำ (สิ่งที่ฉันคิด) คุณต้องการ:

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

ความละเอียดอ่อนที่นี่คือ++ผู้ประกอบการปรับเปลี่ยนตัวแปรxซึ่งแตกต่างจากการแสดงออกเช่นx + xซึ่งจะประเมินเป็นค่า int แต่ปล่อยให้ตัวแปรxตัวเองไม่เปลี่ยนแปลง พิจารณาการสร้างเช่นforห่วงที่เคารพ:

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

สังเกตเห็นi++ในที่นั่น? มันเป็นผู้ประกอบการเดียวกัน เราสามารถเขียนforลูปนี้แบบนี้และมันจะทำตัวเหมือนเดิม:

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

ฉันยังแนะนำไม่ให้ใช้++โอเปอเรเตอร์ในนิพจน์ที่ใหญ่กว่าในกรณีส่วนใหญ่ เนื่องจากความละเอียดอ่อนของเมื่อมันปรับเปลี่ยนตัวแปรดั้งเดิมในก่อนเพิ่มขึ้นโพสต์ ( ++xและx++ตามลำดับ) มันเป็นเรื่องง่ายมากที่จะแนะนำข้อบกพร่องที่ลึกซึ้งที่ยากที่จะติดตาม

ตามรหัสไบต์ที่ได้รับจากไฟล์คลาส

ทั้งสองได้รับมอบหมายเพิ่มขึ้น x แต่ความแตกต่างคือช่วงเวลาของ when the value is pushed onto the stack

ในCase1Push เกิดขึ้น (จากนั้นกำหนดในภายหลัง) ก่อนการเพิ่ม (หมายถึงการเพิ่มขึ้นของคุณไม่ได้ทำอะไรเลย)

ในการCase2เพิ่มขึ้นเกิดขึ้นครั้งแรก (ทำให้เป็น 8) จากนั้นผลักลงบนสแต็ก (และจากนั้นกำหนดให้กับ x)

กรณีที่ 1:

int x=7;
x=x++;

รหัสไบต์:

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

กรณีที่ 2:

int x=7; 
x=++x;

รหัสไบต์

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

• สแต็คที่นี่หมายถึงตัวถูกดำเนินการท้องถิ่น: ดัชนี x: 1 ประเภท: int

มันเพิ่มขึ้นหลังจาก " x = x++;" มันจะเป็น 8 ถ้าคุณทำ " x = ++x;"

ผู้ประกอบการโพสต์เพิ่มขึ้นทำงานดังนี้:

1. เก็บค่าก่อนหน้าของตัวถูกดำเนินการ
2. เพิ่มค่าของตัวถูกดำเนินการ
3. ส่งคืนค่าก่อนหน้าของตัวถูกดำเนินการ

ดังนั้นคำสั่ง

int x = 7;
x = x++; 

จะถูกประเมินดังนี้:

1. x ถูกเตรียมใช้งานด้วยค่า 7
2. ผู้ประกอบการที่เพิ่มขึ้นโพสต์เก็บค่าก่อนหน้าของ x คือ 7 เพื่อกลับ
3. เพิ่มค่า x ดังนั้นตอนนี้ x คือ 8
4. ส่งคืนค่าก่อนหน้าของ x ie 7 และถูกกำหนดกลับเป็น x ดังนั้น x จึงกลายเป็น 7 อีกครั้ง

ดังนั้น x จึงเพิ่มขึ้นแน่นอน แต่เนื่องจาก x ++ กำหนดผลลัพธ์กลับเป็น x ดังนั้นค่าของ x จะถูกแทนที่ด้วยค่าก่อนหน้า

การเพิ่มขึ้นเกิดขึ้นหลังจากที่ x ถูกเรียกดังนั้น x ยังคงเท่ากับ 7 ++ x จะเท่ากับ 8 เมื่อ x ถูกเรียก

เมื่อคุณกำหนดค่าใหม่สำหรับxมันยังคงเป็น 7 ลองx = ++xแล้วคุณจะได้ 8 อย่าง

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

เนื่องจาก x ++ เพิ่มค่าหลังจากการกำหนดให้กับตัวแปร เป็นต้นและระหว่างการดำเนินการของบรรทัดนี้:

x++;

varialbe x จะยังคงมีค่าดั้งเดิม (7) แต่การใช้ x อีกครั้งในบรรทัดอื่นเช่น

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

จะให้ 8

หากคุณต้องการใช้ค่าที่เพิ่มขึ้นของ x ในคำสั่งการมอบหมายให้ใช้

++x;

สิ่งนี้จะเพิ่ม x เป็น 1 จากนั้นกำหนดค่าให้กับตัวแปร x

[แก้ไข] แทน x = x ++ มันเป็นแค่ x ++; อดีตกำหนดค่าดั้งเดิมของ x ให้กับตัวเองดังนั้นจึงไม่ทำอะไรเลยในบรรทัดนั้น

เกิดอะไรขึ้นเมื่อint x = 7; x = x++;?

ans -> x++หมายถึงค่าการใช้งานครั้งแรกของ x สำหรับนิพจน์แล้วเพิ่มขึ้นทีละ 1
นี่คือสิ่งที่เกิดขึ้นในกรณีของคุณ ค่าของ x บน RHS จะถูกคัดลอกไปยังตัวแปร x บน LHS แล้วค่าของxจะเพิ่มขึ้น 1

ในทำนองเดียวกัน++x หมายถึงการ ->เพิ่มค่าของ x ก่อนโดยหนึ่งแล้วใช้ในการแสดงออก
ดังนั้นในกรณีของคุณถ้าคุณทำ x = ++x ; // where x = 7
คุณจะได้รับค่า 8

เพื่อความชัดเจนยิ่งขึ้นลองดูว่าจะมีคำสั่ง printf จำนวนเท่าใดรันโค้ดต่อไปนี้

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

++xคือ pre-increment ->x ถูกเพิ่มขึ้นก่อนที่จะใช้งาน
x++คือการเพิ่ม->ขึ้นภายหลัง x จะเพิ่มขึ้นหลังจากการใช้งาน

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

ดังนั้นนี่หมายความว่า: x++ไม่เท่ากับx = x+1

เพราะ:

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

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

และตอนนี้ดูเหมือนแปลกเล็กน้อย:

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

คอมไพเลอร์ขึ้นอยู่มาก!

x = x ++;

นี่คือตัวดำเนินการที่เพิ่มขึ้นภายหลัง ควรเข้าใจว่าเป็น "ใช้ค่าของตัวถูกดำเนินการแล้วเพิ่มตัวถูกดำเนินการ"

หากคุณต้องการให้สิ่งที่ตรงกันข้ามเกิดขึ้นเช่น "เพิ่มตัวถูกดำเนินการแล้วใช้ค่าของตัวถูกดำเนินการ" คุณต้องใช้ตัวดำเนินการเพิ่มล่วงหน้าดังที่แสดงด้านล่าง

x = ++ x;

โอเปอเรเตอร์นี้จะเพิ่มค่าของ x เป็น 1 ก่อนจากนั้นจึงกำหนดค่ากลับเป็น x

ฉันคิดว่าความขัดแย้งนี้สามารถแก้ไขได้โดยไม่ต้องใช้รหัสและแค่คิด

พิจารณา i ++ & ++ i เป็นฟังก์ชันพูด Func1 & Func2

ตอนนี้ฉัน = 7;
Func1 (i ++) ส่งคืน 7, Func2 (++ i) ส่งคืน 8 (ทุกคนรู้สิ่งนี้) ภายในทั้งสองฟังก์ชั่นเพิ่มขึ้น i ถึง 8 แต่พวกเขากลับค่าที่แตกต่าง

ดังนั้นฉัน = i ++ เรียกฟังก์ชัน Func1 ภายในฟังก์ชัน i เพิ่มขึ้นเป็น 8 แต่เมื่อทำเสร็จแล้วฟังก์ชันจะคืนค่า 7

ดังนั้นในที่สุด 7 ได้รับการจัดสรรให้ฉัน (ดังนั้นในที่สุด i = 7)

นี่เป็นเพราะคุณใช้ตัวดำเนินการที่เพิ่มขึ้นภายหลัง ในบรรทัดของรหัสต่อไปนี้

x = x++;

สิ่งที่เกิดขึ้นคือคุณกำลังกำหนดค่าของ x เป็น x x ++ เพิ่มขึ้น x หลังจากค่าของ x ถูกกำหนดให้กับ x นั่นคือการทำงานของผู้ให้บริการหลังการเพิ่ม มันทำงานได้หลังจากมีการดำเนินการคำสั่ง ดังนั้นในรหัสของคุณ x จะถูกส่งกลับก่อนหลังจากนั้นจะเพิ่มขึ้นทีหลัง

ถ้าคุณทำ

x = ++x;

คำตอบคือ 8 เพราะคุณใช้โอเปอเรเตอร์ที่เพิ่มขึ้นล่วงหน้า ค่านี้จะเพิ่มค่าก่อนที่จะส่งคืนค่าของ x