Comment by DanielBMarkham | Hacker News Reader

Comment by DanielBMarkham | Hacker News Reader

I'm cold on C++ (haven't coded in several years) but let me try this out:

deleting "this" releases memory held by the instance data of the object. The programmer can't be sure that any subsequent references to that data will return valid data (although the compiler will allow it). Static data and type-level methods should be fine to call -- although every time the program counter ticks you can't be sure that you're continuing to walk through uncontaminated memory.

I think that's it.

Sounds like a BS question to me because you're going way, way under the hood with exactly how the compiler runs the code. It's like those coding questions where you have to start byte-counting to get the answer. Neat trivia perhaps, but I'd much rather have somebody who delivered clean, organized, easily-maintainable code and got the answer wrong.

EDIT: Seems like I've seen delete this on several occasions (although I can't remember where), but hell if I'd use it unless I had no choice. Even then, it'd be the last statement in the method.

It also invokes the dtors for the object, and, more importantly, does all this before the caller method returns, so that when "delete this" finishes, the program still has to execute code in the method context of a dead object --- which usually works.

I'm a bit rusty on my C++ minutiae, but... there's also the problem that you don't know whether the corresponding new statement was plain new, new[], etc.

Mismatches between new[] and delete will generally just fail to call dtors or potentially call dtors twice, but the behavior's undefined. Ick.

The function's body is not part of the object itself. When you delete the object, you can keep executing the function just fine, as long as you don't access any member variables.

You keep executing the function because it's on the stack. The program counter keeps moving through the method until it hits a return statement. God help you if you try to reference one of the class' internal data objects as their heap space could have been allocated to something else running on another thread.

The function's body is not part of the object itself

Most all of the time, yes. But the function could have been dynamically allocated to an instance of the object. You don't know from the definition of the question. A dynamic function, presumably, would be picked up by the dtor.

Reply on news.ycombinator.com