Weak pointers

When all pointers and references to an object go out of scope, the object gets automatically destroyed. An ordinary pointer can be converted to a weak pointer. When all ordinary pointers and and references go out of scope, the object gets destroyed even if there's a weak pointer to the object:

#include <x/obj.H>
#include <x/ref.H>
#include <x/weakptr.H>

class widgetObj : virtual public x::obj {

// ...


typedef x::ref<widgetObj> widget;

typedef x::ptr<widgetObj> widgetptr;

typedef x::weakptr<widgetptr> weakwidget;

// ...

widget w{widget::create()};

// ...

weakwidget weakw=w.weaken();

// ...

widgetptr origw=weakw.getptr();

if (!origw.null())
    // ...

weaken() creates a weakptr, a weak pointer. Alternatively, its constructor can be invoked directly, but note that the template's constructor takes a x::ptr and not an x::ref, but both x::ptrs and x::refs have a weaken() method. The only method implemented by a weakptr is getptr(), which returns an ordinary, strong pointer to the underlying object, if it still exists. If all other existing references to the object previously went out of scope and the object got destroyed, getptr() returns an unbound reference.

Like x::ptr, the implementation of weakptr is thread-safe, however see important comments about thread safety of references.

x::mpweakptr implements a mutext-protected wrapper for weak pointers. It is a reference-counted object that contains a mutex-protected weak pointer. The thread-safe getptr() method uses a mutex to protect the call to the underlying weak pointer's getptr(). The similarly thread-safe setptr() method updates the mutex-protected weak pointer.