Что происходит во время `delete this;` statement?

Question

Пожалуйста, обратите внимание на следующий код:

class foo 
{ 
public: 
    foo(){} 
    ~foo(){} 
    void done() { delete this;} 
private: 
    int x; 
}; 

Что происходит (и это действует?) В следующих двух вариантах:

вариант 1:

void main() 
{ 
    foo* a = new foo(); 
    a->done(); 
    delete a; 
} 

вариант 2:

void main() 
{ 
    foo a; 
    a.done(); 
} 

Будет ли второе заявление delete a; на opt ион 1 вызовет исключение или кучу коррупции?

Будет ли вариант2 вызывать исключение или разложение кучи?

Answer 1

delete this; разрешено, он удаляет объект.

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

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

Answer 2

Оба могут вызвать ошибку.

Первый указатель удаляется дважды, со вторым delete вызывает ошибку, тогда как вторая выделяется в стеке и не могут быть удалены неявно (ошибка, вызванная первым вызовом деструктора).

Answer 3

И вызовет ошибку, что вы хотите:

void main() 
{ 
    foo* a = new foo(); 
    a->done(); 
} 

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

void __foo_done(foo* this) 
{ 
    delete this; 
} 

void main() 
{ 
    foo* a = new foo(); 
    __foo_done(a); 
} 

Смотрите также Is it legal (and moral) for a member function to say delete this?

Answer 4

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

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

Answer 5

В обоих случаях ваша куча будет повреждена. Конечно, вы не можете использовать в варианте 2 «->», если левое значение (в данном случае «a») не является указателем, правильной формой в опции 2 будет a.done(); Но да, вы должны получить кучу, если попытаетесь удалить 1) то, что уже было удалено, или 2) локальная переменная.

Вызов «удалить это» является технически обоснованным и освобождает память.

EDIT мне было интересно, и на самом деле попытался это:

class foo 
{ 
public: 
    foo(){} 
    ~foo(){} 
    void done() { delete this; } 
    void test() { x = 2; } 
    int getx() { return x; } 
private: 
    int x; 
} ; 


int main(int argc, char* argv[]) 
{ 
    foo *a = new foo(); 
    a->done(); 
    a->test(); 
    int x = a->getx(); 
    printf("%i\n", x); 
    return x; 
} 

Вызов printf будет успешным, и x будет содержать значение 2.

Answer 6

Я бы очень осторожно относился к контексту, в котором вы освобождаете память. Призывая «удалить это»; попытается освободить память, связанную с структурой класса, эта операция не имеет возможности вывести контекст исходного распределения памяти, т. е. если она выделена из кучи или стека. Мой совет будет заключаться в том, чтобы переработать ваш код, чтобы операция освобождения была вызвана из внешнего контекста. Обратите внимание, что это отличается от освобождения структур, встроенных в класс, в этом случае используйте деструктор.

Answer 7

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

Это гарантирует, что только класс может удалить себя.

Если вы сделаете свой деструктор закрытым, оба образца кода не скомпилируются.