CountingPtr – an intrusive reference counting pointer

CountingPtr is an implementation of intrusive reference counting.

This is similar, but not identical to boost or C++ TR1's shared_ptr. Intrusive reference counting requires the counted class to contain the counter, which is not required by std::shared_ptr.

Intrusive counting is often faster due to fewer cache faults. Furthermore, CountingPtr is a single pointer, whereas std::shared_ptr actually contains (at least) two pointers. CountingPtr also creates a lot less debug info due to reduced complexity.

CountingPtr is accompanied by ReferenceCounter, which contains the actual reference counter (a single integer). A reference counted object must derive from ReferenceCounter :

struct Something : public tlx::ReferenceCounter
{
};

Code that now wishes to use pointers referencing this object, will typedef an CountingPtr, which is used to increment and decrement the included reference counter automatically.

using SomethingPtr = tlx::CountingPtr<Something>;
{
    // create new instance of something
    SomethingPtr p1 = new something;
    {
        // create a new reference to the same instance (no deep copy!)
        SomethingPtr p2 = p1;
        // this block end will decrement the reference count, but not delete the object
    }
    // this block end will delete the object
}

The CountingPtr can generally be used like a usual pointer or std::shared_ptr (see the docs for more).