พิจารณาหัวข้อนี้เป็นภาคต่อของหัวข้อต่อไปนี้:
งวดก่อนหน้า
พฤติกรรมที่ไม่ได้กำหนดและจุดลำดับ
มาทบทวนสำนวนที่ตลกและซับซ้อนนี้กันอีกครั้ง(วลีตัวเอียงนำมาจากหัวข้อด้านบน * smile *):
i += ++i;
เรากล่าวว่าสิ่งนี้ก่อให้เกิดพฤติกรรมที่ไม่ได้กำหนด ผมเข้าใจว่าเมื่อพูดแบบนี้เราคิดว่าโดยปริยายประเภทของการiเป็นหนึ่งในตัวชนิด
เกิดอะไรขึ้นถ้าประเภทของการiเป็นผู้ใช้กำหนดชนิดใด? บอกว่าประเภทของมันคือIndexสิ่งที่กำหนดไว้ในโพสต์นี้ (ดูด้านล่าง) มันจะยังคงเรียกใช้พฤติกรรมที่ไม่ได้กำหนดหรือไม่?
ถ้าใช่เพราะเหตุใด มันไม่เทียบเท่ากับการเขียนi.operator+=(i.operator++());หรือแม้แต่ไวยากรณ์ที่เรียบง่ายกว่า i.add(i.inc());? หรือพวกเขาเรียกร้องพฤติกรรมที่ไม่ได้กำหนดมากเกินไป?
ถ้าไม่ทำไมไม่? ท้ายที่สุดวัตถุiจะถูกแก้ไขสองครั้งระหว่างจุดลำดับที่ต่อเนื่องกัน โปรดระลึกถึงหลักการง่ายๆ: นิพจน์สามารถแก้ไขค่าของอ็อบเจ็กต์ได้เพียงครั้งเดียวระหว่าง "ลำดับจุด" ที่ต่อเนื่องกันและถ้า i += ++iเป็นนิพจน์ก็จะต้องเรียกใช้พฤติกรรมที่ไม่ได้กำหนดหากเป็นเช่นนั้นจะมีค่าเทียบเท่าi.operator+=(i.operator++());และ i.add(i.inc());ต้องเรียกใช้พฤติกรรมที่ไม่ได้กำหนดซึ่ง ดูเหมือนจะไม่จริง! (เท่าที่ฉันเข้าใจ)
หรือi += ++iไม่ใช่นิพจน์ที่ขึ้นต้นด้วย? ถ้าเป็นเช่นนั้นคำจำกัดความของนิพจน์คืออะไร?
หากเป็นนิพจน์และในเวลาเดียวกันพฤติกรรมของมันก็ถูกกำหนดไว้อย่างดีเช่นกันแสดงว่าจำนวนจุดลำดับที่เกี่ยวข้องกับนิพจน์นั้นขึ้นอยู่กับประเภทของตัวถูกดำเนินการที่เกี่ยวข้องกับนิพจน์ ฉันถูกต้อง (แม้บางส่วน) หรือไม่?
แล้วสำนวนนี้ล่ะ?
//Consider two cases:
//1. If a is an array of a built-in type
//2. If a is user-defined type which overloads the subscript operator!
a[++i] = i; //Taken from the previous topic. But here type of `i` is Index.
คุณต้องคำนึงถึงสิ่งนี้ด้วยในการตอบสนองของคุณ (ถ้าคุณรู้พฤติกรรมของมันอย่างแน่นอน) :-)
คือ
++++++i;
กำหนดไว้อย่างดีใน C ++ 03? ท้ายที่สุดนี่คือสิ่งนี้
((i.operator++()).operator++()).operator++();
class Index
{
int state;
public:
Index(int s) : state(s) {}
Index& operator++()
{
state++;
return *this;
}
Index& operator+=(const Index & index)
{
state+= index.state;
return *this;
}
operator int()
{
return state;
}
Index & add(const Index & index)
{
state += index.state;
return *this;
}
Index & inc()
{
state++;
return *this;
}
};