Какая польза от деструктора как частного?

Ответ 1

В принципе, в любое время, когда вы хотите, чтобы какой-либо другой класс отвечал за жизненный цикл объектов вашего класса или у вас были причины предотвратить уничтожение объекта, вы можете сделать деструктор закрытым.

Например, если вы делаете какую-то ссылку на подсчет ссылок, вы можете иметь объект (или управляющий, который был "другом" ), ответственный за подсчет количества ссылок на себя и удаление его, когда число попадает нуль. Частный dtor не позволил бы кому-либо еще удалять его, когда еще есть ссылки на него.

В другом случае, если у вас есть объект, у которого есть менеджер (или сам), который может его уничтожить или может отказаться уничтожить его в зависимости от других условий в программе, таких как открытое соединение с базой данных или файл, являющийся написано. У вас может быть метод "request_delete" в классе или менеджере, который будет проверять это условие, и он будет либо удалять, либо отклонять, и возвращать статус, сообщающий вам, что он сделал. Это намного более гибко, чем просто "удалить".

Ответ 2

Такой объект никогда не может быть создан в стеке. Всегда в куче. И удаление должно быть сделано через друга или участника. Продукт может использовать одну иерархию объектов и пользовательский менеджер памяти - такие сценарии могут использовать частный 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;
}

Ответ 3

Если вы не хотите, чтобы пользователи обращались к деструктору, т.е. вы хотите, чтобы объект был уничтожен только с помощью других средств.

http://blogs.msdn.com/larryosterman/archive/2005/07/01/434684.aspx дает пример, где объект подсчитывается ссылкой и должен быть уничтожен только самим объектом, когда счетчик обращается в ноль.

Ответ 4

COM использует эту стратегию для удаления экземпляра. COM делает деструктор закрытым и предоставляет интерфейс для удаления экземпляра.

Вот пример того, как будет выглядеть метод Release.

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

Объекты ATL COM являются ярким примером этого шаблона.

Ответ 5

Класс может быть удален только сам. Полезно, если вы создаете какую-то попытку подсчета засчитанного объекта. Тогда только метод release может удалить объект, что поможет избежать ошибок.

Ответ 6

Добавление к уже существующим ответам; частные конструкторы и деструкторы весьма полезны при реализации factory, где создаваемые объекты должны быть выделены в куче. Объекты, в общем, будут созданы/удалены статическим членом или другом. Пример типичного использования:

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
}

Ответ 7

Я знаю, что вы спрашивали о частном деструкторе. Вот как я использую защищенные. Идея заключается в том, что вы не хотите удалять основной класс с помощью указателя на класс, который добавляет дополнительные функции к основному.
В приведенном ниже примере я не хочу, чтобы 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(){}
};

Ответ 8

dirkgently ошибочно. Вот пример объекта с частным 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

Ответ 9

Это может быть способ справиться с проблемой в Windows, где каждый модуль может использовать другую кучу, например Debug heap. Если эта проблема не обрабатывается правильно bad вещи может произойти.