Android——智能指针

最新推荐文章于 2024-07-04 16:35:20 发布
最新推荐文章于 2024-07-04 16:35:20 发布
阅读量3k 收藏 3
点赞数 1
分类专栏： 【Android — 机制】 文章标签： android 智能指针 内存泄漏 RefBase引用计数 sp_wp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jscese/article/details/30070775
版权

   众多周知，指针在C/C++是一个很重要的手段，但是也是最让人麻烦的东西，容易出现空指针，或者内存泄漏，无非是new了一个对象，没有对应的delete，长时间运行导致系统崩溃！

在android系统中其实也有这个指针这个概念，只不过被用另外的一种安全机制弥补以上的麻烦。


一.概念：

android的中间层frameworks中的JNI以及往下的libraries 运行库层大部分使用的是C++来写的，目的是为了提高效率，在这些地方就需要用到指针了！

android 提供了一套机制为智能指针:

智能指针本身为一个对象，是一个模板类，可以当作一个控制类。有 sp  wp  这两个类，后面介绍。

通过对指针指向的对象进行引用计数控制，来决定delete对象，不会遗漏new出来无用的对象，只要还有指针还指向目标对象，那么就不会delete该对象 也杜绝了指针指空的现象！


智能指针用法分三种类型：

1.轻量级指针

2.强指针

3.弱指针



二.轻量级指针:

目标对象的引用计数类为：/frameworks/native/include/utils/RefBase.h 中的  LightRefBase 类，也就是说智能指针指向的对象是继承于LightRefBase这个父类或者间接父类的！

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);
        }
    }

...

}

可以看到由mCount 一个变量来计数，初始为0，有incStrong decStrong 这个两个方法 来操作 mCount 。

这个计数类比较简单，接口方法只有 sp 类才有，所以我的理解 轻量级的指针只是因为计数类比较简单，智能指针控制类和强指针的类型一样都是 sp！

看看 sp 类：

android4.2 在/frameworks/native/include/utils/StrongPointer.h中定义.

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();

...

}

sp 就是一个智能指针对象，当指向某一个对象的时候，就会创建，当不需要指向某一个对象的时候，也就是这个指针销毁的时候，分别会调用构造函数和析构函数。

看看sp 指针类的构造和析构：

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);
}

可以看到分别调用的是引用的对象的 incStrong  和 decStrong  分别对应 LightRefBase的计数加1 和 减1 ，可以看到当mCount=1 的时候 再 decStrong 就会 delete对象！



三.强指针：

和轻量级指针不同，强指针用RefBase类计数，同样需要用强指针的也得继承了这个类，也在/frameworks/native/include/utils/RefBase.h中定义：

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;
    class weakref_impl;
    
                            RefBase(const RefBase& o);
            RefBase&        operator=(const RefBase& o);

        weakref_impl* const mRefs;
};

这个类有点复杂，知道几个重要的函数就可以了，这个计数类也提供了 incStrong 和 decStrong这两个控制计数的函数

所谓强指针，肯定是比轻量级的复杂，包含了轻量级的简单计数以外，还区分了计数的类型，分强引用的计数和弱引用的计数，这个两个计数器的值都能起到决定是否delete的作用，

这样做的原因是因为，如果在两个对象之间。互相通过指针引用了对象，当两个对象都不需要用到的时候，就无法单独回收一个对象，定义一个规则 在某个对象的强引用计数为0的时候 不管弱引用多少 都delete 就能解决这一问题

在嵌套引用中就需要设置delete 到底依赖规则，依赖强计数 还是 弱计数 ！

这两种计数的变量在RefBase类里面由weakref_impl 类提供 ，也就是 mRefs，看看weakref_impl类：

/frameworks/base/libs/utils/RefBase.cpp中：

class RefBase::weakref_impl : public RefBase::weakref_type
{
public:
    volatile int32_t    mStrong;
    volatile int32_t    mWeak;
    RefBase* const      mBase;
    volatile int32_t    mFlags;
#if !DEBUG_REFS

    weakref_impl(RefBase* base)
        : mStrong(INITIAL_STRONG_VALUE)
        , mWeak(0)
        , mBase(base)
        , mFlags(0)
    {
    }
...

}



可以看到前面两个就是两个计数变量，mBase代表这个类对应的RefBase类，

