一个数组类模板CArray3d
//********************************************
// Array3d.h
// class CArray3d :
//********************************************
// Careful : this array stores pointers
// on elements, but does not free memory
// in destructors, you must call array.Free()
// to do this.
//********************************************
// pierre.alliez@cnet.francetelecom.fr
// Created : 30/01/98
// Modified : 18/02/98
//********************************************
#ifndef _ARRAY_3D_
#define _ARRAY_3D_
template<class T>
class CArray3d
{
// Implementation
private:
T** m_pData; // the actual array of data
int m_nSize; // # of elements (upperBound - 1)
int m_nMaxSize; // max allocated
int m_nGrowBy; // grow amount
public:
// Construction
CArray3d()
{
m_pData = NULL;
m_nSize = 0;
m_nMaxSize = 0;
m_nGrowBy = 0;
}
// Destruction
~CArray3d()
{
delete [] (BYTE*)m_pData;
}
// Attributes
int GetSize() { return m_nSize; }
int GetUpperBound() { return m_nSize-1; }
// Operations
// Really clean up
void Free()
{
for(int i=0;i<m_nSize;i++)
if(m_pData[i] != NULL)
{
delete m_pData[i];
m_pData[i] = NULL;
}
RemoveAll();
}
// Clean up pointers array
void FreeExtra();
// Clean up pointers array
void RemoveAll() { SetSize(0); }
// Accessing elements
T* GetAt(int nIndex)
{
ASSERT(nIndex >= 0 && nIndex < m_nSize);
return m_pData[nIndex];
}
// SetAt
void SetAt(int nIndex, T* newElement)
{
ASSERT(nIndex >= 0 && nIndex < m_nSize);
m_pData[nIndex] = newElement;
}
// Has
int Has(T* pElement)
{
int size = GetSize();
for(int i=0;i<size;i++)
if(GetAt(i) == pElement)
return 1;
return 0;
}
// Direct Access to the element data (may return NULL)
T** GetData() { return m_pData; }
// Add
int Add(T* newElement)
{
int nIndex = m_nSize;
SetAtGrow(nIndex, newElement);
return nIndex;
}
// overloaded operator helpers
T* operator[](int nIndex) { return GetAt(nIndex); }
// Potentially growing the array
void SetAtGrow(int nIndex, T* newElement)
{
ASSERT(nIndex >= 0);
if (nIndex >= m_nSize)
SetSize(nIndex+1);
m_pData[nIndex] = newElement;
}
// Operations that move elements around
void InsertAt(int nIndex, T* newElement, int nCount = 1)
{
ASSERT(nIndex >= 0); // will expand to meet need
ASSERT(nCount > 0); // zero or negative size not allowed
if (nIndex >= m_nSize)
{
// adding after the end of the array
SetSize(nIndex + nCount); // grow so nIndex is valid
}
else
{
// inserting in the middle of the array
int nOldSize = m_nSize;
SetSize(m_nSize + nCount); // grow it to new size
// shift old data up to fill gap
memmove(&m_pData[nIndex+nCount], &m_pData[nIndex],
(nOldSize-nIndex) * sizeof(T*));
// re-init slots we copied from
memset(&m_pData[nIndex], 0, nCount * sizeof(T*));
}
// insert new value in the gap
ASSERT(nIndex + nCount <= m_nSize);
while (nCount--)
m_pData[nIndex++] = newElement;
}
void RemoveAt(int nIndex, int nCount = 1)
{
ASSERT(nIndex >= 0);
ASSERT(nCount >= 0);
ASSERT(nIndex + nCount <= m_nSize);
// just remove a range
int nMoveCount = m_nSize - (nIndex + nCount);
if (nMoveCount)
memcpy(&m_pData[nIndex], &m_pData[nIndex + nCount],
nMoveCount * sizeof(T*));
m_nSize -= nCount;
}
// IndexFrom
int IndexFrom(T* pElement)
{
for(int i=0;i<m_nSize;i++)
if(m_pData[i] == pElement)
return i;
TRACE("IndexFrom : no element\n");
return -1;
}
// SetSize
void SetSize(int nNewSize, int nGrowBy = -1)
{
ASSERT(nNewSize >= 0);
if(nGrowBy != -1)
m_nGrowBy = nGrowBy; // set new size
// shrink to nothing
if(nNewSize == 0)
{
delete[] (BYTE*)m_pData;
m_pData = NULL;
m_nSize = 0;
m_nMaxSize = 0;
}
else
// create one with exact size
if(m_pData == NULL)
{
m_pData = (T**) new BYTE[nNewSize * sizeof(T*)];
memset(m_pData, 0, nNewSize * sizeof(T*)); // zero fill
m_nSize = nNewSize;
m_nMaxSize = nNewSize;
}
else
if(nNewSize <= m_nMaxSize)
{
// it fits
if (nNewSize > m_nSize)
{
// initialize the new elements
memset(&m_pData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(T*));
}
m_nSize = nNewSize;
}
else
{
// otherwise, grow array
int nGrowBy = m_nGrowBy;
if (nGrowBy == 0)
{
// heuristically determine growth when nGrowBy == 0
// (this avoids heap fragmentation in many situations)
nGrowBy = min(1024, max(4, m_nSize / 8));
}
int nNewMax;
if (nNewSize < m_nMaxSize + nGrowBy)
nNewMax = m_nMaxSize + nGrowBy; // granularity
else
nNewMax = nNewSize; // no slush
ASSERT(nNewMax >= m_nMaxSize); // no wrap around
T** pNewData = (T**) new BYTE[nNewMax * sizeof(T*)];
// copy new data from old
memcpy(pNewData, m_pData, m_nSize * sizeof(T*));
// construct remaining elements
ASSERT(nNewSize > m_nSize);
memset(&pNewData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(T*));
// get rid of old stuff (note: no destructors called)
delete[] (BYTE*)m_pData;
m_pData = pNewData;
m_nSize = nNewSize;
m_nMaxSize = nNewMax;
}
}
};
#endif // _ARRAY_3D_
//********************************************
// Array3d.h
//********************************************
// class CArray3d
//********************************************
// pierre.alliez@cnet.francetelecom.fr
// Created : 30/01/98
// Modified : 11/03/98
//********************************************
#include "stdafx.h"
#include "Array3d.h"
//********************************************
// FreeExtra
//********************************************
template<class T>
void CArray3d<T>::FreeExtra()
{
if (m_nSize != m_nMaxSize)
{
// shrink to desired size
#ifdef SIZE_T_MAX
ASSERT(m_nSize <= SIZE_T_MAX/sizeof(T*));
#endif
T** pNewData = NULL;
if (m_nSize != 0)
{
pNewData = (T**) new BYTE[m_nSize * sizeof(T*)];
// copy new data from old
memcpy(pNewData, m_pData, m_nSize * sizeof(T*));
}
// get rid of old stuff (note: no destructors called)
delete[] (BYTE*)m_pData;
m_pData = pNewData;
m_nMaxSize = m_nSize;
}
}
//** EOF **
