#ifndef ARRAY_HEAD_FILE
#define ARRAY_HEAD_FILE


#pragma once


//


//數(shù)組模板類
template <class TYPE, class ARG_TYPE=const TYPE &> class CWHArray
{
//變量定義
protected:
TYPE * m_pData; //數(shù)組指針
INT_PTR m_nMaxCount; //緩沖數(shù)目
INT_PTR m_nGrowCount; //增長(zhǎng)數(shù)目
INT_PTR m_nElementCount; //元素?cái)?shù)目


//函數(shù)定義
public:
//構(gòu)造函數(shù)
CWHArray();
//析構(gòu)函數(shù)
virtual ~CWHArray();


//信息函數(shù)
public:
//是否空組
bool IsEmpty() const;
//獲取數(shù)目
INT_PTR GetCount() const;


//功能函數(shù)
public:
//獲取緩沖
TYPE * GetData();
//獲取緩沖
const TYPE * GetData() const;
//增加元素
INT_PTR Add(ARG_TYPE newElement);
//拷貝數(shù)組
VOID Copy(const CWHArray & Src);
//追加數(shù)組
INT_PTR Append(const CWHArray & Src);
//獲取元素
TYPE & GetAt(INT_PTR nIndex);
//獲取元素
const TYPE & GetAt(INT_PTR nIndex) const;
//獲取元素
TYPE & ElementAt(INT_PTR nIndex);
//獲取元素
const TYPE & ElementAt(INT_PTR nIndex) const;


//操作函數(shù)
public:
//設(shè)置大小
VOID SetSize(INT_PTR nNewSize);
//設(shè)置元素
VOID SetAt(INT_PTR nIndex, ARG_TYPE newElement);
//設(shè)置元素
VOID SetAtGrow(INT_PTR nIndex, ARG_TYPE newElement);
//插入數(shù)據(jù)
VOID InsertAt(INT_PTR nIndex, const CWHArray & Src);
//插入數(shù)據(jù)
VOID InsertAt(INT_PTR nIndex, ARG_TYPE newElement, INT_PTR nCount=1);
//刪除數(shù)據(jù)
VOID RemoveAt(INT_PTR nIndex, INT_PTR nCount=1);
//刪除元素
VOID RemoveAll();


//操作重載
public:
//操作重載
TYPE & operator[](INT_PTR nIndex);
//操作重載
const TYPE & operator[](INT_PTR nIndex) const;


//內(nèi)存函數(shù)
public:
//釋放內(nèi)存
VOID FreeMemory();
//申請(qǐng)內(nèi)存
VOID AllocMemory(INT_PTR nNewCount);
};


//
// CWHArray<TYPE, ARG_TYPE> 內(nèi)聯(lián)函數(shù)


//是否空組
template<class TYPE, class ARG_TYPE>?
AFX_INLINE bool CWHArray<TYPE, ARG_TYPE>::IsEmpty() const
{
return (m_nElementCount==0);
}


//獲取數(shù)目
template<class TYPE, class ARG_TYPE>
AFX_INLINE INT_PTR CWHArray<TYPE, ARG_TYPE>::GetCount() const
{
return m_nElementCount;
}


//增加元素
template<class TYPE, class ARG_TYPE>
AFX_INLINE INT_PTR CWHArray<TYPE,ARG_TYPE>::Add(ARG_TYPE newElement)
{
INT_PTR nIndex=m_nElementCount;
SetAtGrow(nIndex,newElement);
return nIndex;
}


//操作重載
template<class TYPE, class ARG_TYPE>
AFX_INLINE TYPE & CWHArray<TYPE, ARG_TYPE>::operator[](INT_PTR nIndex)
{?
return ElementAt(nIndex);
}


//操作重載
template<class TYPE, class ARG_TYPE>
AFX_INLINE const TYPE & CWHArray<TYPE, ARG_TYPE>::operator[](INT_PTR nIndex) const
{?
return GetAt(nIndex);
}


//
// CWHArray<TYPE, ARG_TYPE> 外聯(lián)函數(shù)


//構(gòu)造函數(shù)
template<class TYPE, class ARG_TYPE>?
CWHArray<TYPE, ARG_TYPE>::CWHArray()
{
m_pData=NULL;
m_nMaxCount=0;
m_nGrowCount=0;
m_nElementCount=0;


return;
}


//構(gòu)造函數(shù)
template<class TYPE, class ARG_TYPE>?
CWHArray<TYPE,ARG_TYPE>::~CWHArray()
{
if (m_pData!=NULL)
{
for (INT_PTR i=0;i<m_nElementCount;i++) (m_pData+i)->~TYPE();
delete [] (BYTE *)m_pData;
m_pData=NULL;
}


return;
}


//獲取緩沖
template<class TYPE, class ARG_TYPE>?
TYPE * CWHArray<TYPE,ARG_TYPE>::GetData()
{
return m_pData;
}