而mFlags就是上面说的依赖规则了，怎么来判定处理前面的两个计数变量！构造函数可以看到 默认为0。对应一个枚举，在RefBase类中的weakref_type类：

    enum {
        OBJECT_LIFETIME_STRONG  = 0x0000,
        OBJECT_LIFETIME_WEAK    = 0x0001,
        OBJECT_LIFETIME_MASK    = 0x0001
    };



同轻量级一样，在智能指针指向对象的时候，调用指针的构造，这里强指针就是通过 sp 实际调用到对象的incStrong，

也就是 RefBase::incStrong：

void RefBase::incStrong(const void* id) const
{
    weakref_impl* const refs = mRefs;
    refs->incWeak(id);
    
    refs->addStrongRef(id);
    const int32_t c = android_atomic_inc(&refs->mStrong);
    ALOG_ASSERT(c > 0, "incStrong() called on %p after last strong ref", refs);

...

}

android4.2 在incWeak 里面增加了弱引用计数，然后addStrongRef再增加了强计数。强弱计数都+1.

实际处理函数为android_atomic_inc(&refs->mStrong)


同样在销毁的时候调用RefBase::decStrong:

void RefBase::decStrong(const void* id) const
{
    weakref_impl* const refs = mRefs;
    refs->removeStrongRef(id);
    const int32_t c = android_atomic_dec(&refs->mStrong);
#if PRINT_REFS
    ALOGD("decStrong of %p from %p: cnt=%d\n", this, id, c);
#endif
    ALOG_ASSERT(c >= 1, "decStrong() called on %p too many times", refs);
    if (c == 1) {
        refs->mBase->onLastStrongRef(id);
        if ((refs->mFlags&OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_STRONG) {
            delete this;
        }
    }
    refs->decWeak(id);
}
实际处理函数为 android_atomic_dec(&refs->mStrong)

可以看到在操作完强计数的时候，会做判断，如果是到0了，然后依赖的处理规则又是强引用，那么就delete这个对象！


不然就往下处理弱引用计数decWeak：

void RefBase::weakref_type::decWeak(const void* id)
{
    weakref_impl* const impl = static_cast<weakref_impl*>(this);
    impl->removeWeakRef(id);
    const int32_t c = android_atomic_dec(&impl->mWeak);
    ALOG_ASSERT(c >= 1, "decWeak called on %p too many times", this);
    if (c != 1) return;

    if ((impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_STRONG) {
        // This is the regular lifetime case. The object is destroyed
        // when the last strong reference goes away. Since weakref_impl
        // outlive the object, it is not destroyed in the dtor, and
        // we'll have to do it here.
        if (impl->mStrong == INITIAL_STRONG_VALUE) {
            // Special case: we never had a strong reference, so we need to
            // destroy the object now.
            delete impl->mBase;
        } else {
            // ALOGV("Freeing refs %p of old RefBase %p\n", this, impl->mBase);
            delete impl;
        }
    } else {
        // less common case: lifetime is OBJECT_LIFETIME_{WEAK|FOREVER}
        impl->mBase->onLastWeakRef(id);
        if ((impl->mFlags&OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_WEAK) {
            // this is the OBJECT_LIFETIME_WEAK case. The last weak-reference
            // is gone, we can destroy the object.
            delete impl->mBase;
        }
    }
}

一样的，做了判断，如果发现到0了然后规则是弱引用处理，就delete



四.弱指针：

弱指针所用的计数类和强指针的一样为RefBase这个类。控制的智能指针不一样而已 为 wp 类，定义在/frameworks/native/include/utils/RefBase.h

template <typename T>
class wp
{
public:
    typedef typename RefBase::weakref_type weakref_type;
    
    inline wp() : m_ptr(0) { }

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

    ~wp();

...

    // promotion to sp
    
    sp<T> promote() const;

...

}

调用同上面的一样，直接看构造和析构函数：

template<typename T>
wp<T>::wp(T* other)
    : m_ptr(other)
{
    if (other) m_refs = other->createWeak(this);
}

template<typename T>
wp<T>::~wp()
{
    if (m_ptr) m_refs->decWeak(this);
}

分别调用到RefBase类里面的实现函数：

构造的：

RefBase::weakref_type* RefBase::createWeak(const void* id) const
{
    mRefs->incWeak(id);
    return mRefs;
}

这里的mRefs 是weakref_impl类的对象，上面有说过的，调到： 


void RefBase::weakref_type::incWeak(const void* id)
{
    weakref_impl* const impl = static_cast<weakref_impl*>(this);
    impl->addWeakRef(id);
    const int32_t c = android_atomic_inc(&impl->mWeak);
    ALOG_ASSERT(c >= 0, "incWeak called on %p after last weak ref", this);
}

这里只是 弱引用计数 +1


析构的：

直接调用到:

RefBase::weakref_type::decWeak

同上！


另外弱指针有一个特性，就是无法直接操作目标对象，弱指针类没有重载*和->操作符号！


弱指针可以通过promote()方法提升为强指针！


实现函数：RefBase::weakref_type::attemptIncStrong

bool RefBase::weakref_type::attemptIncStrong(const void* id)
{
    incWeak(id);
    
    weakref_impl* const impl = static_cast<weakref_impl*>(this);
    
    int32_t curCount = impl->mStrong;
    ALOG_ASSERT(curCount >= 0, "attemptIncStrong called on %p after underflow",
               this);
    while (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {
        if (android_atomic_cmpxchg(curCount, curCount+1, &impl->mStrong) == 0) {
            break;
        }
        curCount = impl->mStrong;
    }
    
    if (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) {
        bool allow;
        if (curCount == INITIAL_STRONG_VALUE) {
            // Attempting to acquire first strong reference...  this is allowed
            // if the object does NOT have a longer lifetime (meaning the
            // implementation doesn't need to see this), or if the implementation
            // allows it to happen.
            allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK
                  || impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);
        } else {
            // Attempting to revive the object...  this is allowed
            // if the object DOES have a longer lifetime (so we can safely
            // call the object with only a weak ref) and the implementation
            // allows it to happen.
            allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_WEAK
                  && impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);
        }
        if (!allow) {
            decWeak(id);
            return false;
        }
        curCount = android_atomic_inc(&impl->mStrong);

        // If the strong reference count has already been incremented by
        // someone else, the implementor of onIncStrongAttempted() is holding
        // an unneeded reference.  So call onLastStrongRef() here to remove it.
        // (No, this is not pretty.)  Note that we MUST NOT do this if we
        // are in fact acquiring the first reference.
        if (curCount > 0 && curCount < INITIAL_STRONG_VALUE) {
            impl->mBase->onLastStrongRef(id);
        }
    }
    
    impl->addStrongRef(id);

#if PRINT_REFS
    ALOGD("attemptIncStrong of %p from %p: cnt=%d\n", this, id, curCount);
#endif

    if (curCount == INITIAL_STRONG_VALUE) {
        android_atomic_add(-INITIAL_STRONG_VALUE, &impl->mStrong);
        impl->mBase->onFirstRef();
    }
    
    return true;
}


但是提升为强指针是要看目前弱指针对象是否已经delete，还要看对象有没有设置一些属性导致不被允许提升为强指针

一种情况是 对象整在被其它强指针引用 强引用肯定大于0  可以提升为强指针 然后增加对象强引用计数


第二种情况：

如果没有被其它的强指针引用而且强引用计数等于INITIAL_STRONG_VALUE就要满足：

allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK
                  || impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);

否则就要满足： 

allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_WEAK
&& impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);



