CGrowableArray解析 _ DXUT容器

CGrowableArray的声明                                       in  DXUTmisc.h

 //--------------------------------------------------------------------------------------
 // A growable array .
 //--------------------------------------------------------------------------------------
 template<typename TYPE> class CGrowableArray
 {
 public:
             CGrowableArray()
             {
                 m_pData = NULL; m_nSize = ; m_nMaxSize = ;
             }
             CGrowableArray( const CGrowableArray <TYPE>& a )
             {
                 for( int i = ; i < a.m_nSize; i++ ) Add( a.m_pData[i] );
             }
             ~CGrowableArray()
             {
                 RemoveAll();
             }

     const TYPE& operator[]( int nIndex ) const
     {
         return GetAt( nIndex );
     }
     TYPE& operator[]( int nIndex )
     {
         return GetAt( nIndex );
     }

     CGrowableArray& operator=( const CGrowableArray <TYPE>& a )
     {
         if( this == &a ) return *this; RemoveAll(); for( int i = ; i < a.m_nSize;
                                                          i++ ) Add( a.m_pData[i] ); return *this;
     }

     HRESULT SetSize( int nNewMaxSize );
     HRESULT Add( const TYPE& value );
     HRESULT Insert( int nIndex, const TYPE& value );
     HRESULT SetAt( int nIndex, const TYPE& value );
     TYPE& GetAt( int nIndex ) const
     {
         assert( nIndex >=  && nIndex < m_nSize ); return m_pData[nIndex];
     }
     int     GetSize() const
     {
         return m_nSize;
     }
     TYPE* GetData()
     {
         return m_pData;
     }
     bool    Contains( const TYPE& value )
     {
         return ( - != IndexOf( value ) );
     }

     int     IndexOf( const TYPE& value )
     {
         return ( m_nSize >  ) ? IndexOf( value, , m_nSize ) : -;
     }
     int     IndexOf( const TYPE& value, int iStart )
     {
         return IndexOf( value, iStart, m_nSize - iStart );
     }
     int     IndexOf( const TYPE& value, int nIndex, int nNumElements );

     int     LastIndexOf( const TYPE& value )
     {
         return ( m_nSize >  ) ? LastIndexOf( value, m_nSize - , m_nSize ) : -;
     }
     int     LastIndexOf( const TYPE& value, int nIndex )
     {
         return LastIndexOf( value, nIndex, nIndex +  );
     }
     int     LastIndexOf( const TYPE& value, int nIndex, int nNumElements );

     HRESULT Remove( int nIndex );
     void    RemoveAll()
     {
         SetSize(  );
     }
     void    Reset()
     {
         m_nSize = ;
     }

 protected:
     TYPE* m_pData;      // the actual array of data
     int m_nSize;        // # of elements (upperBound - 1)
     int m_nMaxSize;     // max allocated

     HRESULT SetSizeInternal( int nNewMaxSize );  // This version doesn't call ctor or dtor.
 };