tlx
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
{
};
Provides reference counting abilities for use with CountingPtr.

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
}
High-performance smart pointer used as a wrapping reference counting pointer.

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