如果allow为false 就代表不能提升为强指针，那么就要减小目标对象的弱引用计数，因为attempIncStrong 开头就直接增加了弱引用计数！

如果满足条件，往下就增加强引用计数.



五.强弱指针使用范例：

借用一个写的比较形象的范例：


#include <stdio.h>
#include <utils/RefBase.h>

#define INITIAL_STRONG_VALUE (1<<28)

using namespace android;

class WeightClass : public RefBase
{
public:
        void printRefCount()
        {
                int32_t strong = getStrongCount();
                weakref_type* ref = getWeakRefs();

                printf("-----------------------\n");
                printf("Strong Ref Count: %d.\n", (strong  == INITIAL_STRONG_VALUE ? 0 : strong));
                printf("Weak Ref Count: %d.\n", ref->getWeakCount());
                printf("-----------------------\n");
        }
};

class StrongClass : public WeightClass
{
public:
        StrongClass()
        {
                printf("Construct StrongClass Object.\n");
        }

        virtual ~StrongClass()
        {
                printf("Destory StrongClass Object.\n");
        }
};


class WeakClass : public WeightClass
{
public:
        WeakClass()
        {
                extendObjectLifetime(OBJECT_LIFETIME_WEAK);

                printf("Construct WeakClass Object.\n");
        }

