การใช้ destructor เป็นแบบส่วนตัวคืออะไร

การใช้ destructor เป็นแบบส่วนตัวคืออะไร

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

ตัวอย่างเช่นหากคุณกำลังทำสิ่งอ้างอิงนับประเภทคุณสามารถมีวัตถุ (หรือผู้จัดการที่เป็น "เพื่อน" ed) รับผิดชอบในการนับจำนวนการอ้างอิงถึงตัวเองและลบออกเมื่อจำนวนศูนย์ถึงศูนย์ dtor ส่วนตัวจะป้องกันไม่ให้ใครอื่นลบมันเมื่อยังมีการอ้างอิงถึงมัน

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

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

#include <iostream>
class a {
    ~a() {}
    friend void delete_a(a* p);
};


void delete_a(a* p)  {
    delete p;
}

int main()
{
    a *p = new a;
    delete_a(p);

    return 0;
}

เมื่อคุณไม่ต้องการให้ผู้ใช้เข้าถึง destructor นั่นคือคุณต้องการให้วัตถุถูกทำลายโดยวิธีการอื่นเท่านั้น

http://blogs.msdn.com/larryosterman/archive/2005/07/01/434684.aspxให้ตัวอย่างซึ่งการอ้างอิงวัตถุนับและควรทำลายวัตถุโดยตัวเองเมื่อการนับเป็นศูนย์

COM ใช้กลยุทธ์นี้เพื่อลบอินสแตนซ์ COM ทำให้ destructor เป็นส่วนตัวและจัดให้มีอินเทอร์เฟซสำหรับการลบอินสแตนซ์

นี่คือตัวอย่างของรูปแบบวิธีการเผยแพร่

int MyRefCountedObject::Release() 
{
 _refCount--;
 if ( 0 == _refCount ) 
 {
    delete this;
    return 0;
 }
 return _refCount;
}

ATL COM วัตถุเป็นตัวอย่างสำคัญของรูปแบบนี้

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

class myclass
{
public:
    static myclass* create(/* args */)  // Factory
    {
        return new myclass(/* args */);
    }

    static void destroy(myclass* ptr)
    {
        delete ptr;
    }
private:
    myclass(/* args */) { ... }         // Private CTOR and DTOR
    ~myclass() { ... }                  // 
}

int main ()
{
    myclass m;                          // error: ctor and dtor are private
    myclass* mp = new myclass (..);     // error: private ctor
    myclass* mp = myclass::create(..);  // OK
    delete mp;                          // error: private dtor
    myclass::destroy(mp);               // OK
}

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

ฉันรู้ว่าคุณกำลังถามเกี่ยวกับ destructor ส่วนตัว นี่คือวิธีที่ฉันใช้ตัวป้องกัน แนวคิดคือคุณไม่ต้องการลบคลาสหลักผ่านตัวชี้ไปยังคลาสที่เพิ่มฟังก์ชันพิเศษให้กับคลาสหลัก
ในตัวอย่างด้านล่างฉันไม่ต้องการให้ลบ GuiWindow ผ่านตัวชี้ HandlerHolder

class Handler
{
public:
    virtual void onClose() = 0;
protected:
    virtual ~Handler();
};

class HandlerHolder
{
public:
    void setHandler( Handler* );
    Handler* getHandler() const;
protected:
    ~HandlerHolder(){}
private:
    Handler* handler_;
};

class GuiWindow : public HandlerHolder
{
public:
    void finish()
    {
        getHandler()->onClose();
    }

    virtual ~GuiWindow(){}
};

ผิดอย่างผิดปกติ นี่คือตัวอย่างของวัตถุที่มี c-tor ส่วนตัวและ d-tor ที่สร้างขึ้นบนสแต็ก (ฉันใช้ฟังก์ชันสมาชิกแบบคงที่ที่นี่ แต่สามารถทำได้ด้วยฟังก์ชันเพื่อนหรือคลาสเพื่อนเช่นกัน)

#include <iostream>

class PrivateCD
{
private:
    PrivateCD(int i) : _i(i) {};
    ~PrivateCD(){};
    int _i;
public:
    static void TryMe(int i)
    {
        PrivateCD p(i);
        cout << "inside PrivateCD::TryMe, p._i = " << p._i << endl;
    };
};

int main()
{
    PrivateCD::TryMe(8);
};

รหัสนี้จะสร้างผลลัพธ์: Inside PrivateCD :: TryMe, p._i = 8

อาจเป็นวิธีจัดการกับปัญหาใน Windows ที่แต่ละโมดูลสามารถใช้ heap ที่แตกต่างกันเช่นDebug heap หากปัญหานั้นไม่ได้รับการจัดการอย่างถูกต้องสิ่งเลวร้าย สามารถเกิดขึ้นได้