Detecting Deletion

Suppose you’re implementing a class that uses a callback:

class operation { public: struct done_callback { virtual ~done_callback(); virtual void operation_done( operation *op ) = 0; }; operation() { } bool perform( done_callback *cb ); private: bool success_ = false; }; bool operation::perform( done_callback *cb ) { // ... if ( cb != nullptr ) cb->operation_done( this ); return success_; } 

Aside on naming callbacks

Even though a callback seems like a good candidate for a functor, that is:

virtual void operator()( operation *op ) = 0; 

The problem with this is that it restricts a class from implementing multiple callbacks simultaneously. Hence, it’s better to give callbacks explicit names.

Further suppose we implement done_callback like:

struct my_callback : operation::done_callback { void operation_done( operation *op ) override; }; void my_callback::operation_done( operation *op ) { // ... delete this; delete op; } 

At the end of operation_done(), the callback deletes itself and the operation now that it’s done. The problem is that perform() does:

 return success_; // really: this->success_ 

and so may dump core because the operation was deleted by the callback. So the general question is: how can a member function tell whether a callback deleted its object?

Detecting Deletion

One way to detect deletion is by having the callback signature be either:

 virtual bool operation_done( operation *op ) = 0; virtual void operation_done( operation *op, bool *deleted ) = 0; 

The first would return true only if the callback deleted its caller; the second could set *deleted to true. While either would work, they feel kind of clunky and not general-purpose enough. Plus they require cooperation from the callback, hence aren’t surefire.

Ideally, we want to know if ~operation() was called. Perhaps have the destructor itself set a “destructor called” flag that perform() could check. But how? It obviously can’t use a data member of *this for the flag. But it can set a flag in perform()’s stack frame.

To do this, we need two things:

1. A “delete detector” (in perform()’s stack frame) that detects when an object’s destructor has been called.
2. A “delete signaler” (as a data member of operation) that runs when ~operation() has been called and signals the detector.

Here’s the declaration for delete_signaler:

class delete_detector; class delete_signaler { public: delete_signaler() { } delete_signaler( delete_signaler const& ) { // intentionally do nothing } ~delete_signaler(); delete_signaler& operator=( delete_signaler const& ) { // intentionally do nothing return *this; } void set_success( bool success ); private: delete_detector *detector_ = nullptr; }; 

Both the delete_signaler copy constructor and assignment operator intentionally do nothing. Specifically, detector_ must not be copied if and when the delete_signaler is. If it were copied, then one of two bad things would happen:

1. If the delete_signaler copy is destroyed before the callback returns, then the embedded delete_signaler may invalidate the signal sent (or not sent) by the delete_signaler original.
2. If the delete_signaler copy is destroyed after the callback returns, then detector_ will likely point to a delete_detector that’s since been destroyed.

Note that it’s insufficient simply not to declare either a copy constructor or assignment operator because the compiler will auto-generate both that will copy detector_. Hence, both must be declared explicitly to do nothing.

The body of set_success() is:

void delete_signaler::set_success( bool success ) { if ( detector_ != nullptr ) { assert( !detector_->destructor_called() ); detector_->status_ = success ? delete_detector::DTOR_CALLED_SUCCESS : delete_detector::DTOR_CALLED_FAILURE; } } 

To use a delete_signaler, one has to be declared as a data member of operation and call set_success() upon destruction:

class operation { public: // ... ~operation() { delete_signaler_.set_success( success_ ); } private: bool success_; delete_signaler delete_signaler_; }; 

Note that calling set_success() is needed only in cases like operation where there is a “success” result. If no such result is needed, but the caller still needs to detect whether the callback has deleted it, then there is no need to call set_success().

All the work of signaling the detector is done in ~delete_signaler() (more later).

Here’s the declaration for delete_detector:

class delete_detector { public: explicit delete_detector( delete_signaler &signaler ); ~delete_detector(); bool destructor_called() const { return status_ != DTOR_NOT_CALLED; } bool success() const { return status_ == DTOR_CALLED_SUCCESS; } private: enum status { DTOR_NOT_CALLED, DTOR_CALLED_VOID, DTOR_CALLED_SUCCESS, DTOR_CALLED_FAILURE }; delete_signaler &signaler_; status status_ = DTOR_NOT_CALLED; delete_detector( delete_detector const& ) = delete; delete_detector& operator=( delete_detector const& ) = delete; friend class delete_signaler; }; 

A delete_detector would be used like:

bool operation::perform( done_callback *cb ) { // ... if ( cb != nullptr ) { delete_detector detector{ delete_signaler_ }; cb->operation_done( this ); if ( detector.destructor_called() ) return detector.success(); } return success_; // this->success_ is safe to access } 

The constructor for delete_detector is fairly straightforward in that it simply sets the signaler’s detector_ to this:

delete_detector::delete_detector( delete_signaler &signaler ) : signaler_{ signaler } { assert( signaler_.detector_ == nullptr ); signaler_.detector_ = this; } 

The destructor for delete_detector not surprisingly does the reverse by setting the signaler’s detector back to nullptr — but only if the signaler’s destructor was not called:

delete_detector::~delete_detector() { if ( !destructor_called() ) { assert( signaler_.detector_ == this ); signaler_.detector_ = nullptr; } } 

One last bit of code is the destructor for delete_signaler that sets the detector’s status_ to DTOR_CALLED_VOID but only if it’s DTOR_NOT_CALLED, i.e., set_success() was not called:

delete_signaler::~delete_signaler() { if ( !detector->destructor_called() ) detector->status_ = delete_detector::DTOR_CALLED_VOID; }