Поскольку оператор удаления освобождает память, зачем мне деструктор?

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

Помимо очень простых классов, обычно они есть.

Такие вещи, как закрытие файловых дескрипторов или отключение соединений с базой данных, удаление других объектов, на которые указывают данные-члены в вашем объекте, и так далее.

Классический пример — реализация стека:

class myStack {
    private:
        int *stackData;
        int topOfStack;

    public:
        void myStack () {
            topOfStack = 0;
            stackData = new int[100];
        }

        void ~myStack () {
            delete [] stackData;
        }

        // Other stuff here like pop(), push() and so on.
}

Теперь подумайте, что произойдет, если деструктор не будет вызываться каждый раз при удалении одного из ваших стеков. В этом случае в C++ нет автоматической сборки мусора, поэтому stackData память будет утекать, и вы в конечном итоге закончите.

Это требование к деструктору удалить все свои ресурсы перемещает вниз по дереву к базовым типам. Например, у вас может быть пул соединений с базой данных с массивом соединений с базой данных. Деструктор для этого будет delete каждое отдельное соединение с базой данных.

Одно соединение с базой данных может выделять множество вещей, таких как буферы данных, кэши, скомпилированные запросы SQL и так далее. Таким образом, деструктор для подключения к базе данных также должен delete выполнять все эти действия.

Другими словами, у вас есть что-то вроде:

+-------------------------------------+
| DB connection pool                  |
|                                     |
| +-------------------------+---+---+ |
| | Array of DB connections |   |   | |
| +-------------------------+---+---+ |
|                             |   |   |
+-----------------------------|---|---+
                              |   |   +---------+
                              |   +-> | DB Conn |
             +---------+      |       +---------+
             | DB Conn | <----+         /  |  \
             +---------+         buffers   |   queries
               /  |  \                  caches
        buffers   |   queries
               caches

Освобождение памяти для пула соединений с БД не повлияет на существование отдельного соединения с БД или других объектов, на которые они указывают.

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

Класс вроде:

class intWrapper {
    private:
        int value;
    public:
        intWrapper () { value = 0; }
        ~intWrapper() {}
        void setValue (int newval) { value = newval; }
        int getValue (void) { return value; }
}

не имеет реальной необходимости в деструкторе, так как освобождение памяти — это все, что вам нужно сделать.

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

Затем, когда вы закончите, delete вызывает деструктор, чтобы "снести" ваш объект, восстанавливая память, выделенную для этого объекта.

Если delete освобождает память, то зачем тут деструктор?

Смысл деструктора в том, чтобы выполнить любую логику, необходимую для очистки после вашего объекта, например:

• вызов удаления для других объектов, принадлежащих уничтожаемому объекту
• правильное освобождение других ресурсов, таких как соединения с базой данных; файловые дескрипторы и тому подобное

Предположим, у вас есть класс, который динамически выделяет память:

class something {
public:
    something() {
        p = new int;
    }

    ~something() {
        delete p;
    }

    int *p;
};

Теперь давайте динамически выделим объект something:

something *s = new something();

delete s;

Теперь, если бы delete не вызывал деструктор, то s->p никогда не освободился бы. Таким образом, delete должен вызвать деструктор и затем освободить память.

Деструктор отвечает за освобождение ресурсов, отличных от выделенной памяти объекта. Например, если объект имеет открытый дескриптор файла, деструктор может вызвать для него fclose.

Он освобождает память, занимаемую этим объектом. Однако обо всем, что было выделено объектом (и принадлежит этому объекту), необходимо позаботиться в деструкторе.

Тоже в общем... FAQ... обычно не ошибаются.

если вы объявляете класс обычным (не указателем), он автоматически вызывает конструктор и автоматически вызывает деструктор при закрытии программы. Если вы объявляете как указатель, он вызывает конструктор при инициализации с использованием нового и не вызывает деструктор автоматически, пока вы не вызовете удаление этого указателя с помощью удаления

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

Деструктор не был бы обязательной функцией. Такие языки, как C, Java, C#, не имеют деструкторов. C++ также может жить без него.

Деструктор — это специальное средство, предоставляемое C++ (такое же, как конструктор). Он вызывается, когда объект "уничтожается".

Уничтожить означает, что область действия объекта официально завершена, и любая ссылка на этот объект будет недопустимой. Например:

A* foo ()
{
  static A obj;  // 'A' is some class
  A *p = &obj;
  return p;
}

В приведенном выше коде obj представляет собой static данные, созданные типа A; foo() возвращает ссылку на этот obj, что нормально, потому что obj.~A() еще не вызывается. Предположим, что obj не является статическим. Код будет скомпилирован, однако A*, возвращенный foo(), теперь указывает на ячейку памяти, которая больше не является объектом A. Значит -> операция плохая/незаконная.

Теперь вы должны уметь отличать освобождение памяти от уничтожения объекта. Оба тесно связаны, но есть тонкая грань.

Также помните, что деструктор можно вызывать в нескольких местах:

int bar ()
{
  A obj;
  ...
  return 0; // obj.~A() called here
  ...
  return 1; // obj.~A() called here
  ...
  return 2; // obj.~A() called here
}

В приведенном выше примере obj.~A() будет вызываться только один раз, но его можно вызвать из любого из показанных мест.

Во время разрушения вы можете захотеть сделать несколько полезных вещей. Допустим, class A вычисляет какой-то результат, когда объект уничтожается; он должен напечатать результат вычисления. Это можно сделать в стиле C (поместив некоторую функцию в каждый оператор return). Но ~A() — это доступное универсальное средство.

В дополнение к ответам, сосредоточенным на объектах, выделенных в куче (с помощью new; которые освобождаются только с помощью delete)... Не забывайте, что если вы поместите объект в стеке (то есть без использования new), его деструктор будет вызван автоматически и он будет удален из стека (без вызова delete ), когда он выходит за рамки. Таким образом, у вас есть одна функция, которая гарантировано будет выполнена, когда объект выходит из области видимости, и это идеальное место для выполнения очистки всех других ресурсов, выделенных объектом (различные дескрипторы, сокеты... и объекты, созданные в куче этим объектом - если они не должны пережить этот). Это используется в идиоме RAII.