在此特别感谢renwind提供的FTP空间
文章请访问下面的链接（PDF格式请使用Acrobat 5或以上版本打开）
http://www.zsws.org/renwind/smartPtr.pdf
代码：
/** NOTE ********************************************************************
filename:RefObject.h
creator:noslopforever
more author:noslopforever
！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
本文件是GamerClass工程不可分割的一部分，GamerClass以及本文件的作者noslopforever（天堂里的死神）［Email：noslopforever@yahoo.com.cn］在此声明：
在法律所允许范围内，您可以自由、免费使用本文件，但您不能更改此文件自由、共享的本质，不能将文件及其内容私有化。
在任何情况下，您都必须不经修改地保留此Note，即便您在使用过程中人为修改了本文件，仍应保留此Note。
此Note中，只有more author部分才是您可以修改的部分，但必须保留这一部分的原始信息。
让我们共同维护公平公正、合法合理的代码共享环境，好的环境将让我们彼此受益，谢谢大家。
！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
purpose:TSafePtrNULL保护智能指针
TSharePtrRefCount智能指针（必须和CRefObject的派生类搭配使用）
TSharePtrAutoValid自删除性质的RefCount智能指针（必须和CRefObject的派生类搭配使用）
****************************************************************************/
#ifndef _RefObject_H_
#define _RefObject_H_
#include "NF3DTypes.h"
StartNamespace(NF3D)
/** 在需要INVALID Define的类结构体内写这一句，为cls传入这个类的类名 */
#defineDEF_INVALID( cls )static cls##*INVALID;
/** 在相应cpp里面写这一句，为cls传入这个类的类名，为value传入相应非法Class的地址 */
#defineIMPL_INVALID( cls , value )cls##* cls##::INVALID =##value##;
/** 或者，为cls传入这个类的类名，为inv_cls传入相应非法Class名 */
#defineIMPL_CLS_INVALID( cls , inv_cls )\
inv_cls g_##inv_cls;\
IMPL_INVALID( cls , &g_##inv_cls )\
template < class T >
class TSharePtr;
//------------------------------------------------------------------------
/**
*\brief
*/
class NF3D_APICRefObject
{
public:
CRefObject() : m_un32RefCount(0)
{ }
virtual~CRefObject()
{
#ifdef _DEBUG
if ( m_un32RefCount != 0 )
{ assert(false); }
#endif
}
DEF_INVALID(CRefObject)
private:
template < class T > friend class TSharePtr;
template < class T > friend class TSharePtrAutoValid;
// 引用计数
uint32m_un32RefCount;
private:
inlinevoidAddRef()
{ ++m_un32RefCount; }
inlinevoidRelease()
{
if ( --m_un32RefCount == 0 )
{ delete this; }
}
public:
inlineuint32GetRefCount()
{ return m_un32RefCount; }
template< class T >
staticvoidAddRef( T* t )
{
if ( t )
{
t->AddRef();
}
}
template< class T >
staticvoidRelease( T* t )
{
if ( t )
{
t->Release();
}
}
};
//------------------------------------------------------------------------
//------------------------------------------------------------------------
/**
* @brief
*/
template < class T >
class TSharePtr
{
private:
/** 内部接口 */
T*m_pInner;
inlineT*_ReturnInner() const
{
if ( !m_pInner )
{
// @todo throw or log error
return T::INVALID;
}
return m_pInner;
}
public:
inlineT*__real_ptr()const
{ return m_pInner; }
inlineoperator bool() const
{ return m_pInner!=NULL; }
public:
/** cast为内部接口 */
inlineT* ptr() const
{ return _ReturnInner(); }
inlineconst T*cptr() const
{ return _ReturnInner(); }
inlineconst T* operator->() const
{ return _ReturnInner(); }
inlineT* operator->()
{ return _ReturnInner(); }
public:
/** 默认构造函数 */
TSharePtr()
{
m_pInner = NULL;
}
/** 通过内部接口构造 */
TSharePtr( const T* pInner )
{
m_pInner = const_cast<T*>(pInner);
if ( m_pInner )
{ m_pInner->AddRef(); }
}
/** 拷贝构造函数 */
template < class U >
TSharePtr( TSharePtr<U> const& rhs )
{
m_pInner = static_cast<T*>(rhs.__real_ptr());
if ( m_pInner ) { m_pInner->AddRef(); }
}
TSharePtr( TSharePtr<T> const& rhs )
{
m_pInner = rhs.__real_ptr();
if ( m_pInner )
{ m_pInner->AddRef(); }
}
/** 析构函数 */
~TSharePtr()
{
if ( m_pInner )
{
static_cast<CRefObject*>(m_pInner)->Release();
m_pInner = NULL;
}
}
/** 赋值函数 */
template < class U >
inlineTSharePtr<T>&operator= ( TSharePtr<U> const& rhs )
{
SafeRelease(m_pInner);
m_pInner = static_cast<T*>(rhs.__real_ptr());
if ( m_pInner )
{ m_pInner->AddRef(); }
return *this;
}
inlineTSharePtr<T>&operator= ( TSharePtr<T> const& rhs )
{
SafeRelease(m_pInner);
m_pInner = rhs.__real_ptr();
if ( m_pInner )
{ m_pInner->AddRef(); }
return *this;
}
/** 比较函数 */
template <class U>
inlinebool operator== ( TSharePtr<U> const& rhs ) const
{ return m_pInner == rhs.__real_ptr(); }
template <class U>
inlinebool operator!= ( TSharePtr<U> const& rhs ) const
{ return m_pInner != rhs.__real_ptr(); }
template <class U>
inlinebool operator== ( U* rhs ) const
{ return m_pInner == rhs; }
template <class U>
inlinebool operator!= ( U* rhs ) const
{ return m_pInner != rhs; }
inlinebool operator== ( T* rhs ) const
{ return m_pInner == rhs; }
inlinebool operator!= ( T* rhs ) const
{ return m_pInner != rhs; }
staticconst TSharePtr<T>&NULLPTR()
{
static TSharePtr<T> null_handle;
return null_handle;
}
};
//------------------------------------------------------------------------
//------------------------------------------------------------------------
/**
* @brief
*/
template < class T >
class TSafePtr
{
private:
/** 内部接口 */
T*m_pInner;
inlineT*_ReturnInner() const
{
if ( !m_pInner )
{
// @todo throw or log error
return T::INVALID;
}
return m_pInner;
}
public:
inlineT*__real_ptr()const
{ return m_pInner; }
/** cast为内部接口 */
inlineT* ptr() const
{
return _ReturnInner();
}
inlineconst T*cptr() const
{ return _ReturnInner(); }
inlineoperator bool() const
{ return m_pInner!=NULL; }
inlineconst T* operator->() const
{
return _ReturnInner();
}
inlineT* operator->()
{
return _ReturnInner();
}
public:
/** 默认构造函数 */
TSafePtr()
{
m_pInner = NULL;
}
/** 通过内部接口构造 */
TSafePtr( const T* pInner )
{
m_pInner = const_cast<T*>(pInner);
}
/** 拷贝构造函数 */
template < class U >
TSafePtr( TSafePtr<U> const& rhs )
{
m_pInner = static_cast<T*>(rhs.__real_ptr());
}
TSafePtr( TSafePtr<T> const& rhs )
{
m_pInner = rhs.__real_ptr();
}
/** 析构函数 */
~TSafePtr()
{
}
/** 赋值函数 */
template < class U >
inlineTSafePtr<T>&operator= ( TSafePtr<U> const& rhs )
{
m_pInner = static_cast<T*>(rhs.__real_ptr());
return *this;
}
inlineTSafePtr<T>&operator= ( TSafePtr<T> const& rhs )
{
m_pInner = rhs.__real_ptr();
return *this;
}
/** 比较函数 */
template <class U>
inlinebool operator== ( TSafePtr<U> const& rhs ) const
{ return m_pInner == rhs.__real_ptr(); }
template <class U>
inlinebool operator!= ( TSafePtr<U> const& rhs ) const
{ return m_pInner != rhs.__real_ptr(); }
template <class U>
inlinebool operator== ( U* rhs ) const
{ return m_pInner == rhs; }
template <class U>
inlinebool operator!= ( U* rhs ) const
{ return m_pInner != rhs; }
inlinebool operator== ( T* rhs ) const
{ return m_pInner == rhs; }
inlinebool operator!= ( T* rhs ) const
{ return m_pInner != rhs; }
staticconst TSafePtr<T>&NULLPTR()
{
static TSafePtr<T> null_handle;
return null_handle;
}
};
//------------------------------------------------------------------------
//------------------------------------------------------------------------
/**
* @brief
*/
template < class T >
class TSharePtrAutoValid
{
private:
/** 内部接口 */
T*m_pInner;
inlinevoid_Validate() const
{
if ( m_pInner )
{
if ( m_pInner->IsDestroyed() ){ SafeRelease(const_cast<TSharePtrAutoValid<T>*>(this)->m_pInner); }
}
}
inlineT*_ReturnInner() const
{
if ( !m_pInner )
{
//assert(false);
return T::INVALID;
}
return m_pInner;
}
public:
inlineT*__real_ptr()const
{
_Validate();
return m_pInner;
}
inlineoperator bool() const
{ return m_pInner!=NULL; }
public:
/** cast为内部接口 */
inlineT* ptr() const
{ _Validate();return _ReturnInner(); }
inlineconst T*cptr() const
{ _Validate();return _ReturnInner(); }
inlineconst T* operator->() const
{ _Validate();return _ReturnInner(); }
inlineT* operator->()
{ _Validate();return _ReturnInner(); }
public:
/** 默认构造函数 */
TSharePtrAutoValid()
{
m_pInner = NULL;
}
/** 通过内部接口构造 */
TSharePtrAutoValid( const T* pInner )
{
m_pInner = const_cast<T*>(pInner);
if ( m_pInner )
{ m_pInner->AddRef(); }
}
/** 拷贝构造函数 */
template < class U >
TSharePtrAutoValid( TSharePtrAutoValid<U> const& rhs )
{
m_pInner = static_cast<T*>(rhs.__real_ptr());
if ( m_pInner ) { m_pInner->AddRef(); }
}
TSharePtrAutoValid( TSharePtrAutoValid<T> const& rhs )
{
m_pInner = rhs.__real_ptr();
if ( m_pInner )
{ m_pInner->AddRef(); }
}
/** 析构函数 */
~TSharePtrAutoValid()
{
if ( m_pInner )
{
static_cast<CRefObject*>(m_pInner)->Release();
m_pInner = NULL;
}
}
/** 赋值函数 */
template < class U >
inlineTSharePtrAutoValid<T>&operator= ( TSharePtrAutoValid<U> const& rhs )
{
SafeRelease(m_pInner);
m_pInner = static_cast<T*>(rhs.__real_ptr());
if ( m_pInner )
{ m_pInner->AddRef(); }
return *this;
}
inlineTSharePtrAutoValid<T>&operator= ( TSharePtrAutoValid<T> const& rhs )
{
SafeRelease(m_pInner);
m_pInner = rhs.__real_ptr();
if ( m_pInner )
{ m_pInner->AddRef(); }
return *this;
}
/** 比较函数 */
template <class U>
inlinebool operator== ( TSharePtrAutoValid<U> const& rhs ) const
{ _Validate();return m_pInner == rhs.__real_ptr(); }
template <class U>
inlinebool operator!= ( TSharePtrAutoValid<U> const& rhs ) const
{ _Validate();return m_pInner != rhs.__real_ptr(); }
template <class U>
inlinebool operator== ( U* rhs ) const
{ _Validate();return m_pInner == rhs; }
template <class U>
inlinebool operator!= ( U* rhs ) const
{ _Validate();return m_pInner != rhs; }
inlinebool operator== ( T* rhs ) const
{ _Validate();return m_pInner == rhs; }
inlinebool operator!= ( T* rhs ) const
{ _Validate();return m_pInner != rhs; }
staticconst TSharePtrAutoValid<T>&NULLPTR()
{
static TSharePtrAutoValid<T> null_handle;
return null_handle;
}
};
//------------------------------------------------------------------------
//------------------------------------------------------------------------
typedefTSharePtr<CRefObject>REFOBJ_PTR;
//------------------------------------------------------------------------
EndNamespace
#endif//_RefObject_H_
分享到：
相关推荐
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
智能指针是C++中用于自动管理动态内存的对象，它遵循RAII（Resource Acquisition Is Initialization）原则，确保在适当的时间自动释放所持有的内存资源。在C++11及其后续版本中，标准库提供了四种类型的智能指针：`...
C++智能指针是C++标准库中用于自动管理动态分配内存的对象，它们的主要目标是解决C++中手动内存管理的挑战，特别是防止内存泄漏。智能指针在生命周期结束时会自动调用删除器（deleter）来释放其所指向的对象，确保...
本篇文章收集了近一年来所有关于智能指针的面试相关内容。以智能指针的面试题线索，穿插讲解完最常用的四种智能指针的各个方面。本文讲解4个智能指针的基本概念和特性，以及其他设计到的知识点。讲解的过程中，如果...
C++智能指针是C++标准库中提供的一种机制，用于自动管理动态分配的内存，以防止内存泄漏。智能指针的基本原理是利用类对象的析构函数在对象生命周期结束时自动释放其所指向的内存。这解决了传统指针在异常处理或函数...
C++11 智能指针详解 C++11 中引入了智能指针，用于自动管理堆内存，避免内存泄漏和二次释放。智能指针通过引用计数来管理堆内存，当最后一个指向对象的智能指针被销毁时，自动释放对象。C++11 中有四种智能指针：...
### 智能指针——真正的安全的指针 在现代C++开发中，智能指针作为一种高级特性被广泛应用于内存管理中。它提供了一种更安全、更可靠的内存管理方式，有效地避免了传统裸指针所带来的一系列问题，如内存泄漏、悬挂...
"c++句柄、智能指针和指针的区别" 在C++编程中，句柄、智能指针和指针是三个相关但不同的概念。理解它们之间的区别对于初学者来说非常重要。 首先，让我们来讨论指针和句柄的区别。指针是指向物理内存地址的指针...
C++ 7种智能指针测试代码
在C++中，智能指针是管理动态分配对象的现代工具，它们负责自动释放内存，以防止内存泄漏。其中，`shared_ptr`是C++11引入的一种智能指针，它实现了引用计数机制，当最后一个`shared_ptr`实例被销毁时，其管理的对象...
智能指针是C++编程中一个非常重要的工具，它在管理动态分配的内存时提供了自动释放的功能，大大降低了内存泄漏的风险。然而，如果不正确地使用智能指针，反而可能导致一些严重的问题，例如悬挂指针、内存泄漏或者...
在计算机系统中，资源是数量有限且对系统正常运行具有一定作用的元素。...不过系统为我们提供了智能指针，避免出现上述问题，本文将系统地分析Android系统智能指针（轻量级指针、强指针和弱指针）的实现原理。
当引用计数变为零时，意味着没有智能指针再指向这个对象，此时系统会自动释放该对象的内存。 在C++标准库中，有几种不同的智能指针类型，包括`std::unique_ptr`、`std::shared_ptr`和`std::weak_ptr`。其中： 1. `...
STL 中的智能指针 智能指针是一种特殊的指针，它可以自动管理内存，避免手动 delete 导致的内存泄露问题。在 STL 中，有多种智能指针，每种都有其特点和用途。本文将详细介绍 STL 中的智能指针，包括 std::auto_ptr...
例如，在32位系统中，指针通常占用4字节；而在64位系统中，指针则占用8字节。 ### 指针操作 #### 指针赋值 指针可以通过`=`操作符被赋予另一个同类型的指针的值，或者被赋予一个NULL值。例如： ```c int a = 10; ...
智能指针是C++编程中一个非常重要的概念，它是一种对象，封装了原始指针，并在需要时自动管理所指向的对象的生命周期。智能指针的主要目的是解决C++中的内存管理和资源管理问题，防止因手动释放内存导致的内存泄漏...
C++智能指针是C++语言为解决内存管理问题，特别是防止内存泄漏而引入的一种机制。传统的C++中，程序员需要手动申请和释放内存，这可能导致内存泄漏，尤其是在复杂的程序结构中。为了解决这个问题，C++引入了智能指针...
C++智能指针的创建 C++中的指针是很麻烦的，难以管理和释放内存。为了减少问题的出现，现在有很多技巧去减少问题的出现。智能指针是其中一种解决方案。 智能指针是一种特殊的类，它可以模拟指针的行为，但同时也...