基本上，任何时候你想让其他类负责你类对象的生命周期，或者你有理由阻止对象的销毁，你都可以将析构函数设为private。

例如，如果您正在做一些引用计数的事情，您可以让对象(或已被“好友”化的管理器)负责计算对自己的引用数量，并在数量为零时删除它。私有dtor可以防止其他人在仍然有引用的情况下删除它。

另一个例子是，如果你有一个对象，它有一个管理器(或它本身)，可以根据程序中的其他条件(比如正在打开的数据库连接或正在写入的文件)销毁它或拒绝销毁它。您可以在类或管理器中有一个“request_delete”方法，它将检查该条件，它将删除或拒绝，并返回一个状态，告诉您它做了什么。这比调用delete要灵活得多。

Dirkgently错了。下面是一个在堆栈上创建了私有c-tor和d-tor的对象的例子(我在这里使用静态成员函数，但它也可以用friend函数或friend类来完成)。

#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

该类只能被自身删除。在创建引用计数对象时很有用。然后只有release方法可以删除对象，这可能会帮助您避免错误。

我知道你在问私有析构函数。下面是我如何使用受保护的。其思想是，您不想通过向main类添加额外功能的类的指针来删除main类。 在下面的例子中，我不希望通过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(){}
};

这样的对象永远不能在堆栈上创建。总是在堆上。删除必须通过朋友或会员来完成。一个产品可以使用一个Object层次结构和一个自定义内存管理器——这样的场景可以使用一个私有的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;
}

这可能是在Windows中处理问题的一种方法，其中每个模块可以使用不同的堆，例如Debug堆。如果这个问题处理不当，就会发生不好的事情。