根据OSG中的ref_ptr和Reference简化的智能指针

main.cpp测试代码

#include "TestSmartPointer"
void fun()
{
    SP<TestSmartPointer> sp1=new TestSmartPointer("A");
    SP<TestSmartPointer> sp2=sp1;
    sp1=sp2;
}
void main()
{
    fun();
    //system("pause");
}

TestSmartPointer头文件

#pragma once

#include "Referenced"
#include "SmartPointer"

#include <string>

class TestSmartPointer : public Referenced
{
    public:
        inline TestSmartPointer(std::string name):Referenced(),_name(name) {}
    protected:

        virtual ~TestSmartPointer() {}

        std::string _name;
};

Referenced计数器

#ifndef REFERENCED
#define REFERENCED 1

#include <iostream>
using namespace std;

/** Base class from providing referencing counted objects.*/
class Referenced
{
    public:
        Referenced() { _refCount=; }
        Referenced(const Referenced&) { _refCount=; }
        inline Referenced& operator = (const Referenced&) { return *this; }

        /** Increment the reference count by one, indicating that
            this object has another pointer which is referencing it.*/
        inline void ref() const;

        /** Decrement the reference count by one, indicating that
            a pointer to this object is referencing it.  If the
            reference count goes to zero, it is assumed that this object
            is no longer referenced and is automatically deleted.*/
        inline void unref() const;

        /** Decrement the reference count by one, indicating that
            a pointer to this object is referencing it.  However, do
            not delete it, even if ref count goes to 0.  Warning, unref_nodelete()
            should only be called if the user knows exactly who will
            be resonsible for, one should prefer unref() over unref_nodelete()
            as the later can lead to memory leaks.*/
        inline void unref_nodelete() const;

        /** Return the number pointers currently referencing this object. */
        inline int referenceCount() const { return _refCount; }

    protected:
        virtual ~Referenced()
        {
            if (_refCount>)
            {
                cout<<"Warning: deleting still referenced object "<<this<<" of type '"<<typeid(this).name()<<"'"<<std::endl;
                cout<<"the final reference count was "<<_refCount<<", memory corruption possible."<<std::endl;
            }
        }
        mutable int  _refCount;
};

inline void Referenced::ref() const
{
    ++_refCount;
}

inline void Referenced::unref() const
{
    bool needDelete = false;
    --_refCount;
    needDelete = _refCount<=;

    if (needDelete)
    {
        delete this;
    }
}
inline void Referenced::unref_nodelete() const
{
    --_refCount;
}

#endif

SmartPointer智能指针模板类

#ifndef SMART_POINTER
#define SMART_POINTER 1

/** Smart pointer for handling referenced counted objects.*/
template<class T>
class SP
{
    public:
        typedef T element_type;

        SP() :_ptr(0L) {}
        SP(T* t):_ptr(t)              { if (_ptr) _ptr->ref(); }
        SP(const SP& rp):_ptr(rp._ptr)  { if (_ptr) _ptr->ref(); }
        ~SP()                           { if (_ptr) _ptr->unref(); _ptr=; }

        inline SP& operator = (const SP& rp)
        {
            if (_ptr==rp._ptr) return *this;
            T* tmp_ptr = _ptr;
            _ptr = rp._ptr;
            if (_ptr) _ptr->ref();
            // unref second to prevent any deletion of any object which might
            // be referenced by the other object. i.e rp is child of the
            // original _ptr.
            if (tmp_ptr) tmp_ptr->unref();
            return *this;
        }

        inline SP& operator = (T* ptr)
        {
            if (_ptr==ptr) return *this;
            T* tmp_ptr = _ptr;
            _ptr = ptr;
            if (_ptr) _ptr->ref();
            // unref second to prevent any deletion of any object which might
            // be referenced by the other object. i.e rp is child of the
            // original _ptr.
            if (tmp_ptr) tmp_ptr->unref();
            return *this;
        }

        // comparison operators for SP.
        inline bool operator == (const SP& rp) const { return (_ptr==rp._ptr); }
        inline bool operator != (const SP& rp) const { return (_ptr!=rp._ptr); }
        inline bool operator < (const SP& rp) const { return (_ptr<rp._ptr); }
        inline bool operator > (const SP& rp) const { return (_ptr>rp._ptr); }

        // comparison operator for const T*.
        inline bool operator == (const T* ptr) const { return (_ptr==ptr); }
        inline bool operator != (const T* ptr) const { return (_ptr!=ptr); }
        inline bool operator < (const T* ptr) const { return (_ptr<ptr); }
        inline bool operator > (const T* ptr) const { return (_ptr>ptr); }

        inline T& operator*()  { return *_ptr; }

        inline const T& operator*() const { return *_ptr; }

        inline T* operator->() { return _ptr; }

        inline const T* operator->() const   { return _ptr; }

        inline bool operator!() const   { return _ptr==0L; }

        inline bool valid() const       { return _ptr!=0L; }

        inline T* get() { return _ptr; }

        inline const T* get() const { return _ptr; }

        /** take control over the object pointed to by SP, unreference but do not delete even if ref count goes to 0,
          * return the pointer to the object.
          * Note, do not use this unless you are 100% sure your code handles the deletion of the object correctly, and
          * only use when absolutely required.*/
        inline T* take() { return release();}

        inline T* release() { T* tmp=_ptr; if (_ptr) _ptr->unref_nodelete(); _ptr=; return tmp;}

    private:
        T* _ptr;
};

#endif