ลำดับการดำเนินการ C ++ ในวิธีการผูกมัด

ผลลัพธ์ของโปรแกรมนี้:

#include <iostream> 
class c1
{   
  public:
    c1& meth1(int* ar) {
      std::cout << "method 1" << std::endl;
      *ar = 1;
      return *this;
    }
    void meth2(int ar)
    {
      std::cout << "method 2:"<< ar << std::endl;
    }
};

int main()
{
  c1 c;
  int nu = 0;
  c.meth1(&nu).meth2(nu);
}

คือ:

method 1
method 2:0

ทำไมnuไม่เป็น1 เมื่อmeth2()เริ่ม?

เนื่องจากไม่ได้ระบุลำดับการประเมิน

คุณกำลังเห็นnuในmainการประเมิน0ก่อนที่จะmeth1ถูกเรียกด้วยซ้ำ นี่คือปัญหาเกี่ยวกับการผูกมัด ฉันไม่แนะนำให้ทำ

เพียงสร้างโปรแกรมที่ดีเรียบง่ายชัดเจนอ่านง่ายเข้าใจง่าย:

int main()
{
  c1 c;
  int nu = 0;
  c.meth1(&nu);
  c.meth2(nu);
}

ฉันคิดว่าส่วนนี้ของร่างมาตรฐานเกี่ยวกับลำดับการประเมินมีความเกี่ยวข้อง:

1.9 การดำเนินการโปรแกรม

...

15. ยกเว้นในกรณีที่ระบุไว้การประเมินค่าตัวถูกดำเนินการของแต่ละตัวดำเนินการและนิพจน์ย่อยของนิพจน์แต่ละรายการจะไม่ได้รับผลกระทบ การคำนวณค่าของตัวถูกดำเนินการของตัวดำเนินการจะเรียงลำดับก่อนการคำนวณค่าของผลลัพธ์ของตัวดำเนินการ หากผลข้างเคียงที่มีต่อวัตถุสเกลาร์ไม่สัมพันธ์กับผลข้างเคียงอื่นที่มีต่อวัตถุสเกลาร์เดียวกันหรือการคำนวณค่าโดยใช้ค่าของวัตถุสเกลาร์เดียวกันและอาจไม่เกิดขึ้นพร้อมกันพฤติกรรมจะไม่ถูกกำหนด

และนอกจากนี้ยังมี:

5.2.2 การเรียกใช้ฟังก์ชัน

...

8. [หมายเหตุ: การประเมินของนิพจน์ postfix และอาร์กิวเมนต์จะไม่สัมพันธ์กัน ผลข้างเคียงทั้งหมดของการประเมินอาร์กิวเมนต์จะถูกจัดลำดับก่อนที่จะป้อนฟังก์ชัน - หมายเหตุท้าย]

ดังนั้นสำหรับสายของคุณc.meth1(&nu).meth2(nu);ให้พิจารณาสิ่งที่เกิดขึ้นในโอเปอเรเตอร์ในแง่ของตัวดำเนินการเรียกฟังก์ชันสำหรับการเรียกครั้งสุดท้ายเพื่อmeth2ให้เราเห็นรายละเอียดอย่างชัดเจนในนิพจน์ postfix และอาร์กิวเมนต์nu:

operator()(c.meth1(&nu).meth2, nu);

การประเมินของนิพจน์ postfix และอาร์กิวเมนต์สำหรับการเรียกใช้ฟังก์ชันสุดท้าย (เช่นนิพจน์ postfix c.meth1(&nu).meth2และnu) จะไม่สัมพันธ์กันตามกฎการเรียกฟังก์ชันข้างต้น ดังนั้นผลข้างเคียงของการคำนวณนิพจน์ postfix บนวัตถุสเกลาร์arจะไม่สัมพันธ์กับการประเมินอาร์กิวเมนต์nuก่อนการmeth2เรียกใช้ฟังก์ชัน ตามกฎการทำงานของโปรแกรมด้านบนนี่คือพฤติกรรมที่ไม่ได้กำหนดไว้

