---

refcount.h

// Filename     : refcount.h
// Purpose      : Reference counting object and reference counting pointer template
// Author       : Erad Fridman
// Date         : 14/11/2002

#ifndef __REFCOUNT_H__
#define __REFCOUNT_H__

#include <windows.h> // For having memcpy, new, and NULL definition.

// Define the ref count object base class
class RefCountObj
{
public:
        // c'tors & d'tor
        RefCountObj() : _ref_count (0) {}
        RefCountObj(const RefCountObj &) : _ref_count (0) {}
        virtual ~RefCountObj() {}

        // RefCountObj methods
        RefCountObj& operator = (const RefCountObj &)
        {
                return *this;
        }

        void add_ref() const
        {
                ++_ref_count;
        }

        void remove_ref() const
        {
                if (--_ref_count == 0)
                        delete this;
        }

private:
        mutable unsigned int _ref_count;
};

//-----------------------------------------------------------------------------
// Define the ref count pointer class template
template <class T>
class RefCountPtr
{
public:
        // c'tors & d'tor
        RefCountPtr(T* real_ptr = 0);
        RefCountPtr(const RefCountPtr<T> &rhs);
        ~RefCountPtr();

        // Operator methods
        RefCountPtr<T> & operator = (const RefCountPtr<T> &rhs);

        T* operator -> ();
        T& operator * ();
        const T* operator -> () const;
        const T& operator * () const;

        operator bool () const;

private:
        T* _ptr;
};

template <class T>
RefCountPtr<T>::RefCountPtr(T* real_ptr) :
        _ptr (real_ptr)
{
        if (_ptr != NULL)
                _ptr->add_ref();
}

template <class T>
RefCountPtr<T>::RefCountPtr(const RefCountPtr<T> &rhs) :
        _ptr (rhs._ptr)
{
        if (_ptr != NULL)
                _ptr->add_ref();
}

template <class T>
RefCountPtr<T>::~RefCountPtr()
{
        if (_ptr != NULL)
                _ptr->remove_ref();
}

template <class T>
RefCountPtr<T>& RefCountPtr<T>::operator = (const RefCountPtr<T> &rhs)
{
        if (_ptr != rhs._ptr)
        {
                if (_ptr != NULL)
                        _ptr->remove_ref();

                _ptr = rhs._ptr;

                if (_ptr != NULL)
                        _ptr->add_ref();
        }
        return *this;
}

template <class T>
const T* RefCountPtr<T>::operator -> () const
{
        return _ptr;
}

template <class T>
T* RefCountPtr<T>::operator -> ()
{
        return _ptr;
}

template <class T>
const T& RefCountPtr<T>::operator * () const
{
        return *_ptr;
}

template <class T>
T& RefCountPtr<T>::operator * ()
{
        return *_ptr;
}

template <class T>
RefCountPtr<T>::operator bool () const
{
        return (_ptr != NULL);
}

#endif // __REFCOUNT_H__

---