        virtual ~WeakClass()
        {
                printf("Destory WeakClass Object.\n");
        }
};




void TestStrongClass(StrongClass* pStrongClass)
{
        wp<StrongClass> wpOut = pStrongClass;
        pStrongClass->printRefCount();

        {
                sp<StrongClass> spInner = pStrongClass;
                pStrongClass->printRefCount();
        }

        sp<StrongClass> spOut = wpOut.promote();
        printf("spOut: %p.\n", spOut.get());
}

void TestWeakClass(WeakClass* pWeakClass)
{
        wp<WeakClass> wpOut = pWeakClass;
        pWeakClass->printRefCount();

        {
                sp<WeakClass> spInner = pWeakClass;
                pWeakClass->printRefCount();
        }

        pWeakClass->printRefCount();
        sp<WeakClass> spOut = wpOut.promote();
        printf("spOut: %p.\n", spOut.get());
}



int main(int argc, char** argv)
{
        printf("Test Strong Class: \n");
        StrongClass* pStrongClass = new StrongClass();
        TestStrongClass(pStrongClass);

        printf("\nTest Weak Class: \n");
        WeakClass* pWeakClass = new WeakClass();
        TestWeakClass(pWeakClass);


        return 0;
}


跑起来的结果：

Test Strong Class: 
Construct StrongClass Object.
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 1.
-----------------------
-----------------------
Strong Ref Count: 1.
Weak Ref Count: 2.
-----------------------
Destory StrongClass Object.
spOut: 0x0.

可以看到首先是用的一个弱指针去指向对象，所以对象的强引用计数为0 弱引用计数为1

然后中途用一个强指针指向对象，对象的两个引用计数全部加1

退出大括号，销毁强指针，因为默认的强指针是依赖强引用的，上面有说 mFlag 设的是0 ，所在这个时候发现对象的强引用从1变为0了，就delete对象

最后再来用之前的弱指针提升到强指针，因为对象不存在了，所以失败 返回 0x0.


Test Weak Class: 
Construct WeakClass Object.
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 1.
-----------------------
-----------------------
Strong Ref Count: 1.
Weak Ref Count: 2.
-----------------------
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 1.
-----------------------
spOut: 0xa528.
Destory WeakClass Object.

这个弱指针的测试前面和上面一样，不同的就是在对象创建的时候 设置了引用计数的依赖规则为 依赖弱引用计数！

所以在中途退出大括号时，不会delete

这个时候提升强指针也满足上面说到过的条件，所以返回0xa528

在程序退出时，弱指针也销毁，这个时候，弱引用计数为0 ，delete 对象！


到这里学习分析完毕！

撰写不易，转载请注明出处：http://blog.csdn.net/jscese/article/details/30070775









