Question

I’ve been thinking about the possible use of delete this in c++, and I’ve seen one use.

Because you can say delete this only when an object is on heap, I can make the destructor private and stop objects from being created on stack altogether. In the end I can just delete the object on heap by saying delete this in a random public member function that acts as a destructor. My questions:

1) Why would I want to force the object to be made on the heap instead of on the stack?

2) Is there another use of delete this apart from this? (supposing that this is a legitimate use of it 🙂 )

Answer 1

Any scheme that uses delete this is somewhat dangerous, since whoever called the function that does that is left with a dangling pointer. (Of course, that’s also the case when you delete an object normally, but in that case, it’s clear that the object has been deleted). Nevertheless, there are somewhat legitimate cases for wanting an object to manage its own lifetime.

It could be used to implement a nasty, intrusive reference-counting scheme. You would have functions to “acquire” a reference to the object, preventing it from being deleted, and then “release” it once you’ve finished, deleting it if noone else has acquired it, along the lines of:

class Nasty {
public:
    Nasty() : references(1) {}

    void acquire() {
        ++references;
    }
    void release() {
        if (--references == 0) {
            delete this;
        }
    }
private:
    ~Nasty() {}
    size_t references;
};

// Usage
Nasty * nasty = new Nasty; // 1 reference
nasty->acquire();          // get a second reference
nasty->release();          // back to one
nasty->release();          // deleted
nasty->acquire();          // BOOM!

I would prefer to use std::shared_ptr for this purpose, since it’s thread-safe, exception-safe, works for any type without needing any explicit support, and prevents access after deleting.

More usefully, it could be used in an event-driven system, where objects are created, and then manage themselves until they receive an event that tells them that they’re no longer needed:

class Worker : EventReceiver {
public:
    Worker() {
        start_receiving_events(this);
    }    
    virtual void on(WorkEvent) {
        do_work();
    }
    virtual void on(DeleteEvent) {
        stop_receiving_events(this);
        delete this;
    }
private:
    ~Worker() {}
    void do_work();
};