regina::SafePtr< T > Class Template Reference

A reference counted smart pointer that supports alternate models of ownership. More...

#include <utilities/safeptr.h>

Public Types
typedef T	element_type
	The pointee type. More...

Public Member Functions
	SafePtr ()
	Constructs a new null pointer. More...
	SafePtr (T *object)
	Constructs a new safe pointer that points to the given object. More...
template<class Y >
	SafePtr (const SafePtr< Y > &other)
	Copy constructor. More...
T *	get () const
	Returns a raw pointer to the pointee. More...
	operator bool () const
	Returns true if the pointee is non-null. More...
void	reset (T *object=nullptr)
	Resets this to point to the given object. More...
SafePtr< T > &	operator= (const SafePtr< T > &)=delete
	Disable the default assignment operator. More...

Detailed Description

template<class T>
class regina::SafePtr< T >

A reference counted smart pointer that supports alternate models of ownership.

Specifically, there are two models of ownership for the pointee (of type T):

1. The pointee may be owned by the smart pointer(s), in which case it will be destroyed when the last smart pointer to it is destroyed.
2. Alternatively, the pointee may be owned by some other C++ object not using this smart pointer class. In this case, even when the last smart pointer to it is destroyed, the pointee itself will not be destroyed.

The pointee can indicate at runtime which model of ownership is in effect, through the return value of the function T::hasOwner().

The requirements for the pointee type T are as follows:

• T must subclass from SafePointeeBase<T>.
• T must implement a member function bool hasOwner(), which returns true if and only if some other C++ object (which is not a SafePtr) owns the pointee.

Destruction works as follows:

• An object will stay alive as long as one SafePtr is pointing to it.
• It is never safe to call delete on a raw pointer to an object of type T, unless you know (e.g., from human analysis of the program logic) that no SafePtr points to that same object.
• Subclasses of SafePointeeBase may provide their own destruction routines for users to call instead of delete, which are always safe to call regardless of whether there are SafePtr or not. For example, users should always delete packets by calling Packet::safeDelete(), not delete.
• Destroying a SafePtr will destroy the underlying object of type T if and only if: (i) no other SafePtr is pointing to that object, and (ii) the pointee's hasOwner() returns false.

Author

Matthias Goerner

---

The documentation for this class was generated from the following files:

• utilities/safepointeebase.h
• utilities/safeptr.h