C++ 智能指针

最新推荐文章于 2024-11-13 18:57:30 发布
最新推荐文章于 2024-11-13 18:57:30 发布
阅读量1.9k 收藏
点赞数 1
分类专栏： C++语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jltxgcy/article/details/18603575
版权
本文详细解析了C++中的智能指针RefBase的实现原理，包括其弱引用计数的管理，以及在不同引用计数情况下的行为。通过多个测试案例展示了RefBase在强引用和弱引用转换中的作用，以及对象生命周期的控制。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

本文参考http://blog.youkuaiyun.com/luoshengyang/article/details/6786239

一、RefBash.h

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

        void            decStrong(const void* id) const;

        int             getStrongCount() const;

	    class weakref_type
	    {
	    public:
		RefBase*            refBase() const;

		void                incWeak(const void* id);

		void                decWeak(const void* id);

		bool                attemptIncStrong(const void* id);

		int                 getWeakCount() const;
	    };

        weakref_type*   createWeak(const void* id) const;

        weakref_type*   getWeakRefs() const;

protected:
		                        RefBase();

	    virtual                 ~RefBase();//delete this时候会调用子类

	    enum {
		OBJECT_LIFETIME_WEAK    = 0x0001,
		OBJECT_LIFETIME_FOREVER = 0x0003
	    };

            void            extendObjectLifetime(int  mode);

	    enum {
		FIRST_INC_STRONG = 0x0001
	    };

	    virtual bool            onIncStrongAttempted(int flags, const void* id);//子类可以覆盖


private:
	    //friend class weakref_type;

    	class weakref_impl; //不能include，只能前向声明

        RefBase(const RefBase& o);

        RefBase&    operator=(const RefBase& o);

        weakref_impl* const mRefs;
};



// ---------------------------------------------------------------------------

template <typename T>
class sp
{
public:
	typedef typename RefBase::weakref_type weakref_type;
	//相当于typedef  RefBase::weakref_type weakref_typ

    sp(T* other);

    sp(const sp<T>& other);

    ~sp();

    inline  T*      get() const         { return m_ptr; }

private:
    template<typename Y> friend class wp;//wp可以操作sp的私有变量，如构造函数
 
    sp(T* p, weakref_type* refs);

    T*              m_ptr;
};



// ---------------------------------------------------------------------------

template <typename T>
class wp
{
public:
	typedef  RefBase::weakref_type weakref_type;
    wp(T* other);

    wp(const wp<T>& other);

    ~wp();

    sp<T> promote() const;

    inline  weakref_type* get_refs() const { return m_refs; }


private:

    T*              m_ptr;//strongPointer

    weakref_type*   m_refs;//weakref_impl

};



// ---------------------------------------------------------------------------

template<typename T>
sp<T>::sp(T* other)
    : m_ptr(other)//strongPointer
{
    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);
}


template<typename T>
sp<T>::sp(T* p, weakref_type* refs)
    : m_ptr((p && refs->attemptIncStrong(this)) ? p : 0)
{
}


// ---------------------------------------------------------------------------

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

template<typename T>
wp<T>::wp(const wp<T>& other)
    : m_ptr(other.m_ptr), m_refs(other.m_refs)
{
    if (m_ptr) m_refs->incWeak(this);
}


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


template<typename T>
sp<T> wp<T>::promote() const
{
    return sp<T>(m_ptr, m_refs);
}


二、RefBase.cpp

#include "RefBase.h"
#include <iostream>
using namespace std;
#define INITIAL_STRONG_VALUE (1<<28)

class RefBase::weakref_impl : public RefBase::weakref_type
{
public:
    volatile int    mStrong;
    volatile int    mWeak;
    RefBase* const      mBase;
    volatile int    mFlags;

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

    ~weakref_impl()
    {
    	cout << "~weakref_impl"<<endl;
    }
};

// ---------------------------------------------------------------------------

void RefBase::incStrong(const void* id) const
{
    weakref_impl* const refs = mRefs;
    refs->incWeak(id);

    const int c = refs->mStrong++;
    if (c != INITIAL_STRONG_VALUE)  {
        return;
    }
    refs->mStrong = refs->mStrong - INITIAL_STRONG_VALUE;
}

