เหตุใดตัวดำเนินการด้านท้ายที่มีเครื่องหมายจุลภาคจึงประเมินเพียงนิพจน์เดียวในกรณีจริง

ฉันกำลังเรียนรู้ C ++ ด้วยหนังสือ C ++ Primer และหนึ่งในแบบฝึกหัดในหนังสือเล่มนี้คือ:

อธิบายว่านิพจน์ต่อไปนี้ใช้ทำอะไร: someValue ? ++x, ++y : --x, --y

เรารู้อะไรบ้าง? เราทราบดีว่าตัวดำเนินการ ternary มีลำดับความสำคัญสูงกว่าตัวดำเนินการลูกน้ำ ด้วยตัวดำเนินการไบนารีสิ่งนี้ค่อนข้างเข้าใจได้ง่าย แต่สำหรับตัวดำเนินการด้านท้ายฉันกำลังดิ้นรนเล็กน้อย ด้วยตัวดำเนินการไบนารี "มีลำดับความสำคัญสูงกว่า" หมายความว่าเราสามารถใช้วงเล็บรอบนิพจน์ที่มีลำดับความสำคัญสูงกว่าและจะไม่เปลี่ยนแปลงการดำเนินการ

สำหรับตัวดำเนินการ ternary ฉันจะทำ:

(someValue ? ++x, ++y : --x, --y)

ทำให้เกิดรหัสเดียวกันอย่างมีประสิทธิภาพซึ่งไม่ได้ช่วยฉันในการทำความเข้าใจว่าคอมไพเลอร์จะจัดกลุ่มโค้ดอย่างไร

อย่างไรก็ตามจากการทดสอบกับคอมไพเลอร์ C ++ ฉันรู้ว่านิพจน์นั้นรวบรวมและฉันไม่รู้ว่าตัว:ดำเนินการใดสามารถยืนได้ด้วยตัวเอง ดังนั้นคอมไพเลอร์ดูเหมือนจะตีความตัวดำเนินการ ternary อย่างถูกต้อง

จากนั้นฉันดำเนินการโปรแกรมด้วยสองวิธี:

#include <iostream>

int main()
{
    bool someValue = true;
    int x = 10, y = 10;

    someValue ? ++x, ++y : --x, --y;

    std::cout << x << " " << y << std::endl;
    return 0;
}

ผลลัพธ์ใน:

11 10

ในทางกลับกันsomeValue = falseมันพิมพ์:

9 9

ทำไมจะ c ++ คอมไพเลอร์สร้างรหัสที่จริงสาขาของผู้ประกอบการ ternary เพียงการเพิ่มขึ้นxในขณะที่สำหรับเท็จสาขาของ ternary มัน decrements ทั้งสองxและy?

ฉันไปไกลถึงการใส่วงเล็บรอบ ๆ สาขาจริงเช่นนี้:

someValue ? (++x, ++y) : --x, --y;

11 10แต่ก็ยังส่งผลในการ

ดังที่@Raketeกล่าวในคำตอบที่ยอดเยี่ยมของพวกเขานี่เป็นเรื่องยุ่งยาก ขอเพิ่มเติมนิดนึงว่า

ตัวดำเนินการ ternary ต้องมีแบบฟอร์ม:

? การ กำหนดนิพจน์ตรรกะหรือ: นิพจน์

ดังนั้นเราจึงมีการแมปต่อไปนี้:

• someValue: ตรรกะหรือนิพจน์
• ++x, ++y: นิพจน์
• ??? มอบหมาย เป็นนิพจน์--x, --yหรือเท่านั้น--x?

ในความเป็นจริงเป็นเพียง--xเพราะไม่สามารถแยกวิเคราะห์นิพจน์การมอบหมายเป็นสองนิพจน์ที่คั่นด้วยเครื่องหมายจุลภาค (ตามกฎไวยากรณ์ของ C ++) ดังนั้นจึง--x, --yไม่สามารถถือว่าเป็นนิพจน์การมอบหมายได้

ซึ่งส่งผลให้ส่วนนิพจน์ ternary (ตามเงื่อนไข) มีลักษณะดังนี้:

someValue?++x,++y:--x

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

และประเมินตามลำดับนี้:

1. someValue?
2. (++x,++y) หรือ --x (ขึ้นอยู่กับboolผลลัพธ์ของ 1. )

จากนั้นนิพจน์นี้จะถือว่าเป็นนิพจน์ย่อยด้านซ้ายสำหรับตัวดำเนินการลูกน้ำโดยมีนิพจน์ย่อยด้านขวาอยู่ --yดังนี้:

(someValue?(++x,++y):--x), --y;

ซึ่งหมายความว่าด้านซ้ายคือไฟล์ นิพจน์ทิ้ง - ค่าซึ่งหมายความว่ามีการประเมินอย่างแน่นอน แต่จากนั้นเราประเมินด้านขวาและส่งกลับ

จะเกิดอะไรขึ้นเมื่อ someValueคือtrueอะไร?

1. (someValue?(++x,++y):--x) ดำเนินการและเพิ่มขึ้น xและyเป็น11และ11
2. นิพจน์ด้านซ้ายจะถูกยกเลิก (แม้ว่าผลข้างเคียงของการเพิ่มจะยังคงอยู่)
3. เราประเมินด้านขวามือของตัวดำเนินการลูกน้ำ: --yซึ่งจะลดyกลับไปเป็น10

ในการ "แก้ไข" พฤติกรรมคุณสามารถจัดกลุ่ม--x, --yด้วยวงเล็บเพื่อแปลงเป็นนิพจน์หลักซึ่งเป็นรายการที่ถูกต้องสำหรับนิพจน์การกำหนด *:

someValue?++x,++y:(--x, --y);

