#pragma once

template

class CDynArray

    {

    private:

     // pointer to internal container

     T *m_pData;

     // number of elements;

     DWORD m_dwSize;

    public:

     CDynArray():m_pData(NULL){};

     CDynArray(DWORD dwNumberofElements)

         {

         m_dwSize = dwNumberofElements;

         m_pData = new T[m_dwSize];

         };

         CDynArray(const CDynArray& DynArray)

             {

             m_dwSize = DynArray.m_dwSize;

             m_pData = new T[m_dwSize];

             for(int i=0;i < m_dwSize;i++)

             *(m_pData + i) = *(DynArray.m_pData+i);

        };

         ~CDynArray()

             {

             delete [] m_pData;

             };

             T& operator [](DWORD nIndex)

                 {

                 if((NULL == m_pData) || (nIndex > m_dwSize))

                     {

                     throw out_of_range("CDynArray::operator[] passed an out of range index");

                     }

                     return *(m_pData + nIndex);

                     };

                     // provides lossless resize for sizes greater than current size

                     bool Resize(DWORD dwNewsize) 

                         {

                         T *pTmp = new T[dwNewsize];

                         if(NULL == pTmp)

                         return false;

                         DWORD dwsize = (m_dwSize > dwNewsize) ? dwNewsize : m_dwSize;

                        for(int i=0;i < dwsize;i++)

                         *(pTmp + i) = *(m_pData+i);

                         delete [] m_pData;

                         m_pData = pTmp;

                         m_dwSize = dwNewsize;

                         return true;

                         };

                    };