Sawyer::SharedObject Class Reference

Description

Base class for reference counted objects.

The SharedObject class is used in conjunction with SharedPointer to declare that objects of this type are allocated on the heap (only), are reference counted, and invoke "delete" on themselves when the reference count decreases to zero. Any object that is intended to be referenced by a SharedPointer must inherit directly or indirectly from SharedObject.

Here's an example that demonstrates some of the best practices:

• Provide a declaration for the pointer by appending "Ptr" to the class name.

• Inherit from SharedObject just once in the entire class hierarchy, normally in the base class.

• Provide a public "Ptr" member type that's equivalent to the forward-declared pointer type.

• Make all constructors "protected" so that users are less likely to construct objects without allocating them in the heap.

• Provide static member functions named "instance", one per constructor, that allocate the object on the heap and return its first reference-counting pointer.

// Forward declarations if necessary
class MyBaseClass;
typedef Sawyer::SharedPointer<MyBaseClass> MyBaseClassPtr;
 
// Class definition
class MyBaseClass: public SharedObject {
public:
    typedef Sawyer::SharedPointer<MyBaseClass> Ptr;
 
protected:
    // Hide the constructors so users don't accidentally create objects on the stack
    MyBaseClass();
    MyBaseClass(const MyBaseClass&);
 
public:
    // Provide allocating wrappers around the constructors
    static Ptr instance() {
        return Ptr(new MyBaseClass);
    }
    static Ptr instance(const MyBaseClass &other) {
        return Ptr(new MyBaseClass(other));
    }
};

See also

SharedPointer, SharedFromThis

Definition at line 64 of file SharedObject.h.

#include <SharedObject.h>

Inheritance diagram for Sawyer::SharedObject:

Public Member Functions
	SharedObject ()
	Default constructor. More...
	SharedObject (const SharedObject &)
	Copy constructor. More...
virtual	~SharedObject ()
	Virtual destructor. More...
SharedObject &	operator= (const SharedObject &)
	Assignment. More...

Constructor & Destructor Documentation

SharedObject() [1/2]

Sawyer::SharedObject::SharedObject ( )

inline

Default constructor.

Initializes the reference count to zero.

Definition at line 70 of file SharedObject.h.

SharedObject() [2/2]

Sawyer::SharedObject::SharedObject ( const SharedObject &  )

inline

Copy constructor.

Shared objects are not typically copy-constructed, but we must support it anyway in case the user wants to copy-construct some shared object. The new object has a ref-count of zero.

Definition at line 76 of file SharedObject.h.

~SharedObject()

virtual Sawyer::SharedObject::~SharedObject ( )

inlinevirtual

Virtual destructor.

Verifies that the reference count is zero.

Definition at line 79 of file SharedObject.h.

Member Function Documentation

operator=()

SharedObject& Sawyer::SharedObject::operator= ( const SharedObject &  )

inline

Assignment.

Assigning one object to another doesn't change the reference count or mutex of either object.

Definition at line 86 of file SharedObject.h.

---

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

• SharedObject.h