CGrowableArray是DXUT實現的一個可自動增長的模板類數組，類似于STL里的vector，該類的實現在DXUTmisc.h里。

首先來看看它的定義部分：

SetSizeInternal() 分析

SetSizeInternal()是protected類型的方法，主要供其他方法內部調用，函數首先檢查nNewMaxSize是否合法，如果nNewMaxSize為0則釋放分配的內存，如果m_pData為NULL或者指定的nNewMaxSize大于原先分配的內存大小m_nMaxSize，則重新分配內存。

// Grow array
int nGrowBy = ( m_nMaxSize == 0 ) ? 16 : m_nMaxSize;  

如果m_nMaxSize為0，意味著沒有為m_nMaxSize指定大小，則將nGrowBy賦值為16，即增加的內存大小為16 * sizeof(TYPE)；若指定了m_nMaxSize，則增加的大小為m_nMaxSize * sizeof(TYPE)，即將分配內存調整為原來的兩倍。

nNewMaxSize = __max( nNewMaxSize, m_nMaxSize + nGrowBy );

#define __max(a,b) (((a) > (b)) ? (a) : (b))

nNewMaxSize在新指定分配內存大小與自動增長的內存m_nMaxSize + nGrowBy 中取一個較大的值。

TYPE* pDataNew = (TYPE*) realloc( m_pData, nNewMaxSize * sizeof(TYPE) );
if( pDataNew == NULL )
        return E_OUTOFMEMORY;

m_pData       = pDataNew;
m_nMaxSize = nNewMaxSize;

pDataNew為指向重新分配內存的指針，m_pData = pDataNew將m_pData指向新分配的內存，m_nMaxSize = nNewMaxSize更新分配后內存的最大尺寸。

函數realloc()的聲明如下：

Reallocate memory blocks.

void *realloc(
   void *memblock,
   size_t size 
);

Parameters

memblock

Pointer to previously allocated memory block.

size

New size in bytes.

Return Value

Remarks

_set_new_mode(1)

Requirements

Example

// crt_realloc.c
// This program allocates a block of memory for buffer and then uses _msize to display the size of that
// block. Next, it uses realloc to expand the amount of memory used by buffer and then calls _msize again to
// display the new amount of memory allocated to buffer. 

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

int main( void )
{
   long *buffer, *oldbuffer;
   size_t size;

   if( (buffer = (long *)malloc( 1000 * sizeof( long ) )) == NULL )
      exit( 1 );

   size = _msize( buffer );
   printf( "Size of block after malloc of 1000 longs: %u\n", size );

   // Reallocate and show new size:
   oldbuffer = buffer;     // save pointer in case realloc fails
   if( (buffer = realloc( buffer, size + (1000 * sizeof( long )) )) 
        ==  NULL )
   {
      free( oldbuffer );  // free original block
      exit( 1 );
   }
   size = _msize( buffer );
   printf( "Size of block after realloc of 1000 more longs: %u\n", 
            size );

   free( buffer );
   exit( 0 );
}

Size of block after malloc of 1000 longs: 4000
Size of block after realloc of 1000 more longs: 8000

SetSize()分析

原代碼：

TYPE* pDataNew = (TYPE*) realloc( m_pData, nNewMaxSize * sizeof(TYPE) );
 if( pDataNew == NULL )
       return E_OUTOFMEMORY;

也就是說當realloc()失敗的時候SetSizeInternal()調用會失敗，這時nOldSize為m_nSize，它不會恒等于nNewMaxSize，于是我將上面的代碼修改為：

    if( nOldSize > nNewMaxSize )
    {
        // Removing elements. Call destructor.
        for( int i = nNewMaxSize; i < nOldSize; ++i )
            m_pData[i].~TYPE();
    }

檢查新指定的內存大小是否小于已分配內存中已賦值元素的個數，如果是則顯式調用各元素的析構函數釋放資源，如下圖所示：

接著調用SetSizeInternal()重新分配大小，失敗則返回：

    // Adjust buffer.  
    HRESULT hr = SetSizeInternal( nNewMaxSize );

    if(FAILED(hr))
        return hr;

如果nNewMaxSize大于nOldSize，則調用構造函數初始化元素的數據，如下圖所示:

    if( nOldSize < nNewMaxSize )
    {
        // Adding elements. Call constructor.
        for( int i = nOldSize; i < nNewMaxSize; ++i )
            ::new (&m_pData[i]) TYPE;
    }

這里對顯式調用構造函數和析構函數做一些說明，之所以顯式調用，是因為new沒有renew，而malloc和calloc有realloc，調用realloc可以避免頻繁調用malloc()和free()【或者new和delete】造成的性能損失，而realloc()不會自動調用構造和析構函數，所以需要顯式調用。

Add()分析：

源碼:

Insert()分析：

#define MoveMemory RtlMoveMemory

#define RtlMoveMemory(Destination,Source,Length) memmove((Destination),(Source),(Length))

接著調用構造函數，賦值，增加m_nSize的大小。

SetAt()：

LastIndexOf():

Remove():