กล่าวอีกนัยหนึ่งก็คือไม่มีข้อกำหนดสำหรับคอมไพลเลอร์ในการประเมินnuอาร์กิวเมนต์ของการmeth2เรียกหลังจากการmeth1โทร - มีอิสระที่จะถือว่าไม่มีผลข้างเคียงที่จะmeth1ส่งผลต่อการnuประเมินผล

รหัสแอสเซมบลีที่ผลิตโดยด้านบนประกอบด้วยลำดับต่อไปนี้ในmainฟังก์ชัน:

1. ตัวแปรnuถูกจัดสรรบนสแต็กและเริ่มต้นด้วย 0
2. การลงทะเบียน ( ebxในกรณีของฉัน) ได้รับสำเนาค่าของnu
3. ที่อยู่ของnuและcโหลดลงในรีจิสเตอร์พารามิเตอร์
4. meth1 ถูกเรียก
5. รีจิสเตอร์ค่าส่งคืนและค่าแคชก่อนหน้านี้ของnuในebxรีจิสเตอร์ถูกโหลดลงในรีจิสเตอร์พารามิเตอร์
6. meth2 ถูกเรียก

ในขั้นตอนที่ 5 เหนือคอมไพเลอร์อนุญาตให้ใช้ค่าแคชของ nuจากขั้นตอนที่ 2 meth2จะเป็นอีกครั้งที่ใช้ในการเรียกฟังก์ชั่น ในที่นี้จะไม่คำนึงถึงความเป็นไปได้ที่nuอาจมีการเปลี่ยนแปลงโดยการเรียกร้องให้meth1- 'พฤติกรรมที่ไม่ได้กำหนด' ในการดำเนินการ

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

ในมาตรฐาน C ++ ปี 1998 ส่วนที่ 5 ย่อหน้าที่ 4

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

(ฉันได้ละเว้นการอ้างอิงเชิงอรรถ # 53 ซึ่งไม่เกี่ยวข้องกับคำถามนี้)

โดยพื้นฐานแล้ว&nuจะต้องมีการประเมินก่อนที่จะโทรc1::meth1()และต้องได้รับการประเมินก่อนที่จะโทรnu c1::meth2()อย่างไรก็ตามไม่มีข้อกำหนดใดที่nuได้รับการประเมินมาก่อน&nu(เช่นได้รับอนุญาตให้nuประเมินก่อนจาก&nuนั้นc1::meth1()จึงเรียกว่า - ซึ่งอาจเป็นสิ่งที่คอมไพเลอร์ของคุณกำลังทำอยู่) ดังนั้นจึงไม่รับประกันว่านิพจน์*ar = 1ในc1::meth1()จะได้รับการประเมินก่อนnuในmain()จะได้รับการประเมินเพื่อส่งต่อc1::meth2()การประเมินเพื่อที่จะถูกส่งผ่านไป

มาตรฐาน C ++ ในภายหลัง (ซึ่งตอนนี้ฉันไม่มีบนพีซีที่ฉันใช้คืนนี้) มีประโยคเดียวกันเป็นหลัก

ฉันคิดว่าเมื่อรวบรวมก่อนที่ funtions meth1 และ meth2 จะถูกเรียกจริงๆพารามีเทอร์ถูกส่งต่อไปยังพวกเขา ฉันหมายถึงเมื่อคุณใช้ "c.meth1 (& nu) .meth2 (nu);" ค่า nu = 0 ถูกส่งต่อไปยัง meth2 ดังนั้นจึงไม่สำคัญว่า "nu" จะถูกเปลี่ยนตามหลัง

คุณสามารถลองสิ่งนี้:

#include <iostream> 
class c1
{
public:
    c1& meth1(int* ar) {
        std::cout << "method 1" << std::endl;
        *ar = 1;
        return *this;
    }
    void meth2(int* ar)
    {
        std::cout << "method 2:" << *ar << std::endl;
    }
};

int main()
{
    c1 c;
    int nu = 0;
    c.meth1(&nu).meth2(&nu);
    getchar();
}

จะได้คำตอบที่คุณต้องการ