void RefBase::decStrong(const void* id) const
{
    weakref_impl* const refs = mRefs;
    const int c = --refs->mStrong;
    if (c == 0) {
        if ((refs->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) {//受到强指针控制
            delete this;
        }
    }

    refs->decWeak(id);
}


int RefBase::getStrongCount() const
{
    return mRefs->mStrong;
}



RefBase* RefBase::weakref_type::refBase() const
{
    return static_cast<const weakref_impl*>(this)->mBase;
}

void RefBase::weakref_type::incWeak(const void* id)
{
    weakref_impl* const impl = static_cast<weakref_impl*>(this);
    impl->mWeak++;
}

void RefBase::weakref_type::decWeak(const void* id)
{
    weakref_impl* const impl = static_cast<weakref_impl*>(this);
    const int c = --impl->mWeak;

    if (c != 0) return;

    if ((impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) {//受强指针控制
        if (impl->mStrong == INITIAL_STRONG_VALUE){
            delete impl->mBase;
        }
        else {
            delete impl;
        }
    } else {
        if ((impl->mFlags&OBJECT_LIFETIME_FOREVER) != OBJECT_LIFETIME_FOREVER) {//受弱指针控制
            delete impl->mBase;
        }
    }
}

bool RefBase::weakref_type::attemptIncStrong(const void* id)
{
    incWeak(id);//先增加，后面有减少，整体不变

    weakref_impl* const impl = static_cast<weakref_impl*>(this);

    int curCount = impl->mStrong;
    if (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {//mStrong变化过，且大于0
	    impl->mStrong = curCount + 1;
        curCount = impl->mStrong;
    }

    if (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) {//mStrong没有变化过；或者变化后，为0
        bool allow;
        if (curCount == INITIAL_STRONG_VALUE) {
            allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK
                  || impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);
        } else {
            allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_WEAK
                  && impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);
        }
        if (!allow) {
            decWeak(id);//再减少
            return false;
        }
        curCount = impl->mStrong++;
    }



    if (curCount == INITIAL_STRONG_VALUE) {
	impl->mStrong = impl->mStrong - INITIAL_STRONG_VALUE;
    }

    return true;
}


int RefBase::weakref_type::getWeakCount() const
{
    return static_cast<const weakref_impl*>(this)->mWeak;
}

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

RefBase::weakref_type* RefBase::getWeakRefs() const
{
    return mRefs;
}

RefBase::RefBase()
    : mRefs(new weakref_impl(this))
{
}

RefBase::~RefBase()
{
    if (mRefs->mWeak == 0) {
        delete mRefs;
    }
}

void RefBase::extendObjectLifetime(int mode)
{
    mRefs->mFlags = mode;
}

bool RefBase::onIncStrongAttempted(int flags, const void* id)
{
    return (flags&FIRST_INC_STRONG) ? true : false;
}


void RefBase::decStrong(const void* id) const
{
    weakref_impl* const refs = mRefs;
    const int c = --refs->mStrong;
    if (c == 0) {
        if ((refs->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) {//受到强指针控制
            delete this;
        }
    }

    refs->decWeak(id);
}
减少强引用计数时候，同时减少弱引用计数，如果强引用计数为0，并且受强指针控制，那么调用子类和RefBase的析构函数 


void RefBase::weakref_type::decWeak(const void* id)
{
    weakref_impl* const impl = static_cast<weakref_impl*>(this);
    const int c = --impl->mWeak;

    if (c != 0) return;

    if ((impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) {//受强指针控制
        if (impl->mStrong == INITIAL_STRONG_VALUE){
            delete impl->mBase;
        }
        else {
            delete impl;
        }
    } else {
        if ((impl->mFlags&OBJECT_LIFETIME_FOREVER) != OBJECT_LIFETIME_FOREVER) {//受弱指针控制
            delete impl->mBase;
        }
    }
}


RefBase::~RefBase()
{
    if (mRefs->mWeak == 0) {
        delete mRefs;
    }
}

减少弱引用计数，如果弱引用计数为0，并且受弱指针控制，那么调用delete impl->mBase，调用上面的析构函数，因为此时mWeek==0，所以执行delete mRefs

如果弱引用计数为0，并且不受强指针，也不受弱指针控制，那么由自己调用delete来删除

如果弱引用计数为0，并且受强指针控制，如果强引用计数为0，那么只delete impl，因为RefBase及其子类已经被delelte掉了

如果弱引用计数为0，并且受强指针控制，如果强引用计数为INITIAL_STRONG_VALUE，那么说明RefBase及其子类还没有删除，那么要delelte impl->mBase，调用上面的析构函数，因为此时mWeek==0，所以执行delete mRefs


bool RefBase::weakref_type::attemptIncStrong(const void* id)
{
    incWeak(id);


    weakref_impl* const impl = static_cast<weakref_impl*>(this);


    int curCount = impl->mStrong;
    if (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {
	    impl->mStrong = curCount + 1;
        curCount = impl->mStrong;
    }


    if (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) {
        bool allow;
        if (curCount == INITIAL_STRONG_VALUE) {
            allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK
                  || impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);
        } else {
            allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_WEAK
                  && impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);
        }
        if (!allow) {
            decWeak(id);
            return false;
        }
        curCount = impl->mStrong++;
    }






    if (curCount == INITIAL_STRONG_VALUE + 1) {
	impl->mStrong = impl->mStrong - INITIAL_STRONG_VALUE;
    }


    return true;
}

    if (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {
	    impl->mStrong = curCount + 1;
        curCount = impl->mStrong;
    }

如果此时强引用计数不为0，或者初始值，那么说明RefBase及其子类还没有删除，所以可以提升为强引用



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

如果此时强引用计数为0，并且还受强指针控制，那么此时，RefBase及其子类已经被删除了，所以不能提升为强引用

如果此时强引用计数为0，并且还受弱指针控制，那么此时，RefBase及其子类还没有删除，能不能提升就看impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id)的了


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

如果此时强引用计数为INITIAL_STRONG_VALUE，并且还受强指针控制，此时RefBase及其子类还没有删除，所以能够提升。

如果此时强引用计数为INITIAL_STRONG_VALUE，并且还受弱指针控制，此时RefBase及其子类还没有删除，能不能提升就看impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id)的了


三、main.cpp

#include <stdio.h>
#include "RefBase.h"

#define INITIAL_STRONG_VALUE (1<<28)

class WeightClass: public RefBase {
public:
	void printRefCount() {
		int 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");
	}
};

class ForeverClass: public WeightClass {
public:
	ForeverClass() {
		extendObjectLifetime(OBJECT_LIFETIME_FOREVER);

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

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

void TestStrongClass(StrongClass* pStrongClass) {
	wp<StrongClass> wpOut = pStrongClass;
	pStrongClass->printRefCount();
	{
		sp<StrongClass> spInner = pStrongClass;
		pStrongClass->printRefCount();
	}
	pStrongClass->printRefCount();
	sp<StrongClass> spOut = wpOut.promote();
	printf("spOut: %p.\n", spOut.get());
	pStrongClass->printRefCount();
}

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

void TestStrongClass4(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());
	pStrongClass->printRefCount();
}

void TestStrongClass3(StrongClass* pStrongClass) {
	wp<StrongClass> wpOut = pStrongClass;
	pStrongClass->printRefCount();
	sp<StrongClass> spOut = wpOut.promote();
	printf("spOut: %p.\n", spOut.get());
	pStrongClass->printRefCount();
}

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());
	pWeakClass->printRefCount();
}

