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():