开源Platinum库里的智能指针机制

在研究 Platinum 的 dlna， 其中实现的操作 g_dlna_ctrl_point = (PLT_CtrlPointReference)new PLT_CtrlPoint(); 但是从来不做 delete 操作

当时一直很奇怪，后面仔细看了下 PLT_CtrlPointReference 的实现，原来它实现了一种机制，类似于java语言的对象引用，如果一个对象没有引用了，就会自动释放。

PLT_CtrlPointReference 因为上在 C++ 语言上实现了，巧妙的使用了 析构 函数的应用

先上代码，我把 PLT_CtrlPointReference 的实现简单整理了下，应该可以在各种平台编译测试

typedef unsigned int  NPT_Cardinal;

template <typename T>
class NPT_Reference
{
public:
    // constructors and destructor
    NPT_Reference() : m_Object(NULL), m_Counter(NULL) {}
    explicit NPT_Reference(T* object, bool thread_safe = true) : 
        m_Object(object), 
        m_Counter(object?new NPT_Cardinal(1):NULL){}

	NPT_Reference(const NPT_Reference<T>& ref) :
        m_Object(ref.m_Object), m_Counter(ref.m_Counter){
        if (m_Counter) ++(*m_Counter);
    }

	// this methods should be private, but this causes a problem on some
    // compilers, because we need this function in order to implement
    // the cast operator operator NPT_Reference<U>() below, which would
    // have to be marked as a friend, and friend declarations with the 
    // same class name confuses some compilers
    NPT_Reference(T* object, NPT_Cardinal* counter) : 
        m_Object(object), m_Counter(counter) { 
        if (m_Counter) ++(*m_Counter);
    }

    ~NPT_Reference() {
        Release();
    }

	// overloaded operators
    NPT_Reference<T>& operator=(const NPT_Reference<T>& ref) {
        if (this != &ref) {
            Release();
            m_Object = ref.m_Object;
            m_Counter = ref.m_Counter;
            
            
            if (m_Counter) ++(*m_Counter);
            
        }
        return *this;
    }

	NPT_Reference<T>& operator=(T* object) {
        Release();
        m_Object  = object;
        m_Counter = object?new NPT_Cardinal(1):NULL;
        
        return *this;
    }

	T& operator*() const { return *m_Object; }
    T* operator->() const { return m_Object; }

    bool operator==(const NPT_Reference<T>& ref) const {
        return m_Object == ref.m_Object;
    } 
    bool operator!=(const NPT_Reference<T>& ref) const {
        return m_Object != ref.m_Object;
    }

	// overloaded cast operators
    template <typename U> operator NPT_Reference<U>() {
        return NPT_Reference<U>(m_Object, m_Counter);
    }

    // methods
    /**
     * Returns the naked pointer value.
     */
    T* AsPointer() const { return m_Object; }
    
    /**
     * Returns the reference counter value.
     */
    NPT_Cardinal GetCounter() const { return *m_Counter; }
    
    /**
     * Returns whether this references a NULL object.
     */
    bool IsNull()  const { return m_Object == NULL; }
    
    /**
     * Detach the reference from the shared object.
     * The reference count is decremented, but the object is not deleted if the
     * reference count becomes 0.
     * After the method returns, this reference does not point to any shared object.
     */
    void Detach() {
        Release(true);        
    }

private:
    // methods
    void Release(bool detach_only = false) {
        bool last_reference = false;
        
            
        if (m_Counter && --(*m_Counter) == 0) {
            delete m_Counter;
            if (!detach_only) delete m_Object;
            last_reference = true;
        }
        
        m_Counter = NULL;
        m_Object  = NULL; 
    }
	// members
    T*            m_Object;
    NPT_Cardinal* m_Counter;
};

class PLT_CtrlPoint
{
public:
	PLT_CtrlPoint(){printf("create\n");}; 
	~PLT_CtrlPoint(){printf("destroy\n");};
};

接下来，我们做测试

typedef NPT_Reference<PLT_CtrlPoint> PLT_CtrlPointReference;

static void test(void)
{
	PLT_CtrlPointReference g_dlna_ctrl_point;
	g_dlna_ctrl_point = (PLT_CtrlPointReference)new PLT_CtrlPoint();
}

int _tmain(int argc, _TCHAR* argv[])
{
	test();
	return 0;
}

我们看到，g_dlna_ctrl_point 进行了 new 操作但是没有进行 delete 操作

但是测试的结果是：

destroy 打印出来了

这是因为 g_dlna_ctrl_point 是局部对象，走过了 test() 函数的生存期后，会自动调用 g_dlna_ctrl_point 对象的析构函数，然后引用计数器减1，发现引用计数器为 0 的话，就真正delete 对象

我们再来一个测试

PLT_CtrlPointReference g_dlna_ctrl_point;

static void test(void)
{
	g_dlna_ctrl_point = (PLT_CtrlPointReference)new PLT_CtrlPoint();
}

int _tmain(int argc, _TCHAR* argv[])
{
	test();
	return 0;
}

g_dlna_ctrl_point 现在是全局的了，可见 调用完 test() 函数后，没有进行释放操作

这个时候，我加上 g_dlna_ctrl_point = NULL; 操作，见下面代码

PLT_CtrlPointReference g_dlna_ctrl_point;

static void test(void)
{
	g_dlna_ctrl_point = (PLT_CtrlPointReference)new PLT_CtrlPoint();
}

int _tmain(int argc, _TCHAR* argv[])
{
	test();
	g_dlna_ctrl_point = NULL;
	return 0;
}

这个时候可看到：

destroy 被打印出来了

这样，局部的对象，不需要的时候，不需要理会，它自己会消失

全局的对象，不需要的时候，赋值为 NULL 或者是其它的值，类似java的机制，那么这个对象就消失了

了解了这些，再分析这些代码，就清楚了