213

将析构函数设为私有有什么用？

4

9 回答 9

194

基本上，只要您希望某个其他类负责您的类对象的生命周期，或者您有理由阻止对象的破坏，您都可以将析构函数设为私有。

例如，如果您正在做某种引用计数的事情，您可以让对象（或已“加好友”的管理器）负责计算对自身的引用数量，并在数量达到零时将其删除。当仍有对它的引用时，私有 dtor 会阻止其他任何人删除它。

再举一个例子，如果你有一个对象，它有一个管理器（或它本身），它可能会破坏它，或者可能拒绝破坏它，这取决于程序中的其他条件，例如打开的数据库连接或正在写入的文件。您可以在类或管理器中有一个“request_delete”方法来检查该条件，它将删除或拒绝，并返回一个状态告诉您它做了什么。这比仅仅调用“删除”要灵活得多。

于 2009-03-10T19:02:44.747 回答
81

这样的对象永远不能在堆栈上创建。总是在堆上。删除必须通过朋友或会员完成。产品可能使用单个对象层次结构和自定义内存管理器——此类场景可能使用私有 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;
}
于 2009-03-10T19:06:44.377 回答
45

当您不希望用户访问析构函数时，即您希望对象仅通过其他方式被销毁。

http://blogs.msdn.com/larryosterman/archive/2005/07/01/434684.aspx给出了一个示例，其中对象是引用计数的，并且只能在计数变为零时由对象本身销毁。

于 2009-03-10T19:03:14.993 回答
18

COM 使用此策略删除实例。COM 将析构函数设为私有，并提供一个用于删除实例的接口。

下面是一个 Release 方法的示例。

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

ATL COM 对象是这种模式的主要示例。

于 2009-03-11T01:14:16.740 回答
11

添加到这里已经存在的答案；在实现需要在堆上分配创建的对象的工厂时，私有构造函数和析构函数非常有用。通常，对象将由静态成员或朋友创建/删除。典型用法示例：

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
}
于 2015-05-17T18:40:57.440 回答
7

该类只能自行删除。如果您正在尝试创建一些引用计数对象，这很有用。然后只有 release 方法可以删除对象，可能会帮助您避免错误。

于 2009-03-10T19:03:49.767 回答
3

我知道你问的是私人析构函数。这是我如何使用受保护的。这个想法是您不想通过指向类的指针来删除主类，从而向主类添加额外的功能。
在下面的示例中，我不希望通过 HandlerHolder 指针删除 GuiWindow。

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(){}
};
于 2009-03-10T20:17:33.740 回答
3

直接是错误的。这是在堆栈上创建的具有私有 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);
};

此代码将产生输出：在 PrivateCD::TryMe 内部，p._i = 8

于 2011-03-10T09:53:55.337 回答
2

这可能是一种处理 Windows 中每个模块可以使用不同堆（例如调试堆）的问题的方法。如果没有正确处理该问题，则可能会发生坏事 。

于 2009-03-10T19:09:11.907 回答