ฟังก์ชั่นเสมือนบริสุทธิ์พร้อมการติดตั้ง

ความเข้าใจพื้นฐานของฉันคือไม่มีการใช้งานสำหรับฟังก์ชั่นเสมือนจริง แต่ฉันก็บอกว่าอาจมีการใช้งานสำหรับฟังก์ชั่นเสมือนบริสุทธิ์

class A {
public:
    virtual void f() = 0;
};

void A::f() {
    cout<<"Test"<<endl;
}

รหัสด้านบนตกลงหรือไม่

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

virtualฟังก์ชั่นที่บริสุทธิ์จะต้องดำเนินการในประเภทที่ได้รับที่จะเป็นอินสแตนซ์โดยตรง แต่ประเภทฐานยังสามารถกำหนดการดำเนินการ คลาสที่ได้รับสามารถเรียกการใช้คลาสพื้นฐานได้อย่างชัดเจน (หากสิทธิ์การอนุญาตอนุญาต) โดยใช้ชื่อที่มีการกำหนดขอบเขตเต็ม (โดยการโทรA::f()ในตัวอย่างของคุณ - ถ้าA::f()มีpublicหรือprotected) สิ่งที่ต้องการ:

class B : public A {

    virtual void f() {
        // class B doesn't have anything special to do for f()
        //  so we'll call A's

        // note that A's declaration of f() would have to be public 
        //  or protected to avoid a compile time problem

        A::f();
    }

};

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

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

เพื่อความชัดเจนคุณเข้าใจผิดว่า = 0; หลังจากฟังก์ชั่นเสมือนหมายถึง

= 0 หมายถึงคลาสที่ได้รับจะต้องจัดให้มีการใช้งานไม่ว่าคลาสพื้นฐานจะไม่สามารถให้บริการได้

ในทางปฏิบัติเมื่อคุณทำเครื่องหมายฟังก์ชั่นเสมือนเป็น pure (= 0) มีจุดน้อยมากในการให้คำจำกัดความเพราะมันจะไม่ถูกเรียกเว้นแต่จะมีคนทำอย่างชัดเจนผ่าน Base :: Function (... ) หรือถ้า ตัวสร้างคลาสพื้นฐานเรียกใช้ฟังก์ชันเสมือนที่เป็นปัญหา

ข้อดีของมันคือมันบังคับให้ประเภทที่ได้รับยังคงแทนที่วิธีการ แต่ยังให้การเริ่มต้นหรือการใช้งานเพิ่มเติม

หากคุณมีรหัสที่ควรดำเนินการโดยคลาสที่ได้รับมา แต่คุณไม่ต้องการให้เรียกใช้งานโดยตรง - และคุณต้องการบังคับให้รหัสนั้น overriden

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

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

รหัสต่อไปนี้ถูกต้องอย่างน่าประหลาด:

class Base {
public:
  virtual ~Base() = 0;
};

Base::~Base() {}

class Derived : public Base {};

int main() { 
  // Base b; -- compile error
  Derived d; 
}

คุณต้องให้เนื้อความแก่ destructor เสมือนล้วนๆเช่น :)

อ่าน: http://cplusplus.co.il/2009/08/22/pure-virtual-destructor/

(ลิงก์เสียหายให้ใช้ที่เก็บถาวร)

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

Scott Meyers กล่าวถึงเรื่องนี้ในรายการC ++ (2nd Edition) ที่มีประสิทธิภาพ # 36 ความแตกต่างระหว่างการสืบทอดของอินเตอร์เฟสและการสืบทอดของการนำไปใช้งาน หมายเลขรายการอาจมีการเปลี่ยนแปลงในรุ่นล่าสุด

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

ฟังก์ชันของฟังก์ชันเสมือนบริสุทธิ์ในคลาสพื้นฐานนั้นมีประโยชน์ถ้าคลาสที่ได้รับของคุณต้องการเรียกใช้งานคลาสพื้นฐานของคุณ

'virtual void foo () = 0;' ไวยากรณ์ไม่ได้หมายความว่าคุณไม่สามารถใช้ foo () ในคลาสปัจจุบันได้ นอกจากนี้ยังไม่ได้หมายความว่าคุณต้องใช้มันในชั้นเรียนมา ก่อนที่คุณจะตบฉันลองสังเกตปัญหาเพชร: (โดยปริยายรหัสคุณ)

class A
{
public: 
    virtual void foo()=0;
    virtual void bar();
}

class B : public virtual A
{
public:
    void foo() { bar(); }
}

class C : public virtual A
{
public:
    void bar();
}

class D : public B, public C
{}

int main(int argc, const char* argv[])
{
    A* obj = new D();
    **obj->foo();**
    return 0;
}

ตอนนี้การเรียกใช้ obj-> foo () จะส่งผลให้ B :: foo () และ C :: bar ()

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

หวังว่าฉันจะช่วย :-)

กรณีใช้ที่สำคัญอย่างหนึ่งของการมีวิธีเสมือนจริงที่มีเนื้อความการนำไปใช้งานคือเมื่อคุณต้องการมีคลาสนามธรรม แต่คุณไม่มีวิธีการที่เหมาะสมในชั้นเรียนเพื่อทำให้บริสุทธิ์เสมือน ในกรณีนี้คุณสามารถสร้าง destructor ของ class pure virtual และนำการใช้งานที่คุณต้องการ (แม้แต่ร่างกายที่ว่างเปล่า) มาใช้ ตัวอย่างเช่น:

class Foo
{
   virtual ~Foo() = 0;
   void bar1() {}
   void bar2(int x) {}
   // other methods
};

Foo::~Foo()
{
}

เทคนิคนี้ทำให้Fooคลาสเป็นนามธรรมและเป็นไปไม่ได้ที่จะยกตัวอย่างชั้นเรียนโดยตรง ในเวลาเดียวกันคุณยังไม่ได้เพิ่มวิธีเสมือนจริงเพิ่มเติมเพื่อให้Fooนามธรรมระดับ