แทนที่ฟังก์ชันเสมือน C ++ อย่างปลอดภัย

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

ใช้ตัวอย่างนี้:

class parent {
public:
  virtual void handle_event(int something) const {
    // boring default code
  }
};

class child : public parent {
public:
  virtual void handle_event(int something) {
    // new exciting code
  }
};

int main() {
  parent *p = new child();
  p->handle_event(1);
}

ที่นี่parent::handle_event()เรียกว่าแทนchild::handle_event()เนื่องจากวิธีการของเด็กพลาดการconstประกาศจึงประกาศวิธีการใหม่ นี่อาจเป็นการพิมพ์ผิดในชื่อฟังก์ชันหรือความแตกต่างเล็กน้อยในประเภทพารามิเตอร์ นอกจากนี้ยังสามารถเกิดขึ้นได้อย่างง่ายดายหากอินเทอร์เฟซของคลาสพื้นฐานเปลี่ยนไปและบางคลาสที่ได้รับมาไม่ได้รับการอัปเดตเพื่อให้สอดคล้องกับการเปลี่ยนแปลง

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

เนื่องจาก g ++ 4.7 เข้าใจoverrideคำหลักC ++ 11 ใหม่:

class child : public parent {
    public:
      // force handle_event to override a existing function in parent
      // error out if the function with the correct signature does not exist
      void handle_event(int something) override;
};

บางอย่างเช่นoverrideคำหลักของ C # ไม่ได้เป็นส่วนหนึ่งของ C ++

ใน gcc -Woverloaded-virtualเตือนไม่ให้ซ่อนฟังก์ชันเสมือนคลาสพื้นฐานที่มีฟังก์ชันชื่อเดียวกัน แต่มีลายเซ็นที่แตกต่างกันเพียงพอที่จะไม่ลบล้างฟังก์ชันนั้น แม้ว่าจะไม่ป้องกันคุณจากความล้มเหลวในการแทนที่ฟังก์ชันเนื่องจากการสะกดชื่อฟังก์ชันผิด

เท่าที่ฉันรู้คุณไม่สามารถทำให้เป็นนามธรรมได้หรือไม่?

class parent {
public:
  virtual void handle_event(int something) const = 0 {
    // boring default code
  }
};

ฉันคิดว่าฉันอ่านใน www.parashift.com ว่าคุณสามารถใช้วิธีนามธรรมได้จริง ซึ่งเป็นเรื่องที่สมเหตุสมผลสำหรับฉันโดยส่วนตัวสิ่งเดียวที่ทำได้คือบังคับให้คลาสย่อยนำไปใช้ไม่มีใครพูดอะไรเกี่ยวกับเรื่องนี้ที่ไม่ได้รับอนุญาตให้มีการใช้งานเอง

ใน MSVC คุณสามารถใช้overrideคีย์เวิร์ดCLR แม้ว่าคุณจะไม่ได้รวบรวม CLR ก็ตาม

ใน g ++ ไม่มีวิธีบังคับโดยตรงในทุกกรณี คนอื่น ๆ -Woverloaded-virtualได้รับคำตอบที่ดีเกี่ยวกับวิธีการที่จะจับความแตกต่างโดยใช้ลายเซ็น ในเวอร์ชันอนาคตอาจมีคนเพิ่มไวยากรณ์ที่เหมือน__attribute__ ((override))หรือเทียบเท่าโดยใช้ไวยากรณ์ C ++ 0x

ใน MSVC ++ คุณสามารถใช้คำสำคัญoverride

class child : public parent {
public:
  virtual void handle_event(int something) <b>override</b> {
    // new exciting code
  }
};

override ทำงานได้ทั้งสำหรับเนทีฟและโค้ด CLR ใน MSVC ++

ทำให้ฟังก์ชันเป็นนามธรรมเพื่อให้คลาสที่ได้รับมาไม่มีทางเลือกอื่นนอกจากแทนที่มัน

@Ray รหัสของคุณไม่ถูกต้อง

class parent {
public:
  virtual void handle_event(int something) const = 0 {
    // boring default code
  }
};

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

class parent {
public:
  virtual void handle_event(int something) const = 0;
};

void parent::handle_event( int something ) { /* do w/e you want here. */ }

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

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

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

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

ตัวอย่างเช่นนี่คือคำเตือน C4263 ใน Microsoft Visual C ++

C ++ 11 overrideคีย์เวิร์ดเมื่อใช้กับการประกาศฟังก์ชันภายในคลาสที่ได้รับมาจะบังคับให้คอมไพเลอร์ตรวจสอบว่าฟังก์ชันที่ประกาศนั้นกำลังแทนที่ฟังก์ชันคลาสพื้นฐานบางอย่าง มิฉะนั้นคอมไพเลอร์จะแสดงข้อผิดพลาด

ดังนั้นคุณสามารถใช้ตัวoverrideระบุเพื่อให้แน่ใจว่ามีความหลากหลายแบบไดนามิก (การแทนที่ฟังก์ชัน)

class derived: public base{
public:
  virtual void func_name(int var_name) override {
    // statement
  }
};