Android智能指针轻量级LightPointer初识

//java 
Object a = new Object(); 

template <class T>
class LightRefBase
{
public:
    inline LightRefBase() : mCount(0) { }
    inline void incStrong(const void* id) const {
        android_atomic_inc(&mCount);
    }
    inline void decStrong(const void* id) const {
        if (android_atomic_dec(&mCount) == 1) {
            delete static_cast<const T*>(this);
        }
    }
    //! DEBUGGING ONLY: Get current strong ref count.
    inline int32_t getStrongCount() const {
        return mCount;
    }
protected:
    inline ~LightRefBase() { }
private:
    mutable volatile int32_t mCount;
};

template<typename T>
class sp {
public:
    inline sp() : m_ptr(0) { }
    sp(T* other);
    sp(const sp<T>& other);
    sp(sp<T>&& other);
    template<typename U> sp(U* other);
    template<typename U> sp(const sp<U>& other);
    template<typename U> sp(sp<U>&& other);
    ~sp();
    // Assignment
    sp& operator = (T* other);
    sp& operator = (const sp<T>& other);
    sp& operator = (sp<T>&& other);
    template<typename U> sp& operator = (const sp<U>& other);
    template<typename U> sp& operator = (sp<U>&& other);
    template<typename U> sp& operator = (U* other);
    //! Special optimization for use by ProcessState (and nobody else).
    void force_set(T* other);
    // Reset
    void clear();
    // Accessors
    inline  T&      operator* () const  { return *m_ptr; }
    inline  T*      operator-> () const { return m_ptr;  }
    inline  T*      get() const         { return m_ptr; }
    // Operators
    COMPARE(==)
    COMPARE(!=)
    COMPARE(>)
     COMPARE(<)
     COMPARE(<=)
     COMPARE(>=)
 private:
     template<typename Y> friend class sp;
     template<typename Y> friend class wp;
     void set_pointer(T* ptr);
     T* m_ptr;
 };

//以下只截取了部分代码，详细代码内容参考 StrongPointer.h
//普通构造函数
template<typename T>
 sp<T>::sp(T* other)
         : m_ptr(other) {
     if (other)
         other->incStrong(this);
 }
//拷贝构造函数
 template<typename T>
 sp<T>::sp(const sp<T>& other)
         : m_ptr(other.m_ptr) {
     if (m_ptr)
         m_ptr->incStrong(this);
 }
//析构函数
 template<typename T>
 sp<T>::~sp() {
     if (m_ptr)
         m_ptr->decStrong(this);
 }
//重载函数（operator =）
 template<typename T>
 sp<T>& sp<T>::operator =(const sp<T>& other) {
     T* otherPtr(other.m_ptr);
     if (otherPtr)
         otherPtr->incStrong(this);
     if (m_ptr)
         m_ptr->decStrong(this);
     m_ptr = otherPtr;
     return *this;
 }

class MyLightRefClass : public LightRefBase<MyLightRefClass>
{
public:
        MyLightRefClass()
        {
        }
        virtual ~MyLightRefClass()
        {
        }
};
int main(int argc, char** argv)
{
        MyLightRefClass* lightClass = new MyLightRefClass();
        sp<MyLightRefClass> lp = lightClass;
}