Gac代码库分析(3)智能指针

 

主要在于引用计数的使用

代码示例:

template<typename T>
class Ptr
{
     template<typename X>
     friend class Ptr;
protected:
    vint*                counter;
    T*                    reference;

    void Inc()
    {
        if(counter)
        {
            (*counter)++;
        }
    }

    void Dec()
    {
        if(counter)
        {
            if(--(*counter)==0)
            {
                delete counter;
                delete reference;
                counter=0;
                reference=0;
            }
        }
    }

    vint* Counter()const
    {
        return counter;
    }

    Ptr(vint* _counter, T* _reference)
        :counter(_counter)
        ,reference(_reference)
    {
        Inc();
    }
public:

    Ptr()
    {
        counter=0;
        reference=0;
    }

    Ptr(T* pointer)
    {
        if(pointer)
        {
            counter=new vint(1);
            reference=pointer;
        }
        else
        {
            counter=0;
            reference=0;
        }
    }

    Ptr(const Ptr<T>& pointer)
    {
        counter=pointer.counter;
        reference=pointer.reference;
        Inc();
    }

    template<typename C>
    Ptr(const Ptr<C>& pointer)
    {
        T* converted=pointer.Obj();
        if(converted)
        {
            counter=pointer.Counter();
            reference=converted;
            Inc();
        }
        else
        {
            counter=0;
            reference=0;
        }
    }

    ~Ptr()
    {
        Dec();
    }

    template<typename C>
    Ptr<C> Cast()const
    {
        C* converted=dynamic_cast<C*>(reference);
        return Ptr<C>((converted?counter:0), converted);
    }

    Ptr<T>& operator=(T* pointer)
    {
        Dec();
        if(pointer)
        {
            counter=new vint(1);
            reference=pointer;
        }
        else
        {
            counter=0;
            reference=0;
        }
        return *this;
    }

    Ptr<T>& operator=(const Ptr<T>& pointer)
    {
        if(this!=&pointer)
        {
            Dec();
            counter=pointer.counter;
            reference=pointer.reference;
            Inc();
        }
        return *this;
    }

    template<typename C>
    Ptr<T>& operator=(const Ptr<C>& pointer)
    {
        T* converted=pointer.Obj();
        Dec();
        if(converted)
        {
            counter=pointer.Counter();
            reference=converted;
            Inc();
        }
        else
        {
            counter=0;
            reference=0;
        }
        return *this;
    }

    bool operator==(const T* pointer)const
    {
        return reference==pointer;
    }

    bool operator!=(const T* pointer)const
    {
        return reference!=pointer;
    }

    bool operator>(const T* pointer)const
    {
        return reference>pointer;
    }

    bool operator>=(const T* pointer)const
    {
        return reference>=pointer;
    }

    bool operator<(const T* pointer)const
    {
        return reference<pointer;
    }

    bool operator<=(const T* pointer)const
    {
        return reference<=pointer;
    }

    bool operator==(const Ptr<T>& pointer)const
    {
        return reference==pointer.reference;
    }

    bool operator!=(const Ptr<T>& pointer)const
    {
        return reference!=pointer.reference;
    }

    bool operator>(const Ptr<T>& pointer)const
    {
        return reference>pointer.reference;
    }

    bool operator>=(const Ptr<T>& pointer)const
    {
        return reference>=pointer.reference;
    }

    bool operator<(const Ptr<T>& pointer)const
    {
        return reference<pointer.reference;
    }

    bool operator<=(const Ptr<T>& pointer)const
    {
        return reference<=pointer.reference;
    }

    operator bool()const
    {
        return reference!=0;
    }

    T* Obj()const
    {
        return reference;
    }

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

1