ผมเข้าใจมากไปผู้ประกอบการส่วนใหญ่มีข้อยกเว้นของผู้ประกอบการเข้าถึงสมาชิกที่->, .*, ->*ฯลฯ

โดยเฉพาะอย่างยิ่งสิ่งที่ส่งผ่านไปยังฟังก์ชันตัวดำเนินการเหล่านี้และสิ่งที่ควรส่งคืน?

ฟังก์ชันตัวดำเนินการ (เช่นoperator->(...)) รู้ได้อย่างไรว่าสมาชิกใดถูกอ้างถึง? มันรู้ได้ไหม? มันจำเป็นต้องรู้หรือไม่?

สุดท้ายมีข้อพิจารณาใดบ้างที่ต้องนำมาพิจารณา? ตัวอย่างเช่นเมื่อมีการใช้งานมากเกินไปoperator[]โดยทั่วไปคุณจะต้องมีทั้งเวอร์ชัน const และไม่ใช่ const ตัวดำเนินการเข้าถึงสมาชิกต้องการเวอร์ชัน const และ non-const หรือไม่?

->

นี่เป็นเพียงเรื่องเดียวที่ยุ่งยากจริงๆ ต้องเป็นฟังก์ชันสมาชิกที่ไม่หยุดนิ่งและไม่มีข้อโต้แย้งใด ๆ ค่าส่งคืนถูกใช้เพื่อดำเนินการค้นหาสมาชิก

ถ้าค่าที่ส่งคืนเป็นอ็อบเจ็กต์ประเภทคลาสอื่นไม่ใช่ตัวชี้operator->ฟังก์ชันการค้นหาสมาชิกที่ตามมาจะถูกจัดการด้วย ซึ่งเรียกว่า "พฤติกรรมเจาะลึก" ภาษาจะรวมสายเข้าด้วยกันoperator->จนกว่าภาษาสุดท้ายจะส่งกลับตัวชี้

struct client
    { int a; };

struct proxy {
    client *target;
    client *operator->() const
        { return target; }
};

struct proxy2 {
    proxy *target;
    proxy &operator->() const
        { return * target; }
};

void f() {
    client x = { 3 };
    proxy y = { & x };
    proxy2 z = { & y };

    std::cout << x.a << y->a << z->a; // print "333"
}

->*

อันนี้เป็นเพียงเรื่องยุ่งยากที่ไม่มีอะไรพิเศษเกี่ยวกับเรื่องนี้ ที่ไม่มากเกินไปรุ่นต้องใช้วัตถุของตัวชี้ประเภทชั้นบนด้านซ้ายมือและวัตถุของตัวชี้ไปยังประเภทสมาชิกที่อยู่ด้านขวาด้วย แต่เมื่อคุณใช้งานมากเกินไปคุณสามารถรับข้อโต้แย้งที่คุณต้องการและส่งคืนสิ่งที่คุณต้องการได้ ไม่จำเป็นต้องเป็นสมาชิกแบบ nonstatic ด้วยซ้ำ

ในคำอื่น ๆ หนึ่งนี้เป็นเพียงผู้ประกอบการไบนารีปกติเช่น+, และ- /ดูเพิ่มเติม: ตัวดำเนินการฟรี -> * มีความชั่วร้ายมากเกินไปหรือไม่?

.* และ .

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

การบรรทุกเกินพิกัด->, ->*, .และ.*สามารถเติมเต็มในกรณีที่มีการแสดงออกจะไม่ได้กำหนดก็ไม่สามารถเปลี่ยนความหมายของการแสดงออกที่จะสามารถใช้งานได้โดยไม่มีการบรรทุกเกินพิกัด

Operator -> เป็นพิเศษ

"มันมีข้อ จำกัด เพิ่มเติมที่ผิดปกติ: ต้องส่งคืนวัตถุ (หรือการอ้างอิงไปยังวัตถุ) ที่มีตัวดำเนินการแยกตัวชี้ด้วยหรือจะต้องส่งคืนตัวชี้ที่สามารถใช้เพื่อเลือกสิ่งที่ลูกศรตัวดำเนินการ dereference ตัวชี้ชี้อยู่ " Bruce Eckel: การคิด CPP Vol-one: operator->

ฟังก์ชันพิเศษมีไว้เพื่อความสะดวกคุณจึงไม่ต้องโทร

a->->func();

คุณสามารถทำได้ง่ายๆ:

a->func();

นั่นทำให้ตัวดำเนินการ -> แตกต่างจากตัวดำเนินการอื่นที่โอเวอร์โหลด

คุณไม่สามารถเข้าถึงสมาชิกมากเกินไป.(เช่นส่วนที่สองของสิ่งที่->ทำ) อย่างไรก็ตามคุณสามารถโอเวอร์โหลดโอเปอเรเตอร์unary dereferencing* (เช่นส่วนแรกของสิ่งที่->ทำ)

ตัวดำเนินการ C ++ ->นั้นโดยพื้นฐานแล้วการรวมกันของสองขั้นตอนและเป็นที่ชัดเจนหากคุณคิดว่าx->yเทียบเท่ากับ(*x).y. C ++ ช่วยให้คุณปรับแต่งสิ่งที่จะทำกับ(*x)ส่วนเมื่อxเป็นอินสแตนซ์ของชั้นเรียนของคุณได้

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

ตัว->ดำเนินการไม่ทราบว่าสมาชิกใดถูกชี้ไปที่มันเพียงแค่ให้วัตถุเพื่อดำเนินการเข้าถึงสมาชิกจริง

นอกจากนี้ฉันไม่เห็นเหตุผลว่าทำไมคุณไม่สามารถระบุเวอร์ชัน const และ non-const ได้

เมื่อคุณโอเวอร์โหลดตัวดำเนินการ -> () (ไม่มีการส่งผ่านอาร์กิวเมนต์ที่นี่) สิ่งที่คอมไพลเลอร์ทำคือการเรียก -> วนซ้ำจนกว่าจะส่งกลับตัวชี้จริงไปยังประเภท จากนั้นใช้สมาชิก / วิธีการที่ถูกต้อง

สิ่งนี้มีประโยชน์เช่นในการสร้างคลาสตัวชี้อัจฉริยะที่ห่อหุ้มตัวชี้จริง ตัวดำเนินการที่โอเวอร์โหลด -> ถูกเรียกใช้ทำทุกอย่าง (เช่นการล็อกเพื่อความปลอดภัยของเธรด) ส่งคืนตัวชี้ภายในจากนั้นคอมไพเลอร์จะเรียกใช้ -> สำหรับตัวชี้ภายในนี้

สำหรับ constness - ได้รับคำตอบในความคิดเห็นและคำตอบอื่น ๆ (คุณสามารถและควรระบุทั้งสองอย่าง)