南丶烟
关注
专栏目录
Android中的智能指针
joye123的博客
03-19 631
Android中的智能指针 C/C++项目中常见的指针问题有三类： 指针没有初始化，或者新申请的内存块没有按照情况进行初始化。 new/delete操作符没有匹配使用，忘记delete造成内存泄漏。 野指针。一个对象不知道有多少个指针引用它，当对象被在错误的时机销毁时，引用它的指针就变成了野指针。 为了解决上面三个问题，智能指针被发明了出来。 智能指针，简单来说就是通过引用计数法记录一个对象被...
Android 智能指针学习笔记（二，完结） —— 强指针，弱指针
小石不识月，呼作白玉盘。
09-18 1022
强弱指针应用实例上一篇学习了轻量级指针，而这一篇则要把强指针与弱指针的原理都探个究竟。 关于智能指针的学习笔记，在这一篇也就完结了，总的来说内容是挺少的，不过其中有些逻辑还是需要细细琢磨才能理解的。
android 智能指针
Android framework
05-07 148
Android 智能指针
入琞的博客
12-17 2154
cpp 开发中，指针是比较难处理，如果是一个大系统，管理不善很可能出现内存泄漏（new之后没释放）/野指针（已释放，但还有其他再使用）等问题发生。 java 使用引用的方式，不开放指针的操作，所以java side基本没这个问题。 有效解决上述问题的方式，andorid 设计一套方法（智能指针）自动管理指针的释放和引用情况，同时内部借助引用计数的方式解决在还有人使用时不释放指针。 ...
Android应用程序框架——智能指针 系列文章源代码
06-17
在Android应用程序开发中，智能指针是用于管理内存的重要工具，尤其是在C++ Native层的编程中。本系列文章源代码主要探讨了如何在Android环境中利用智能指针来优化内存管理和防止内存泄漏。智能指针是一种自动管理...
Binder学习笔记（十一）—— 智能指针
ZChongr
06-13 4495
轻量级指针Binder的学习历程爬到驱动的半山腰明显感觉越来越陡峭，停下业务层的学习，补补基础层知识吧，这首当其冲的就是智能指针了，智能指针的影子在Android源码中随处可见。打开frameworkds/rs/cpp/util，RefBase.h和StrongPointer.h两个文件，代码多读几遍都能读懂，可是串起来总感觉摸不到骨架，把不住主线。闭上眼零零星星的点串不成一条线。究其原因应该是此处
安卓Android源码——mouseovertest.rar
10-11
首先，Android系统主要设计为触控操作，但随着智能设备的多样化，例如电视、桌面端等，支持鼠标输入成为必要的功能。Android API提供了处理鼠标悬停事件的接口，让开发者可以为这些设备提供更好的用户体验。 1. **...
安卓Android源码——指南针安卓端源码.zip
10-10
"安卓" 和 "android" 指的是Google的开源移动操作系统，用于智能手机和平板电脑等设备。这个标签表明源码是专门为Android平台编写的。 【文件名称列表解析】 尽管给出的列表只包含了一个文件 "安卓Android源码——...
Android智能指针
既不是天才，便做那疯子！
05-28 663
本文参考Android系统源代码情景分析进行总结，实现代码上替换成Android O的代码。
Android基础--智能指针
yizhongliu的专栏
04-08 493
智能指针分为3类为轻量级指针（Light Pointer）、强指针（Strong Pointer）和弱指针（Weak Pointer）。轻量级指针采用的是简单的计数，可以认为是强指针的简化版本。在播放器的C++代码中，特别是涉及到binder通讯的地方有很多智能指针的应用,比如jni中 sp<MediaPlayer> mp = getMediaPlayer(env, thiz); s...
Android 13 - 智能指针
青山渺渺
06-12 1621
Android智能指针
Android 智能指针详解
私房菜
01-12 842
来源： http://blog.csdn.net/shift_wwx/article/details/79045127 前言： android framework模块也持续工作了好多年，有些关键的东西还是需要总结，好记性不如烂笔头。最近在回顾C++11中的智能指针，想到了android 中的自带的智能指针，总结一下。 分三部分： 1、Android 智能指针详解 --
Android系统源码分析之智能指针
AngelQing2015的博客
02-02 213
Android系统源码分析之智能指针 在Android系统的应用程序框架层中，相当一部分代码是使用C++写的，而C++编写代码最容易出错的地方就是指针了，具体表现： 一、忘记释放指针指向的对象所占用的内存 二、使用了无效指针 C++指针使用不当，轻则造成内存泄漏，重则造成莫名其妙的逻辑错误，甚至系统奔溃。 但是出于性能的考虑，Android系统的应用程序框架层不得不使用C++来开发。Android系统为我们提供了C++智能指针，避免出现指针使用不当的问题。 通常引用计数技术来维护对象的生命周期，每当有一个新
Android高级——智能指针
最新发布
松仔Log的博客
07-04 1164
智能指针是一种能够自动维护对象引用计数的技术Android系统提供了三种类型的C++智能指针。
android中的智能指针
奋斗
10-10 753
智能指针主要用来解决多个指针指向同一对象时,一个指针被销毁时删除了对象导致的指针悬挂问题.　　智能指针的实现原理:使用引用计数来管理指向对像的拷贝,智能指针将一个计数器和指向的对像关联起来,在创建智能指针时将计数器初始化为1(使用指向的对像来创建),使用其他智能指针进行创建时将调用拷贝构造函数,拷贝构造函数将计数器加1,对其他智能指针赋值时减少左值的计数值增加右值的计数值,释放指针将调用析构函数,
探索Android仪表盘高级源码：Thermometer应用
本资源包中包含的文件及知识点主要涉及Android应用开发中的高级主题，重点在于一个具体的应用实例——thermometer_android仪表盘。这将是一个针对Android平台开发的具有温度显示功能的仪表盘应用。该资源包可能包含...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值