Чи завжди виклик деструктора завжди є ознакою поганого дизайну?

Я думав: мовляв, якщо ви викликаєте деструктор вручну - ви робите щось не так. Але чи завжди це так? Чи є зустрічні приклади? Ситуації, коли необхідно зателефонувати йому вручну або де складно / неможливо / непрактично уникнути цього?

Виклик деструктора вручну необхідний, якщо об'єкт був побудований з використанням перевантаженої форми operator new(), крім випадків, коли використовується " std::nothrow" перевантаження:

T* t0 = new(std::nothrow) T();
delete t0; // OK: std::nothrow overload

void* buffer = malloc(sizeof(T));
T* t1 = new(buffer) T();
t1->~T(); // required: delete t1 would be wrong
free(buffer);

Однак зовнішнє управління пам'яттю на досить низькому рівні, як зазначено вище, явно викликаючи деструктори, є ознакою поганого дизайну. Можливо, це насправді не просто поганий дизайн, а відверто неправильний (так, використання явного деструктора з наступним викликом конструктора копії в операторі присвоєння є поганим дизайном і, ймовірно, буде помилковим).

У C ++ 2011 є ще одна причина використовувати явні виклики деструктора: При використанні узагальнених об'єднань необхідно явно знищити поточний об'єкт і створити новий об'єкт, використовуючи розміщення new, при зміні типу представленого об'єкта. Крім того, коли об'єднання руйнується, необхідно явно викликати деструктор поточного об'єкта, якщо він вимагає знищення.

Усі відповіді описують конкретні випадки, але є загальна відповідь:

Ви викликаєте dtor явно кожного разу, коли вам потрібно просто знищити об'єкт (у сенсі C ++), не звільняючи пам'яті, в якій знаходиться об'єкт.

Зазвичай це трапляється в усіх ситуаціях, коли розподілом / вивільненням пам'яті управляється незалежно від побудови / руйнування об'єкта. У цих випадках будівництво відбувається шляхом розміщення нового на існуючому фрагменті пам'яті, а знищення відбувається за допомогою явного дзвінка dtor.

Ось необроблений приклад:

{
  char buffer[sizeof(MyClass)];

  {
     MyClass* p = new(buffer)MyClass;
     p->dosomething();
     p->~MyClass();
  }
  {
     MyClass* p = new(buffer)MyClass;
     p->dosomething();
     p->~MyClass();
  }

}

Іншим помітним прикладом є значення за замовчуванням std::allocatorпри використанні std::vector: елементи будуються в vectorпід час push_back, але пам'ять виділяється шматками, тому вона вже існує для створення елементів. А отже, vector::eraseповинен знищити елементи, але не обов'язково це звільняє пам'ять (особливо якщо новий push_back повинен відбутися незабаром ...).

Це "поганий дизайн" у суворому ООП-розумінні (ви повинні керувати об'єктами, а не пам'яттю: факт, що об'єкти вимагають пам'яті, - це "інцидент"), це "хороший дизайн" у "програмуванні низького рівня" або у випадках, коли пам'ять не взято з "безкоштовного магазину" за замовчуванням operator new купується в.

Це поганий дизайн, якщо це відбувається випадково навколо коду, це хороший дизайн, якщо це відбувається локально для класів, спеціально розроблених для цієї мети.

Ні, ви не повинні називати це явно, оскільки це буде викликано двічі. Один раз для виклику вручну, а інший раз, коли область, в якій оголошено об'єкт, закінчується.

Напр.

{
  Class c;
  c.~Class();
}

Якщо вам дійсно потрібно виконати ті самі операції, ви повинні мати окремий метод.

Існує конкретна ситуація, коли ви можете викликати деструктор на динамічно виділеному об’єкті з розташуванням, newале це не звучить так, як вам коли-небудь знадобиться.

Ні, це залежить від ситуації, іноді це законний і хороший дизайн.

Щоб зрозуміти, чому і коли потрібно явно викликати деструктори, давайте подивимося, що відбувається з "new" і "delete".

Для динамічного створення об’єкта T* t = new T;під капотом: 1. виділено пам’ять sizeof (T). 2. Конструктор Т викликається для ініціалізації виділеної пам'яті. Оператор new робить дві речі: розподіл та ініціалізацію.

Для знищення об’єкта delete t;під капотом: 1. Викликається деструктор Т. 2. звільняється пам’ять, виділена для цього об’єкта. оператор delete також робить дві речі: знищення та вивільнення.