* เป็นห่วงโซ่ยาวที่ค่อนข้างตลกที่เชื่อมโยงการแสดงออกถึงการมอบหมายงานกลับไปยังนิพจน์หลัก:

การกำหนดนิพจน์ --- (สามารถประกอบด้วย) -> นิพจน์เงื่อนไข -> ตรรกะหรือนิพจน์ -> ตรรกะและนิพจน์ -> รวมหรือนิพจน์ -> เอกสิทธิ์หรือนิพจน์ - -> และนิพจน์ -> ความเท่าเทียมกัน - นิพจน์ -> นิพจน์เชิงสัมพันธ์ -> กะนิพจน์ -> นิพจน์เสริม -> นิพจน์หลายหลาก -> น. นิพจน์ -> การแสดงออก -> unary-expression -> postfix-expression -> primary-expression

ว้าวมันยุ่งยาก

คอมไพเลอร์มองว่านิพจน์ของคุณเป็น:

(someValue ? (++x, ++y) : --x), --y;

ตัวดำเนินการ ternary ต้องการ a :ซึ่งไม่สามารถยืนได้ด้วยตัวเองในบริบทนั้น แต่หลังจากนั้นไม่มีเหตุผลว่าทำไมเครื่องหมายจุลภาคควรเป็นของกรณีเท็จ

ตอนนี้มันอาจสมเหตุสมผลมากขึ้นว่าทำไมคุณถึงได้ผลลัพธ์นั้น ถ้าsomeValueเป็นจริงแล้ว++x, ++yและ--yได้รับการดำเนินการซึ่งไม่ได้อย่างมีประสิทธิภาพมีการเปลี่ยนแปลงแต่เพิ่มหนึ่งไปยังyx

ถ้าsomeValueเป็นเท็จแล้ว--xและ--yถูกดำเนินการโดยลดค่าทั้งสองอย่างทีละรายการ

เหตุใดคอมไพเลอร์ C ++ จึงสร้างโค้ดที่สำหรับ true-branch ของตัวดำเนินการ ternary เพิ่มขึ้นเท่านั้น x

คุณตีความผิดว่าเกิดอะไรขึ้น true-branch เพิ่มขึ้นทั้งxและy. อย่างไรก็ตามyจะลดลงทันทีหลังจากนั้นโดยไม่มีเงื่อนไข

สิ่งนี้เกิดขึ้นได้อย่างไร: เนื่องจากตัวดำเนินการตามเงื่อนไขมีลำดับความสำคัญสูงกว่าตัวดำเนินการลูกน้ำใน C ++คอมไพเลอร์จะแยกวิเคราะห์นิพจน์ดังนี้:

   (someValue ? ++x, ++y : --x), (--y);
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^

สังเกต "orphaned" --yหลังเครื่องหมายจุลภาค นี่คือสิ่งที่นำไปสู่การลดลงyที่เพิ่มขึ้นในตอนแรก

ฉันไปไกลถึงการใส่วงเล็บรอบ ๆ สาขาจริงเช่นนี้:

someValue ? (++x, ++y) : --x, --y;

คุณมาถูกทาง แต่คุณวงเล็บสาขาผิด: คุณสามารถแก้ไขได้โดยการวงเล็บสาขาอื่นดังนี้:

someValue ? ++x, ++y : (--x, --y);

Demo (พิมพ์ 11 11)

ปัญหาของคุณคือนิพจน์ด้านท้ายไม่ได้มีลำดับความสำคัญสูงกว่าเครื่องหมายจุลภาค ในความเป็นจริง C ++ ไม่สามารถอธิบายได้อย่างถูกต้องเพียงแค่ตามลำดับความสำคัญ - และเป็นปฏิสัมพันธ์ระหว่างตัวดำเนินการที่เกี่ยวข้องกับเครื่องหมายจุลภาคที่ซึ่งแบ่งย่อย

a ? b++, c++ : d++

ถือว่าเป็น:

a ? (b++, c++) : d++

(ลูกน้ำทำงานราวกับว่ามีลำดับความสำคัญสูงกว่า) ในทางกลับกัน,

a ? b++ : c++, d++

ถือว่าเป็น:

(a ? b++ : c++), d++

และตัวดำเนินการตามลำดับมีความสำคัญสูงกว่า

ประเด็นที่ถูกมองข้ามไปในคำตอบ (แม้ว่าจะสัมผัสกับความคิดเห็น) ก็คือตัวดำเนินการตามเงื่อนไขจะถูกใช้อย่างสม่ำเสมอ (ตั้งใจโดยการออกแบบ?) ในโค้ดจริงเป็นทางลัดในการกำหนดค่าหนึ่งในสองค่าให้กับตัวแปร

ดังนั้นบริบทที่ใหญ่กว่าจะเป็น:

whatIreallyWanted = someValue ? ++x, ++y : --x, --y;

ซึ่งไร้สาระบนใบหน้าของมันดังนั้นอาชญากรรมจึงมีมากมาย:

• ภาษาอนุญาตให้มีผลข้างเคียงที่ไร้สาระในการมอบหมายงาน
• คอมไพเลอร์ไม่ได้เตือนคุณว่าคุณกำลังทำสิ่งที่แปลกประหลาด
• หนังสือเล่มนี้ดูเหมือนจะมุ่งเน้นไปที่คำถาม 'เคล็ดลับ' เราได้ แต่หวังว่าคำตอบที่อยู่ด้านหลังคือ "สิ่งที่สำนวนนี้ใช้ขึ้นอยู่กับกรณีแปลก ๆ ในตัวอย่างที่สร้างขึ้นเพื่อให้เกิดผลข้างเคียงที่ไม่มีใครคาดคิดไม่เคยทำเช่นนี้"