void TestForeverClass(ForeverClass* pForeverClass) {
	wp<ForeverClass> wpOut = pForeverClass;
	pForeverClass->printRefCount();
	{
		sp<ForeverClass> spInner = pForeverClass;
		pForeverClass->printRefCount();
	}
	pForeverClass->printRefCount();
}

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

	/*        printf("Test Strong Class2: \n");
	 StrongClass* pStrongClass = new StrongClass();
	 TestStrongClass2(pStrongClass);*/

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

	/*        printf("\nTest Froever Class: \n");
	 ForeverClass* pForeverClass = new ForeverClass();
	 TestForeverClass(pForeverClass);
	 pForeverClass->printRefCount();
	 delete pForeverClass;*/

	/*	 printf("Test Strong Class3: \n");
	 StrongClass* pStrongClass = new StrongClass();
	 TestStrongClass3(pStrongClass);*/

	printf("Test Strong Class4: \n");
	StrongClass* pStrongClass = new StrongClass();
	TestStrongClass4(pStrongClass);

	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.
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 1.
-----------------------
spOut: (nil).
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 1.
-----------------------
~weakref_impl

第二个：

Test Strong Class2: 
Construct StrongClass Object.
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 1.
-----------------------
Destory StrongClass Object.
~weakref_impl


第三个：

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: 0x1d60010.
-----------------------
Strong Ref Count: 1.
Weak Ref Count: 2.
-----------------------
Destory WeakClass Object.
~weakref_impl