Один пише конструктор для ініціалізації, а деструктор - для знищення. Коли ви явно викликаєте деструктор, виконується лише руйнування, але не вивільнення .

Отже, законним використанням явного виклику деструктора може бути: "Я хочу лише знищити об'єкт, але я не (або не можу) звільнити виділення пам'яті (поки)".

Поширеним прикладом цього є попереднє виділення пам'яті для пулу певних об'єктів, які в іншому випадку повинні бути розподілені динамічно.

Створюючи новий об'єкт, ви отримуєте шматок пам'яті з попередньо виділеного пулу та виконуєте "розміщення нового". Закінчивши з об’єктом, ви можете явно зателефонувати деструктору, щоб закінчити роботу з очищення, якщо така є. Але ви не зможете звільнити пам'ять, як це зробив би оператор видалення. Натомість ви повертаєте шматок до пулу для повторного використання.

Як цитують FAQ, ви повинні чітко викликати деструктор, коли використовуєте розміщення new .

Це приблизно єдиний раз, коли ви коли-небудь прямо називали деструктор.

Хоча я погоджуюсь, що це рідко коли потрібно.

Кожного разу, коли вам потрібно відокремити розподіл від ініціалізації, вам знадобиться розміщення нового та явного виклику деструктора вручну. Сьогодні це рідко потрібно, оскільки у нас є стандартні контейнери, але якщо вам доведеться застосувати якийсь новий тип контейнера, він вам знадобиться.

Бувають випадки, коли вони необхідні:

У коді, над яким я працюю, я використовую явний виклик деструктора в розподільниках, у мене є реалізація простого розподільника, який використовує розміщення new для повернення блоків пам'яті в контейнери stl. У знищення я маю:

  void destroy (pointer p) {
    // destroy objects by calling their destructor
    p->~T();
  }

під час побудови:

  void construct (pointer p, const T& value) {
    // initialize memory with placement new
    #undef new
    ::new((PVOID)p) T(value);
  }

також розподіл здійснюється у системі allocate () та вивільнення пам'яті в deallocate (), використовуючи механізми виділення та вивільнення, специфічні для платформи. Цей розподільник використовувався для обходу doug lea malloc та використання безпосередньо, наприклад, LocalAlloc на вікнах.

Я знайшов 3 випадки, коли мені потрібно було це зробити:

• виділення / вивільнення об'єктів у пам'яті, створеної за допомогою map-map-io або спільної пам'яті
• при реалізації заданого інтерфейсу C за допомогою C ++ (так, це трапляється і сьогодні, на жаль (тому що у мене недостатньо впливу, щоб змінити його))
• при реалізації класів розподільника

Я ніколи не стикався з ситуацією, коли потрібно викликати деструктор вручну. Здається, я пам’ятаю, що навіть Строуструп стверджує, що це погана практика.

Як що до цього?
Деструктор не викликається, якщо з конструктора викидається виняток, тому мені доводиться викликати його вручну, щоб знищити дескриптори, створені в конструкторі до винятку.

class MyClass {
  HANDLE h1,h2;
  public:
  MyClass() {
    // handles have to be created first
    h1=SomeAPIToCreateA();
    h2=SomeAPIToCreateB();        
    try {
      ...
      if(error) {
        throw MyException();
      }
    }
    catch(...) {
      this->~MyClass();
      throw;
    }
  }
  ~MyClass() {
    SomeAPIToDestroyA(h1);
    SomeAPIToDestroyB(h2);
  }
};

Знайшов інший приклад, коли вам доведеться викликати деструктор (и) вручну. Припустимо, ви реалізували варіантний клас, який містить один із декількох типів даних:

struct Variant {
    union {
        std::string str;
        int num;
        bool b;
    };
    enum Type { Str, Int, Bool } type;
};

Якщо Variantекземпляр містив a std::string, і тепер ви присвоюєте об’єднанню інший тип, ви повинні знищити std::stringперший. Компілятор не буде робити це автоматично .

У мене є інша ситуація, коли я вважаю, що цілком розумно називати деструктор.

При написанні методу типу "Скинути" для відновлення об'єкта до початкового стану цілком розумно викликати Деструктор для видалення старих даних, які скидаються.

class Widget
{
private: 
    char* pDataText { NULL  }; 
    int   idNumber  { 0     };

public:
    void Setup() { pDataText = new char[100]; }
    ~Widget()    { delete pDataText;          }

    void Reset()
    {
        Widget blankWidget;
        this->~Widget();     // Manually delete the current object using the dtor
        *this = blankObject; // Copy a blank object to the this-object.
    }
};