关于Android的轻指针

最新推荐文章于 2023-05-01 11:50:40 发布

白嫩豆腐

最新推荐文章于 2023-05-01 11:50:40 发布

阅读量262

点赞数

分类专栏： android 文章标签： android c语言

本文链接：https://blog.csdn.net/qq_28282317/article/details/60773500

版权

android 专栏收录该内容

26 篇文章 1 订阅

订阅专栏

前言

之前对于c++语言不是特别熟悉，遇到很多问题，现在准备好好研究Android的系统，这里好好研究下这个东西。其实这里仅仅是用来记录下自己的思路，这里主要和Java语言比较，

正文

首先是轻指针，轻指针仅仅是用来记录有多少指针指向当前向量，首先我们的需要一个接口，也就是一个基类，首先要定义一个mCount变量，可是如果我们在这个接口中直接对这个函数进行函数重载，或者友元的处理，就会影响当前类的一些操作，这里我们大概用了一个类似Java中的工具类，让工具类持有我们目标类的操作记录然后记录使用次数，这里我们先来看下这个基类，

template <class T>
class LightRefBase  //这是一个模板类，类似接口。
{
public:
    inline LightRefBase() : mCount(0) { }   //构造函数，mCount位0，
    inline void incStrong(__attribute__((unused)) const void* id) const {
        __sync_fetch_and_add(&mCount, 1);
    }
    inline void decStrong(__attribute__((unused)) const void* id) const {
        if (__sync_fetch_and_sub(&mCount, 1) == 1) {
            delete static_cast<const T*>(this);
        }
    }
    //! DEBUGGING ONLY: Get current strong ref count.
    inline int32_t getStrongCount() const {
        return mCount;
    }

    typedef LightRefBase<T> basetype;

protected:
    inline ~LightRefBase() { }

private:
    friend class ReferenceMover;
    inline static void moveReferences(void*, void const*, size_t,
            const ReferenceConverterBase&) { }

private:
    mutable volatile int32_t mCount;
};

同时这也是一个模板类，这样可以不用集成，即可让你的类拥有了轻指针的特性，至于模板类，当然是为了为了清理内存，因为我们的类没如果想从内存中消除需要知道是哪个类，这里其实没什么复杂的，早incStrong，和decStrong，这里不要过分里面Gcc特特性，基本可以无视，知道是增加指针计数，和减少指针计数。至于哪个工具类，sp，就不比较复杂了，这里我们不要关注里面的东西，只要知道大概远离即可，我也不想过分在c++特性纠结，毕竟比较复杂，特别是操作符的复写和友元的使用。

template <typename T>
class sp
{
public:
    inline sp() : m_ptr(0) { }

    sp(T* other);
    sp(const sp<T>& other);
    template<typename U> sp(U* other);
    template<typename U> sp(const sp<U>& other);

    ~sp();

    // Assignment

    sp& operator = (T* other);
    sp& operator = (const sp<T>& other);

    template<typename U> sp& operator = (const 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;
};

这里我们只要知道，关注下构造函数：

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> template<typename U>
sp<T>::sp(U* other) : m_ptr(other)
{
    if (other) ((T*)other)->incStrong(this);
}

template<typename T> template<typename U>
sp<T>::sp(const sp<U>& 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);
}

其实只要关心第一构造函数，也就是让这个m_ptr指向我们需要用轻指针控制的变量，至于类的注销，当然调用真正需要管理的那个类的decStrong函数来处理，至于其中的友元的等号，其他操作符的重载，这里我暂时不研究，
至于使用，这里我先介绍下

class LightClass : public LightRefBase<lightClass>
{
}
void main(){
sp(LightClass) light_class = new LightClass();
{
    sp(LightClass) inner= new LightClass();
}
}