第四个：

Test Froever Class: 
Construct ForeverClass 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.
-----------------------
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 0.
-----------------------
Destory ForeverClass Object.
~weakref_impl


第五个：

Test Strong Class3: 
Construct StrongClass Object.
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 1.
-----------------------
spOut: 0x646010.
-----------------------
Strong Ref Count: 1.
Weak Ref Count: 2.
-----------------------
Destory StrongClass Object.
~weakref_impl


第六个：

Test Strong Class4: 
Construct StrongClass Object.
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 1.
-----------------------
-----------------------
Strong Ref Count: 1.
Weak Ref Count: 2.
-----------------------
spOut: 0x154e010.
-----------------------
Strong Ref Count: 2.
Weak Ref Count: 3.
-----------------------
Destory StrongClass Object.
~weakref_impl



C++: 智能指针 sp 之 Android强弱指针的实现与使用
Change The World
08-02 845
回顾下前面提到的Android 轻量级智能指针 LightRefBase： class Person : public LightRefBase<Person>{} sp<Person>{ .Person *mptr; sp(){ incStrong; } ~sp(){ decStrong; } } 类比，强弱指针可能会有如下统一实现： class RefBase{ private: int mStrong; int mWeak; Public: voi
hs-promote:Haskell 数字层次结构的 C++ 风格类型提升
06-11
在haskell中输入promotion 就像在 Haskell 中一样，C++ 的算术运算总是作用于相同的类型（例如： 2 + 2或2.0 + 2.0 ，但不是2 + 2.0 ）。 与 Haskell 不同，C++ 自动将算术运算的参数提升为最通用的类​​型。 免得被认为C++在这方面优于Haskell，这里是一个在Haskell中类型提升的实现。 执行 我使用类型系列来计算结果类型，例如， Promotion Int Double = Double因为2 + 2.0的结果是一个Double 。 这种实现策略的一个缺点是我们需要定义一个平方数的实例，每对兼容类型一个。 为了避免这样做，我使用 Template Haskell 来生成所有实例。
智能指针实现Impl模式
xunye的博客
06-20 248
widget.h: class Widget { public: Widget(); ~Widget(); // ... other funcs Widget(const Widget& rhs); / Widget& operator=(const Widget& rhs); private: struct Impl; std::unique_ptr<Impl> pImpl; }; widget.cpp: struct Widget::Impl
C++ 相关智能指针
Flying snow
07-17 1165
智能指针sp/wp Android中定义了两种智能指针类型，一种是强指针sp（strong pointer），另外一种是弱指针（weak pointer）。其实称之为强引用和弱引用更合适一些。强指针与一般意义的智能指针概念相同，通过引用计数来记录有多少使用者在使用一个对象，如果所有使用者都放弃了对该对象的引用，则该对象将被自动销毁。 弱指针也指向一个对象，但是弱指针仅仅记录该对象的地址，不能通过弱指针来访问该对象，也就是说不能通过弱智真来调用对象的成员函数或访问对象的成员变量。要想访问弱指针所指向的对象，需
1分钟理清C/C++的弱符号和强符号，弱引用和强引用
大道至简，求同存异
04-14 1248
1分钟理清C/C++的弱符号和强符号，弱引用和强引用
《深度解析 C++中的弱引用（weak reference）：打破循环依赖的利器》
最新发布
xy520521的博客
11-13 753
在复杂的对象关系网络中，可能会出现循环引用的情况。节点之间可能存在相互指向的关系，如果使用普通的强引用，在删除图中的某些节点时，可能会因为复杂的引用关系而无法正确释放内存。总之，弱引用在 C++中是一种非常有用的概念，它为我们解决了在复杂的对象关系和内存管理中遇到的循环引用等难题，让我们能够更加灵活和安全地管理内存，构建更加健壮的程序。另外，弱引用的实现通常依赖于特定的库或者语言特性，不同的 C++实现环境可能会有一些细微的差别，所以在使用时要充分了解所在环境对弱引用的支持情况。
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
C++智能指针-unique-ptr智能指针详解.pdf
02-27
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++智能指针及容器测试用例
06-11
在C++编程中，智能指针和容器是两个非常重要的概念，它们极大地提高了代码的效率和安全性。本文将深入探讨这两个主题，并结合`CppTest`测试框架，展示如何编写测试用例来验证其正确性。 首先，让我们了解智能指针。...
C++“智能指针”实践与python的weakref
遥远的她
06-14 594
这两天复习C++ Primer时，在“复制控制”这一章看到管理指针成员，在没使用标准库的情况下自己创建一个智能指针。不过书中还是建议使用标准库unique_ptr、shared_ptr、weak_ptr实现，减少程序员内存管理问题的工作。 指针成员默认具有与指针对象同样的行为，但通过不同的复制控制策略，可以为指针成员实现不同的行为。多数C++类采用以下三种方法管理指针成员： （1）指针成员采用...
Android系统的智能指针（轻量级指针、强指针和弱指针）的实现原理分析
oraclestudy
09-23 852
Android系统的运行时库层代码是用C++来编写的，用C++来写代码最容易出错的地方就是指针了，一旦使用不当，轻则造成内存泄漏，重则造成系统崩溃。不过系统为我们提供了智能指针，避免出现上述问题，本文将系统地分析Android系统智能指针（轻量级指针、强指针和弱指针）的实现原理。 在使用C++来编写代码的过程中，指针使用不当造成内存泄漏一般就是因为new了一个对象并且使用完之...
sp<> 强指针类的用法
热门推荐
lksodit_yiyi的专栏
10-18 1万+
文一： 转：http://wangjun-1985.spaces.live.com/blog/cns!E9070276AAF56C8E!472.entry 在android 中可以广泛看到的template class Sp 句柄类实际上是android 为实现垃圾回收机制的智能指针。智能指针是c++ 中的一个概念，因为c++ 本身不具备垃圾回收机制，而且指针也不具备构造函数和析构函数，所以为
c++模板
2301_80429791的博客
02-14 245
【代码】c++模板。
C++数字信号处理算法库SP++
一码算一码
04-06 1万+
SP++ (Signal Processing in C++) 是一个关于信号处理与数值计算的开源C++程序库，该库提供了信号处理与数值计算中常用算法的C++实现。SP++中所有算法都以C++类模板方法实现，以头文件形式组织而成，所以不需要用户进行本地编译，只要将相关的头文件包含在项目中即可使用。”XXX.h”表示声明文件，”XXX-impl.h”表示对应的实现文件。所有的函数和类均位于名字空间”...
Android C++层的内存回收机制
拿节
01-11 3346
Android C++层的内存回收机制   Author：Harish_hu@qq.com 1关于C++ Layer的内存回收机制 Android C++层的内存收回主要是通过三个类来实现，分别是RefBase，sp，wp; SP和WP是两个智能指针类，sp是strong pointer，wp则是weak pointer，亦我们常说的强引用和弱引用；实例化sp和wp这两个模板类的类型必
对c++指针的理解
manchengpiaoxue的博客
09-18 405
#include&lt;iostream&gt; #include&lt;vector&gt; #include&lt;string&gt; using namespace std; int main() {     string s("hello world!");     string *sp = &amp;s;          cout &lt;&lt; s &lt;&lt; endl..
Android智能指针SP WP
h_8410435的博客
05-30 1073
Android的C++部分代码中有大量的sp/wp存在，意思是strong pointer和weak pointer，看字面意思就是指针相关的东西。C++是通过new和delete进行内存的分配和释放的，但是有时候开发者会忘记使用delete导致内存泄露，所以Android中就创建了sp/wp等，用于避免内存泄露和提高开发效率。强指针通过引用计数来记录有多少使用者在使用一个对象，如果所有使用者都放弃了对该对象的引用，则该对象将被自动销毁。
C++智能指针实现与应用
"C++智能指针是一种管理动态分配内存的有效工具，它们通过引用计数或其他机制自动释放所指向的对象，防止内存泄漏。本资源主要介绍了一个自定义的智能指针实现，以及智能指针在C++编程中的重要性。" 在C++编程中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值