Is "delete this" statement valid?

Question

0.00/5 (No votes)

See more:

Hi All,

Recently a question has been asked to me in an interview.
The question was : Is the statement valid?

delete this;

Can someone please let me know, if this is valid or not (with reason)?

As per me, this is a kind of suicide and we should not use such statements. But as per interviewer in multithreaded application it is possible.But i am not sure how.

Please answer.

Thanks in advance

Posted 30-Jan-13 17:57pm

sourabhmehta

Updated 30-Jan-13 18:21pm

v2

Add a Solution

Comments

Sergey Alexandrovich Kryukov 31-Jan-13 0:23am

Why there is a doubt? :-)
—SA

3 solutions

Solution 2

It is perfectly normal[^].

In fact, Microsoft even suggest using it for self-destroying Window objects here[^] (search "delete this" on the page)

Posted 30-Jan-13 18:30pm

chaau

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Sergey Alexandrovich Kryukov · Accepted Answer · 2013-01-30T18:20:00

Solution 1

Can the object delete itself? Yes it can.

Moreover, do you know the technique of reference counting? Among many other things, it is used in COM. With reference counting, this is a standard technique of deleting objects and reclaiming heap memory: every user of object should call its method incrementing a reference counter, and, after use, call the method decrementing it. The last of these two methods is supposed to delete the object in the way you are asking about.

[EDIT]

This is one of the many articles explaining the reference counting technique and using delete this. Don't be afraid of it, enjoy!

Cheers,

—SA

Posted 30-Jan-13 18:20pm

Sergey Alexandrovich Kryukov

Updated 30-Jan-13 18:22pm

v2

Comments

sourabhmehta 31-Jan-13 0:25am

Thanks for quick response. It will be highly appreciable. If you can provide me some simple example or some reference link for the same.

Sergey Alexandrovich Kryukov 31-Jan-13 0:31am

I just did. The article I referenced is very simple. But...


class A {
public:
    void Delete() { delete this; }   
};

//...

A* a = new A();
a->Delete();

However, this trivial sample is correct but pretty meaningless. Again, read the article. Locate "delete this" in code, and you will really see the value of it.

And please accept the answer formally (green button) — thanks.
—SA

zapbuild · Accepted Answer · 2013-01-30T19:00:00

Yes, delete this; has defined results, as long as you assure the object was allocated dynamically, and (of course) never attempt to use the object after it's destroyed.

Some consider this a nasty hack, and tell anybody who will listen that it should be avoided. One commonly cited problem is the difficulty of ensuring that objects of the class are only ever allocated dynamically. Others consider it a perfectly reasonable idiom, and use it all the time. Personally, I'm somewhere in the middle: I rarely use it, but don't hesitate to do so when it seems to be the right tool for the job.

Edit: [mostly in response to @Alexandre C's comment]: the primary time you do this is with an object that has a life that's almost entirely its own. One example James Kanze has cited was a billing/tracking system he worked on for a phone company. Basically, when you pick up the phone, something takes note of that and creates a phone_call object. From that point onward, the phone_call object handles the details of the phone call (making a connection when you dial, adding an entry to the database to say when the call started, possibly connect more people if you do a conference call, etc.) When you hang up, the phone_call object does its final book-keeping (e.g., adds an entry to the database to say when you hung up, so they can compute how long your call was) and then destroys itself. The lifetime of the phone_call object is based on when you pick up/hang up the phone -- from the viewpoint of the rest of the system, it's basically entirely arbitrary, so you can't tie it to any lexical scope in the code, or anything on that order.

For anybody who might care about how dependable this kind of coding can be: if you make a phone call to, from, or through almost any part of Europe, there's a pretty good chance that it's being handled (at least in part) by code that does exactly this.