Android智能指针学习笔记

1.强指针支持指向两种超类型的引用对象，一种是轻量级引用对象，继承自LightRefBase，另一种姑且称之为重量级引用对象，继承自RefBase。

2.弱指针只支持指向重量级引用对象，继承自RefBase。

3.引用对象负责维护自己的引用计数，但引用计数器增加或减少的消息由sp或是wp智能指针对象发送。

4.LightRefBase和RefBase维护引用计数的方式不相同，前者直接使用int型变量维护，或者使用一个嵌套类weakref_type维护。

5.引用对象可以设置自己的生存模式，生存模式有三种，strong，weak，forever。不同的生存模式影响他们在内存中的状态。

6.弱指针无法直接访问对象，需要promote成强指针，但并不一定保证成功。

class RefBase
{
public:
            void            incStrong(const void* id) const;
            void            decStrong(const void* id) const;
    
            void            forceIncStrong(const void* id) const;

            //! DEBUGGING ONLY: Get current strong ref count.
            int32_t         getStrongCount() const;

    class weakref_type
    {
    public:
        RefBase*            refBase() const;
        
        void                incWeak(const void* id);
        void                decWeak(const void* id);
        
        // acquires a strong reference if there is already one.
        bool                attemptIncStrong(const void* id);
        
        // acquires a weak reference if there is already one.
        // This is not always safe. see ProcessState.cpp and BpBinder.cpp
        // for proper use.
        bool                attemptIncWeak(const void* id);

        //! DEBUGGING ONLY: Get current weak ref count.
        int32_t             getWeakCount() const;

        //! DEBUGGING ONLY: Print references held on object.
        void                printRefs() const;

        //! DEBUGGING ONLY: Enable tracking for this object.
        // enable -- enable/disable tracking
        // retain -- when tracking is enable, if true, then we save a stack trace
        //           for each reference and dereference; when retain == false, we
        //           match up references and dereferences and keep only the 
        //           outstanding ones.
        
        void                trackMe(bool enable, bool retain);
    };
    
            weakref_type*   createWeak(const void* id) const;
            
            weakref_type*   getWeakRefs() const;

            //! DEBUGGING ONLY: Print references held on object.
    inline  void            printRefs() const { getWeakRefs()->printRefs(); }

            //! DEBUGGING ONLY: Enable tracking of object.
    inline  void            trackMe(bool enable, bool retain)
    { 
        getWeakRefs()->trackMe(enable, retain); 
    }

    typedef RefBase basetype;

protected:
                            RefBase();
    virtual                 ~RefBase();

    //! Flags for extendObjectLifetime()
    enum {
        OBJECT_LIFETIME_STRONG  = 0x0000,
        OBJECT_LIFETIME_WEAK    = 0x0001,
        OBJECT_LIFETIME_MASK    = 0x0001
    };
    
            void            extendObjectLifetime(int32_t mode);
            
    //! Flags for onIncStrongAttempted()
    enum {
        FIRST_INC_STRONG = 0x0001
    };
    
    virtual void            onFirstRef();
    virtual void            onLastStrongRef(const void* id);
    virtual bool            onIncStrongAttempted(uint32_t flags, const void* id);
    virtual void            onLastWeakRef(const void* id);

private:
    friend class ReferenceMover;
    static void moveReferences(void* d, void const* s, size_t n,
            const ReferenceConverterBase& caster);

private:
    friend class weakref_type;
 7.C++标准规定嵌套类没有权限访问外部类私有成员，所以我们需要将嵌套类声明为friend。但是很多编译器都违反标准规定，嵌套类可以访问外部类的私有成员，实现行为不确定。
    class weakref_impl;
    
            RefBase(const RefBase& o);
            RefBase&  operator=(const RefBase& o);

        weakref_impl* const mRefs;
};

8.更多内容请参考老罗博客