Здравствуйте Idler, Вы писали:
....
SKIPPED

Для таких случаев сделал небольшую резекцию MFC-шному CArray:

template<class TYPE>
class AKVector 
{
public:
    AKVector(long numElements);
    AKVector();
    virtual ~AKVector();
    long GetSize() const;
    void Insert(long nIndex, long nCount = 1);
    void Append(long nCount = 1);
    void Remove(long nIndex, long nCount = 1);
    TYPE& operator[](long nIndex);
private:
    TYPE* m_pData;   // the actual array of data
    long m_nSize;     // # of elements 

};


template<class TYPE>
inline long AKVector<TYPE>::GetSize() const
    { return m_nSize; }


template<class TYPE>
inline TYPE& AKVector<TYPE>::operator[](long nIndex)
    { return m_pData[nIndex]; }



template<class TYPE>
AKVector<TYPE>::AKVector(long numElements )
    {
        m_pData = NULL;
        m_nSize = 0;
    
        Append(numElements);
        return;

    }
template<class TYPE>
AKVector<TYPE>::AKVector()
    {
        m_pData = NULL;
        m_nSize = 0;
        return;

    }

template<class TYPE>
AKVector<TYPE>::~AKVector()
    {
        delete [] m_pData;
        m_nSize = 0;
        return;

    }


template<class TYPE>
void AKVector<TYPE>::Insert(long nIndex, long nCount /* = 1 */)
    {
        ATLASSERT(nIndex < m_nSize);
    
        long nNewSize = m_nSize + nCount;
        TYPE* pNewData =  new TYPE[nNewSize];

        if(nIndex > 0)
            memmove(pNewData, m_pData, nIndex * sizeof(TYPE));

        memmove(&pNewData[nIndex + nCount], &m_pData[nIndex], (m_nSize-nIndex)* sizeof(TYPE));
        
        delete [] m_pData;

        m_nSize = nNewSize;
        m_pData = pNewData;

    }

template<class TYPE>
void AKVector<TYPE>::Append(long nCount /* = 1 */)
    {
        long nNewSize = m_nSize + nCount;
        
        TYPE* pNewData =  new TYPE[nNewSize];

        if(m_nSize > 0){
            memmove(pNewData, m_pData, m_nSize * sizeof(TYPE));
            delete [] m_pData;
        }

        m_nSize = nNewSize;

        m_pData = pNewData;

    }


template<class TYPE>
void AKVector<TYPE>::Remove(long nIndex, long nCount /* = 1 */)
    {
        ATLASSERT(nIndex >= 0);
        ATLASSERT(nCount >= 0);
    
        ATLASSERT(nIndex + nCount <= m_nSize);
    
        long nNewSize = m_nSize - nCount;

        TYPE* pNewData;

        if(nNewSize > 0)
            pNewData =  new TYPE[nNewSize];
        else
            pNewData = NULL;

        if(nIndex > 0)
            memmove(pNewData, m_pData, nIndex * sizeof(TYPE));

        if(nIndex < nNewSize)
            memmove(&pNewData[nIndex ], &m_pData[nIndex + nCount], (m_nSize-nIndex-nCount)* sizeof(TYPE));

        delete [] m_pData;

        m_nSize = nNewSize;
        m_pData = pNewData;

    }

получился облегченный динамический Array. С его помощью, кстати, можно делать и двумерные массивы:

    typedef AKVector <TCHAR*> vecClipRows;
    AKVector <vecClipRows> ClipArray;
        ClipArray.Append(NUMROWS);
        for (int i = 0; i< NUMROWS;i++){
              ClipArray[i].Append(NUMCOLS);
              for(int j = 0; j<NUMCOLS;j++){
                    ClipArray[i][j] = new TCHAR [nTextLen];
              }
        }

причем количество столбцов в каждой строке может быть разным.

перед выходом из области видимости ClipArray нужно удалить все элементы (delete ClipArray [i][j] в цикле)