Direct3D接口自动指针模板

为了方便使用Direct3D接口写的模板

 

#ifndef _DX_AUTO_PTR_
#define _DX_AUTO_PTR_

/*********************************************************
*DX接口不应该主动使用赋值符,这里将赋值定义为会使右值无效       **
*使用Release时应使用DX_auto_ptr的成员函数。                  **
*必须要使用时用get方法返回原生指针进行操作。                   **
*用于管理DX接口的模版                                          **
*********************************************************/
template<class T>
class DX_auto_ptr
{
public:
    DX_auto_ptr():_ptr( 0 ){}
    //复制构造函数传递指针值，然后清空参数指针
    DX_auto_ptr( DX_auto_ptr<T> &ptr ):_ptr( ptr._ptr ){ptr._ptr = 0;}
    ~DX_auto_ptr(){ if( _ptr ) { _ptr->Release() ; _ptr = 0; } }
    //正确释放指针
    ULONG Release() { if( _ptr ) { ULONG re = _ptr->Release() ; _ptr = 0; return re; } return 0; }
    T *operator &() { return &_ptr; }
    T &operator ->(){ return _ptr; }
    //类型安全赋值
    DX_auto_ptr<T> &operator =( DX_auto_ptr<T> &ptr ){ _ptr = ptr._ptr ; ptr._ptr = 0; return *this; 
    //赋值符传递指针值，然后清空r_value指针
    DX_auto_ptr<T> &operator =( T &ptr ){  if( _ptr ) _ptr->Release() ; _ptr = ptr;  return *this; }
    //安全交换指针
    void swap( DX_auto_ptr<T> &ptr ){ T temp = ptr._ptr ; ptr._ptr = _ptr ; _ptr = temp; }
    operator T() const { return _ptr; }//重载转换操作符
    T& get(){ return _ptr; }//取原生指针
private:
    T _ptr;
};

/*********************************************************
**还可以使用vector 或 list进行保存。需要扩展复制构造函数**
**不支持动态增加或删除。set_ptrs是不安全的方法。        **
*********************************************************/
template<class T>
class DX_auto_ptr_array
{
public:
    DX_auto_ptr_array():_ptrs(0){}
    void new_ptrs( DWORD len ){ _ptrs = new DX_auto_ptr<T>[len]; }
    DX_auto_ptr<T> &operator []( DWORD i ){ return _ptrs[i]; }
    void set_ptrs( T* ptrs , DWORD len ){ _ptrs = new DX_auto_ptr<T>[len]; memcpy( &_ptrs , ptrs , sizeof( T ) * len ); }
    ~DX_auto_ptr_array(){ if( _ptrs ) { delete[]_ptrs; } }
private:
    DX_auto_ptr<T> *_ptrs;
}; 


#endif

 

4-10更新版本

 

#ifndef _DX_AUTO_PTR_
#define _DX_AUTO_PTR_
#include <exception>
#include <assert.h>

/*************
*安全释放接口*
*************/
template< class T >
void DX_Releaser( T & ptr )
{
    if( ptr != NULL )
    {
        ptr->Release();
        ptr = NULL;
    }
}

template< class T >
struct DX_Ptr_Checker_Assert
{
    static void _Ptr_Check( T & ptr )
    {
        assert( ptr != NULL );
    }
};

template< class T >
struct DX_Ptr_Checker_Null
{
    static void _Ptr_Check( T & ptr )
    {
    }
};

/*********************************************************
*DX接口不应该主动使用赋值符,这里将赋值定义为会使右值无效**
*使用Release时应使用DX_auto_ptr的成员函数。             **
*必须要使用时用get方法返回原生指针进行操作。            **
*用于管理DX接口的模版                                   **
*********************************************************/
template< class T , 
            template< class T > class Get_Ptr_Check_Rule = DX_Ptr_Checker_Assert >
class DX_auto_ptr : public Get_Ptr_Check_Rule< T >
{
public:
    DX_auto_ptr():_ptr(NULL){}
    ~DX_auto_ptr()
    {
        DX_Releaser( _ptr );
    }
    //正确释放指针
    void Release() 
    {
        DX_Releaser( _ptr );
    }
    T *operator &() 
    { 
        return &_ptr; 
    }
    T &operator ->()
    {
        _Ptr_Check(_ptr);
        return _ptr; 
    }
    bool isNull()
    {
        return _ptr == NULL;
    }
    //交换指针
    void swap( DX_auto_ptr<T,Get_Ptr_Check_Rule> &ptr )
    {
        T temp = ptr._ptr;
        ptr._ptr = _ptr;
        _ptr = temp;
    }
    //重载转换操作符
    operator T() const
    { 
        return _ptr;
    }
    //取原生指针
    T get()
    { 
        return _ptr;
    }
    //设置原生指针    
    void set(T ptr)
    { 
        _ptr = ptr;
    }
protected:
    DX_auto_ptr( DX_auto_ptr<T,Get_Ptr_Check_Rule>& ptr );//不允许
    DX_auto_ptr<T> &operator =( DX_auto_ptr<T,Get_Ptr_Check_Rule> &ptr );//不允许
    T _ptr;
};

template< class T >
struct Bound_Detector_Null
{
    static void _Bound_Check( int cur , int up )
    {
    }
};

template< class T >
struct Bound_Detector_Throw
{
    class OutBoundary : public std::exception{};
    static void _Bound_Check( int cur , int up )
    {
        if( cur <  0 || cur > up )
            throw OutBoundary();
    }
};

template< class T >
struct Bound_Detector_Assert
{
    static void _Bound_Check( int cur , int up )
    {
        assert( cur >=  0 && cur <= up );
    }
};

/*********************************************************
**不支持动态增加或删除。set_ptrs是不安全的方法。        **
*********************************************************/
template<class T , 
            template< class T > class Get_Ptr_Check_Rule = DX_Ptr_Checker_Assert ,
            template< class T > class Bound_Check_Rule = Bound_Detector_Assert >
class DX_auto_ptr_array : public Bound_Check_Rule< T > , public Get_Ptr_Check_Rule< DX_auto_ptr<T,Get_Ptr_Check_Rule> * >
{
public:
    DX_auto_ptr_array():_ptrs(NULL){}
    void new_ptrs( int len )
    { 
        _ptrs = new DX_auto_ptr< T , Get_Ptr_Check_Rule >[len];
        _len = len; 
    }
    void Release()
    {
        if( _ptrs != NULL )
        { 
            delete[]_ptrs;
            _ptrs = NULL;
            _len = 0;
        } 
    }
    DX_auto_ptr<T> &operator []( unsigned long i )
    { 
        _Ptr_Check( _ptrs );
        _Bound_Check( i , _len );
        return _ptrs[i];
    }
    //交换指针
    void swap( DX_auto_ptr_array< T , Get_Ptr_Check_Rule , Bound_Check_Rule > & ptr )
    { 
        DX_auto_ptr<T,Get_Ptr_Check_Rule> * temp = ptr._ptrs ; 
        ptr._ptrs = _ptrs ;
        _ptrs = temp; 
        _len^=ptr->_len;
        ptr->_len^=_len;
        _len^=ptr->_len;
    }
    ~DX_auto_ptr_array()
    {
        Release();
    }
protected:
    DX_auto_ptr_array( DX_auto_ptr_array< T , Get_Ptr_Check_Rule , Bound_Check_Rule >& );//不允许
    DX_auto_ptr_array< T , Get_Ptr_Check_Rule , Bound_Check_Rule > & operator =
        ( DX_auto_ptr_array< T , Get_Ptr_Check_Rule , Bound_Check_Rule >& );//不允许
    unsigned int _len;
    DX_auto_ptr<T,Get_Ptr_Check_Rule> *_ptrs;
}; 


#endif