//獲取緩沖
template<class TYPE, class ARG_TYPE>?
const TYPE * CWHArray<TYPE,ARG_TYPE>::GetData() const
{
return m_pData;
}


//拷貝數(shù)組
template<class TYPE, class ARG_TYPE>?
VOID CWHArray<TYPE,ARG_TYPE>::Copy(const CWHArray & Src)
{
//效驗(yàn)參數(shù)
ASSERT(this!=&Src);
if (this==&Src) return;


//拷貝數(shù)組
AllocMemory(Src.m_nElementCount);
if (m_nElementCount>0)
{
for (INT_PTR i=0;i<m_nElementCount;i++) (m_pData+i)->~TYPE();
memset(m_pData,0,m_nElementCount*sizeof(TYPE));
}
for (INT_PTR i=0;i<Src.m_nElementCount;i++) m_pData[i]=Src.m_pData[i];
m_nElementCount=Src.m_nElementCount;


return;
}


//追加數(shù)組
template<class TYPE, class ARG_TYPE>?
INT_PTR CWHArray<TYPE,ARG_TYPE>::Append(const CWHArray & Src)
{
//效驗(yàn)參數(shù)
ASSERT(this!=&Src);
if (this==&Src) AfxThrowInvalidArgException();


//拷貝數(shù)組
if (Src.m_nElementCount>0)
{
INT_PTR nOldCount=m_nElementCount;
AllocMemory(m_nElementCount+Src.m_nElementCount);
for (INT_PTR i=0;i<Src.m_nElementCount;i++) m_pData[m_nElementCount+i]=Src.m_pData[i];
m_nElementCount+=Src.m_nElementCount;
}


return m_nElementCount;
}


//獲取元素
template<class TYPE, class ARG_TYPE>?
TYPE & CWHArray<TYPE,ARG_TYPE>::GetAt(INT_PTR nIndex)
{
ASSERT((nIndex>=0)&&(nIndex<m_nElementCount));
if ((nIndex<0)||(nIndex>=m_nElementCount)) AfxThrowInvalidArgException();

return m_pData[nIndex];
}


//獲取元素
template<class TYPE, class ARG_TYPE>?
const TYPE & CWHArray<TYPE,ARG_TYPE>::GetAt(INT_PTR nIndex) const
{
ASSERT((nIndex>=0)&&(nIndex<m_nElementCount));
if ((nIndex<0)||(nIndex>=m_nElementCount)) AfxThrowInvalidArgException();

return m_pData[nIndex];
}


//獲取元素
template<class TYPE, class ARG_TYPE>?
TYPE & CWHArray<TYPE,ARG_TYPE>::ElementAt(INT_PTR nIndex)
{
ASSERT((nIndex>=0)&&(nIndex<m_nElementCount));
if ((nIndex<0)&&(nIndex>=m_nElementCount)) AfxThrowInvalidArgException();

return m_pData[nIndex];
}


//獲取元素
template<class TYPE, class ARG_TYPE>?
const TYPE & CWHArray<TYPE,ARG_TYPE>::ElementAt(INT_PTR nIndex) const
{
ASSERT((nIndex>=0)&&(nIndex<m_nElementCount));
if ((nIndex<0)&&(nIndex>=m_nElementCount)) AfxThrowInvalidArgException();


return m_pData[nIndex];
}


//設(shè)置大小
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::SetSize(INT_PTR nNewSize)
{
//效驗(yàn)參數(shù)
ASSERT(nNewSize>=0);
if (nNewSize<0) AfxThrowInvalidArgException();

//設(shè)置大小
AllocMemory(nNewSize);
if (nNewSize>m_nElementCount)
{
for (INT_PTR i=m_nElementCount;i<nNewSize;i++) new ((VOID *)(m_pData+i)) TYPE;
}
else if (nNewSize<m_nElementCount)
{
for (INT_PTR i=nNewSize;i<m_nElementCount;i++) (m_pData+i)->~TYPE();
memset(m_pData+nNewSize,0,(m_nElementCount-nNewSize)*sizeof(TYPE));
}
m_nElementCount=nNewSize;


return;
}


//設(shè)置元素
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::SetAt(INT_PTR nIndex, ARG_TYPE newElement)
{
ASSERT((nIndex>=0)&&(nIndex<m_nElementCount));
if ((nIndex>=0)&&(nIndex<m_nElementCount)) m_pData[nIndex]=newElement;
else AfxThrowInvalidArgException();


return;
}


//設(shè)置元素
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::SetAtGrow(INT_PTR nIndex, ARG_TYPE newElement)
{
//效驗(yàn)參數(shù)
ASSERT(nIndex>=0);
if (nIndex<0) AfxThrowInvalidArgException();


//設(shè)置元素
if (nIndex>=m_nElementCount) SetSize(m_nElementCount+1);
m_pData[nIndex]=newElement;


return;
}


