Я занимаюсь исследованиями, и ничего существенного не появилось, поэтому я пришел сюда.
Я пытаюсь избежать утечек памяти, поэтому мне интересно:
Скажем, у меня есть класс MyClass с членами int a и b и int array c, которые заполняются функцией-членом:
class MyClass
{
public:
int a, b;
int c[2];
void setVariables()
{
a, b = 0;
for (int i = 0; i < 2; i++)
{
c[i] = 3;
}
}
};
int main(int argc, char* argv[])
{
MyClass* mc = new MyClass();
mc->setVariables();
delete mc;
}
Теперь, после вызова delete mc, будет a, b, и все содержимое c также будет удалено? Или я должен сделать это явно в деструкторе MyClass?
Когда выполняется delete mc, компилятор вызывает деструктор объекта (MyClass::~MyClass()) и затем освобождает связанную с ним память.
Деструктор по умолчанию (если вы не объявляете свой собственный) вызывает деструкторы всех переменных-членов, начиная от последнего до первого путем объявления (т.е. в этом случае c, затем b, затем a). Поскольку в этом примере те члены POD типов (они не имеют деструктора) не работают.
Правило очень просто: каждый объект, созданный с помощью new, должен быть уничтожен ровно один раз с помощью delete; каждый массив, созданный с помощью new[], должен быть уничтожен ровно один раз с помощью delete[]; все остальное не должно быть удалено. Таким образом, ваш код правильный; вы удаляете mc после создания его с помощью new и не удаляете элементы, которые не были созданы с помощью new.
Применение правила может быть довольно сложным, когда поток программы усложняется (особенно при использовании исключений); по этой причине гораздо лучше не удалять объекты самостоятельно, а сразу использовать результат new для инициализации умного указателя для управления объектом для вас.
Переменные внутри класса имеют класс scope и уничтожаются, когда класс. Единственное, что вам нужно беспокоиться, это указатели - они должны быть надлежащим образом рассмотрены в вашем деструкторе.
Когда вы освобождаете объект, все его переменные-члены также автоматически освобождаются. Итак, в вашем случае да, a, b и c все освобождены.
Однако, если одна из ваших переменных-членов является указателем, только сам указатель автоматически освобождается, не объект, на который он указывает, - это наиболее распространенный случай, когда вам приходится писать собственный деструктор.
Члены класса являются частью структуры памяти класса.
Итак, когда вы освобождаете эту память, члены освобождаются вместе с ней.
Примечание:
Если у вас есть указатели, они также уничтожены, НО память, на которую они указывают, не уничтожена.
Подробнее о потреблении памяти класса:
delete вернет память, содержащую ваш объект. Если ваш тип поддерживает указатели на динамически распределенную память, вам нужно будет очистить их внутри вашего деструктора.
Что касается вашего конкретного quesiton:
после того, как я вызываю delete mc, будет также удалено a, b и все содержимое c? Или я должен сделать это явно в деструкторе MyClass?
Они будут очищены для вас, поскольку они не были распределены динамически.
Ваши три переменные не были выделены с помощью new, поэтому их вообще не нужно было бы удалять.
Они будут разрушены, если ваш класс delete d (поскольку они были выделены, когда ваш класс был new d), но это не то же самое, что и удаление.
В вашем конкретном примере ответ да. Это потому, что вы выделили переменные-члены в стеке. Если вы использовали new для выделения памяти для переменных-членов, ответ был бы неактивным и потребовал бы, чтобы явное удаление переменных-членов в деструкторе класса.
class MyClass(): heapVariabl(NULL)
{
MyClass()
{}
~MyClass()
{
delete heapVariable;
}
int a, b;
int[2] c;
int *heapVariable;
void setVariables()
{
a, b = 0;
heapVariable = new int; // <- requires deletion in destructor to free memory
*heapVariable = 0;
for (int i = 0; i < 2; i++)
{
c[i] = 3;
}
}
}