//插入數(shù)據(jù)
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::InsertAt(INT_PTR nIndex, const CWHArray & Src)
{
//效驗(yàn)參數(shù)
ASSERT(nStartIndex>=0);
if (nStartIndex<0) AfxThrowInvalidArgException();


if (Src.m_nElementCount>0)
{
//申請(qǐng)數(shù)組
if (nIndex<m_nElementCount)
{
INT_PTR nOldCount=m_nElementCount;
SetSize(m_nElementCount+Src.m_nElementCount);
for (INT_PTR i=0;i<nCount;i++) (m_pData+nOldCount+i)->~TYPE();
memmove(m_pData+nIndex+nCount,m_pData+nIndex,(nOldCount-nIndex)*sizeof(TYPE));
memset(m_pData+nIndex,0,Src.m_nElementCount*sizeof(TYPE));
for (INT_PTR i=0;i<Src.m_nElementCount;i++) new (m_pData+nIndex+i) TYPE();
}
else SetSize(nIndex+nCount);


//拷貝數(shù)組
ASSERT((nIndex+Src.m_nElementCount)<=m_nElementCount);
while (nCount--) m_pData[nIndex++]=newElement;
}


return;
}


//插入數(shù)據(jù)
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::InsertAt(INT_PTR nIndex, ARG_TYPE newElement, INT_PTR nCount)
{
//效驗(yàn)參數(shù)
ASSERT(nIndex>=0);
ASSERT(nCount>0);
if ((nIndex<0)||(nCount<=0)) AfxThrowInvalidArgException();


//申請(qǐng)數(shù)組
if (nIndex<m_nElementCount)
{
INT_PTR nOldCount=m_nElementCount;
SetSize(m_nElementCount+nCount);
for (INT_PTR i=0;i<nCount;i++) (m_pData+nOldCount+i)->~TYPE();
memmove(m_pData+nIndex+nCount,m_pData+nIndex,(nOldCount-nIndex)*sizeof(TYPE));
memset(m_pData+nIndex,0,nCount*sizeof(TYPE));
for (INT_PTR i=0;i<nCount;i++) new (m_pData+nIndex+i) TYPE();
}
else SetSize(nIndex+nCount);


//拷貝數(shù)組
ASSERT((nIndex+nCount)<=m_nElementCount);
while (nCount--) m_pData[nIndex++]=newElement;


return;
}


//刪除數(shù)據(jù)
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::RemoveAt(INT_PTR nIndex, INT_PTR nCount)
{
//效驗(yàn)參數(shù)
ASSERT(nIndex>=0);
ASSERT(nCount>=0);
ASSERT(nIndex+nCount<=m_nElementCount);
if ((nIndex<0)||(nCount<0)||((nIndex+nCount>m_nElementCount))) AfxThrowInvalidArgException();


//刪除數(shù)據(jù)
INT_PTR nMoveCount=m_nElementCount-(nIndex+nCount);
for (INT_PTR i=0;i<nCount;i++) (m_pData+nIndex+i)->~TYPE();
if (nMoveCount>0) memmove(m_pData+nIndex,m_pData+nIndex+nCount,nMoveCount*sizeof(TYPE));
m_nElementCount-=nCount;


return;
}


//刪除元素
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::RemoveAll()
{
if (m_nElementCount>0)
{
for (INT_PTR i=0;i<m_nElementCount;i++) (m_pData+i)->~TYPE();
memset(m_pData,0,m_nElementCount*sizeof(TYPE));
m_nElementCount=0;
}


return;
}


//釋放內(nèi)存
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::FreeMemory()
{
if (m_nElementCount!=m_nMaxCount)
{
TYPE * pNewData=NULL;
if (m_nElementCount!=0)
{
pNewData=(TYPE *) new BYTE[m_nElementCount*sizeof(TYPE)];
memcpy(pNewData,m_pData,m_nElementCount*sizeof(TYPE));
}
delete [] (BYTE *)m_pData;
m_pData=pNewData;
m_nMaxCount=m_nElementCount;
}


return;
}


//申請(qǐng)內(nèi)存
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::AllocMemory(INT_PTR nNewCount)
{
//效驗(yàn)參數(shù)
ASSERT(nNewCount>=0);


if (nNewCount>m_nMaxCount)
{
//計(jì)算數(shù)目
INT_PTR nGrowCount=m_nGrowCount;
if (nGrowCount==0)
{
nGrowCount=m_nElementCount/8;
nGrowCount=(nGrowCount<4)?4:((nGrowCount>1024)?1024:nGrowCount);
}
nNewCount+=nGrowCount;


//申請(qǐng)內(nèi)存
TYPE * pNewData=(TYPE *) new BYTE[nNewCount*sizeof(TYPE)];
memcpy(pNewData,m_pData,m_nElementCount*sizeof(TYPE));
memset(pNewData+m_nElementCount,0,(nNewCount-m_nElementCount)*sizeof(TYPE));
delete [] (BYTE *)m_pData;


//設(shè)置變量
m_pData=pNewData;
m_nMaxCount=nNewCount;
}


return;
}


//


#endif

總結(jié)

以上是生活随笔為你收集整理的网狐动态数组CWHArray的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。