CArray 用法

　　CArray的用法

　　templateclassCArray:public CObject

　　参数

　　TYPE

　　模板参数指定存储在数组中的对象的类型。TYPE是一个由CArray返回的参数。ARG_TYPE

　　模板参数指定用于访问存储在数组中对象的参数类型。通常是一个对TYPE的参考。ARG_TYPE是一个传递给CArray的参数。

　　说明

　　CArray类支持与CArray相似的数组，但是必要时可以动态压缩并扩展。数组索引从0开始。可以决定是固定数组上界还是允许当添加元素时扩展当前的边界。内存对上界是连续地分配空间，甚至一些元素可为空。和CArray一样，CArray索引元素的访问时间是不变的，与数组大小无关。

　　需要包含的头文件

　　CArray类支持与C arrays相似的数组，但是必要时可以动态压缩并扩展。数组索引从0开始。可以决定是固定数组上界还是允许当添加元素时扩展当前的边界。内存对上界是连续地分配空间，甚至一些元素可为空。

　　和CArray一样，CArray索引元素的访问时间是不变的，与数组大小无关。

　　提示：

　　在使用一个数组之前，使用SetSize建立它的大小和为它分配内存。如果不使用SetSize，则为数组添加元素就会引起频繁地重新分配和拷贝。频繁地重新分配和拷贝不但没有效率，而且导致内存碎片。

　　如果需要一堆数组中的个别数据，必须设置CDumpContext对象的深度为1或更大。

　　此类的某成员函数调用全局帮助函数，它必须为CArray的大多数使用而定制。请参阅宏和全局量部分中的“类收集帮助器”。

　　当从一个CArray对象中移去元素时，帮助函数DestructElements被调用。

　　当添加元素时，帮助函数ConstructElements被调用。

　　数组类的派生与列表的派生相似。

　　MFC提供了一套模板库，来实现一些比较常见的数据结构如Array,List,Map。CArray即为其中的一个，用来实现动态数组的功能。CArray是从CObject派生,有两个模板参数，第一个参数就是CArray类数组元素的变量类型，后一个是函数调用时的参数类型。有一个类class Object，要定义一个Object的动态数组，那么可以用以下两种方法：

　　CArray Var1;

　　CArray Var2;

　　Var2的效率要高。

　　ClassHelpers

　　CArray类的成员

　　构造函数

　　Carray构造一个空数组

　　属性

　　GetSize获得此数组中的元素数

　　GetUpperBound返回最大的有效索引值

　　SetSize设置包含在此数组中的元素数

　　操作

　　FreeExtra释放大于当前上界的未使用的内存

　　RemoveAll从此数组移去所有元素

　　元素访问

　　GetAt返回在给定索引上的值

　　SetAt设定一个给定索引的值；数组不允许扩展

　　ElementAt返回一个对数组中元素指针的临时参考

　　GetData允许对数组中的元素访问。可以为NULL

　　扩展数组

　　SetAtGrow为一个给定索引设置值；如果必要，扩展数组

　　Add在数组的末尾添加元素；如果必要，扩展数组

　　Append在数组上附加另一个数组；如果必要，扩展数组

　　Copy把另一个数组拷贝到数组上；如果必要，扩展数组

　　插入/移去

　　InsertAt在指定的索引上插入一个元素（或另一个数组中的所有元素）

　　RemoveAt在指定的索引上移去一个元素

　　运算符

　　[ ]在特定索引上设置或获取元素

　　成员函数

　　CArray::Add

　　int Add(ARG_TYPE newElement);

　　throw(CmemoryException);

　　返回值

　　添加元素的索引。

　　参数

　　ARG_TYPE

　　模板参数指定应用数组中元素的参数的类型。

　　newElement

　　被加入此数组的元素。

　　说明

　　在数组的末尾加入一个新的元素，数组长度加1。如果SetSize已经使用nGrowBy值比1大，则内存按其分配。无论怎样，上界只增长1。

　　示例

　　//example for CArray:Add

　　CArray ptArray;

　　Cpoint pt(10.20);

　　ptArray.Add(pt);

　　//Element 0

　　ptArray.Add(Cpoint(30,40));

　　//Element 1

　　CArray::Append

　　int Append(const CArray& src);

　　返回值

　　第一个附加元素的索引。

　　参数

　　src附加到数组的元素的源。

　　说明

　　调用此成员函数将一个数组的内容附加到另一个数组的末尾。数组必须是同一种类型。如果必要，Append将分配更多的内存来存储附加到数组上的元素。

　　请参阅   CArray::Copy

　　CArray::CArray

　　CArray( );

　　返回值

　　构造一个空数组。数组一次扩展一个元素。

　　请参阅   CObArray::CObArray

　　CArray::Copy

　　void Copy(const CArray& src);

　　参数

　　Src被拷贝到数组中的元素的源。

　　说明

　　使用此成员函数将一个数组的元素拷贝到另一个数组中。调用此成员函数用另一个数组的元素复写数组的元素。Copy不会释放内存；但是，如果必要，Copy可以为拷贝到数组的元素分配更多的内存。请参阅   CArray::Append

　　CArray::Element

　　TYPE&ElementAt(int nIndex);

　　返回值

　　数组元素的参考。

　　参数

　　TYPE指定数组元素类型的模板参数。

　　nIndex比0大或比0小的整数索引，并且小于或等于由GetUpperBound返回的值。

　　说明

　　返回一个对数组中指定元素的临时参考。它用于实现数组的左边界分配运算符。

　　请参阅   CArray::operator[]

　　CArray::FreeExtra

　　void FreeExtra( );

　　说明

　　释放任何当数组扩展时所分配的额外的内存空间。此函数不影响数组的大小和上界。

　　CArray::GetAt

　　TYPE GetAt(int nIndex) const;

　　返回值

　　当前在索引上的数组元素。

　　参数

　　TYPE指定数组元素类型的模板参数。

　　nIndex比0大或比0小的整数索引，并且小于或等于由GetUpperBound返回的值。

　　说明

　　返回特定索引的数组元素。注意   传递一个负值或一个比由GetUpperBound返回值大的值将会引起失败。

　　请参阅  CArray::SetAt,CArray::operator[],ConstElements

　　CArray::GetData

　　const TYPE* GetData( ) const;TYPE* GetData( );

　　返回值

　　指向数组元素的指针。

　　参数

　　TYPE指定数组元素类型的模板参数

　　说明

　　使用此成员函数，获得对数组中元素的直接访问。如果没有元素是有效的，GetData返回一个空值。当对数组元素的直接访问可使工作更快时，当调用GetData时请使用警告，任何直接引起的错误都会影响数组元素。

　　请参阅  CArray::GetAt;CArray::SetAt;CArray::ElementAt

　　CArray::GetSizeint GetSize( ) const;

　　说明

　　返回数组的大小。既然索引基于0，所以数组的大小比最大的索引多1。

　　请参阅  CArray::GetUpperBound,CArray::SetSize

　　CArray::GetUpperBound

　　int GetUpperBound( ) const;

　　说明

　　返回数组的上界。因为数组索引基于0，此函数返回值比GetbSize小1。GetUpperBound=-1的条件确定了数组中没有包含元素。

　　请参阅  CArray::GetSize,CArray::SetSize

　　CArray::InsertAt

　　void InsertAt(int nIndex,ARG_TYPE newElement,intnCount=1);

　　throw(CmemoryException);

　　void InsertAt(int nStarIndex,CArray*pNewArray);

　　throw(CMemoryException);

　　参数

　　nIndex整数值，它可以比GetUpperBound返回值大。

　　ARG_TYPE指定数组元素类型的模板参数。

　　newElement要被放置到数组中的元素。

　　nCount此元素应被插入的次数（缺省为1）。

　　nStarIndex整数索引，它可以比GetUpperBound返回值大。

　　pNewArray要被加入此数组的另一个包含元素的数组。

　　说明

　　InsertAt的第一个版本在数组的特定索引上插入一个元素（或元素的多个拷贝）。在此过程中，移动（通过索引值的增加）此索引上原有的元素，并且移动所有在其后的元素。第二个版本由另一个CArray收集插入所有元素，从nStartIndex位置开始。SetAt函数替换一个特定数组元素，不移动任何元素。

　　示例

　　//example for CArray::Insert

　　CArray ptArray;

　　ptArray.Add(Cpoint(10,20));                   //Element 0

　　ptArray.Add(Cpoint(30,40));                   //Element 1(will becomeelement 2)

　　ptArray.InsertAt(1,Cpoint(50,60));              //New element 1

　　请参阅  GetUpperBound,CArray::SetAt,CArray::RemoveAt

　　CArray::RemoveAll

　　void RemoveAll( );

　　说明

　　从此数组中移去所有元素。如果数组已经为空，此函数也起作用。

　　CArray::RemoveAt

　　void RemoveAt(int nIndex,int nCount=1);

　　参数

　　nIndex整数索引。它大于或等于0并且小于或等于GetUpperBound返回值。

　　nCount删除元素的数量。

　　说明

　　从数组指定的索引起删除一个或多个元素。在这个过程中，它将所有的元素向下移动。它减少数组的上界值，但是不释放内存。如果试图删除包含在数组中在删除点之上的多个元素，则使用库断言的调试版本。

　　CArray::SetAt

　　void SetAt(int nIndex,ARG_TYPE newElement);

　　参数

　　nIndex整数索引。它大于或等于0并且小于或等于GetUpperBound返回值。

　　ARG_TYPE指定用于参考数组元素的参数类型的模板参数。

　　newElement被存储在指定位置的新的元素值。

　　说明

　　在指定的索引设置数组元素。SetAt将不会引起数组增长。如果想让数组自动增长，请使用SetAtGrow。必须保证索引值表示的是一个数组中的有效位置。如果它超出了边界，则使用库断言的调试版本。

　　请参阅  CArray::GetAt,CArray::SetGrow,CArray::ElementAt,CArray::opertor[]

　　CArray::SetAtGrow

　　void SetAtGrow(int nIndex,ARG_TYPE newElement);

　　throw(CMemoryException);

　　参数

　　nIndex整数索引。它大于或等于0。

　　ARG_TYPE指定数组元素类型的模板参数。

　　newElement被添加在此数组的元素值。允许空值。

　　说明

　　在指定的索引上设置数组元素。如果必要，数组自动增长（调整上界以接纳新元素）。

　　示例

　　//example for CArray::SetAtGrow

　　CArray ptArray;

　　ptArray.Add(CPoint(10,20));       //Element 0

　　       ptArray.Add(CPoint(30,40));       //Element 1  

//Element 2 deliberately skipped　 

　         ptArray.SetAtGrow(3,CPoint(50,60));//Element 3

　　请参阅  CArray::GetAt,CArray::SetAt,CArray::Element,CArray::oprator[]

　　CArray::SetSize

　　void SetSize(int nNewSize,int nGrowBy=－1);

　　throw(CMemoryException);

　　参数

　　nNewSize新的数组大小（元素的个数）。必须大于或等于0。

　　nGrowBy如果有必要扩展数组大小时，这是要分配的元素位置的最小值。

　　说明

　　建立一个空的或已存在数组的大小；如果必要，则分配内存。如果新的大小比以前的大小的话，则数组被截短并且所有未使用的内存被释放。在开始使用数组之前，使用此函数设置数组的大小。如果没有使用SetSize，则为数组添加元素就会引起频繁地重分配和拷贝。频繁地重分配和拷贝不仅无效率，而且会造成内存碎片。当数组正在扩张时，nGrowBy参数会影响内部地内存分配。正象GetSize和GetUpperBound提到地那样，它的使用不会数组大小。如果使用缺省值，则MFC分配内存会使用计算方法，避免内存碎片并加已优化，使之对大多数的情况都更有效率。

　　请参阅  CArray::GetUpperBound,CArray::GetSize

　　操作符

　　CArray::opertor[]

　　TYPE& operator[](int nIndex);

　　TYPE& operator[](int nIndex) const;

　　参数

　　TYPE指定此数组中元素的类型的模板参数。

　　nIndex被访问的元素的索引。

　　说明

　　这些下标运算符可方便地取代SetAt和GetAt函数。第一个运算符，不是常量的数组调用它，可以用在赋值语句的右（右值）或左（左值）边。第二个，为常量数组调用，只能用在赋值语句的右边。如果下标（一个赋值语句的左或右边）超出了边界，则使用库断言的调试版本。

请参阅  CArray::GetAt;CArray::SetAt;CArray::ElementAt

 

　　CArray类成员变量的初始化

　　先了解一下CArray中的成员变量及作用。TYPE* m_pData; // 数据保存地址的指针

　　int m_nSize; // 用户当前定义的数组的大小

　　int m_nMaxSize; // 当前实际分配的数组的大小

　　int m_nGrowBy; // 分配内存时增长的元素个数

　　构造函数,对成员变量进行了初始化。

　　CArray::CArray()

　　{

　　m_pData = NULL;

　　m_nSize = m_nMaxSize = m_nGrowBy = 0;

　　}

　　SetSize成员函数是用来为数组分配空间的。SetSize的函数定义如下：

　　void SetSize( int nNewSize, int nGrowBy = -1 );

　　nNewSize 指定数组的大小

　　nGrowBy 如果需要增加数组大小时增加的元素的个数。

　　对SetSize的代码，进行分析。

　　void CArray::SetSize(intnNewSize, int nGrowBy)

　　{

　　if (nNewSize == 0)

　　{

　　// 第一种情况

　　// 当nNewSize为0时,需要将数组置为空,

　　// 如果数组本身即为空,则不需做任何处理

　　// 如果数组本身已含有数据,则需要清除数组元素

　　if (m_pData != NULL)

　　{

　　//DestructElements 函数实现了对数组元素析构函数的调用

　　//不能使用delete m_pData 因为我们必须要调用数组元素的析构函数

　　DestructElements(m_pData, m_nSize);

　　//现在才能释放内存

　　delete[] (BYTE*)m_pData;

　　m_pData = NULL;

　　}

　　m_nSize = m_nMaxSize = 0;

　　}

　　else if (m_pData == NULL)

　　{

　　// 第二种情况

　　// 当m_pData==NULL时还没有为数组分配内存

　　//首先我们要为数组分配内存，sizeof(TYPE)可以得到数组元素所需的字节数

　　//使用new 数组分配了内存。注意，没有调用构造函数

　　m_pData = (TYPE*) new BYTE[nNewSize *sizeof(TYPE)];

　　//下面的函数调用数组元素的构造函数

　　ConstructElements(m_pData, nNewSize);

　　//记录下当前数组元素的个数

　　m_nSize = m_nMaxSize = nNewSize;

　　}

　　else if (nNewSize <= m_nMaxSize)

　　{

　　// 第三种情况

　　// 这种情况需要分配的元素个数比已经实际已经分配的元素个数要少

　　if (nNewSize > m_nSize)

　　{

　　// 需要增加元素的情况

　　// 与第二种情况的处理过程，既然元素空间已经分配，

　　// 只要调用新增元素的构造函数就Ok

　　ConstructElements(&m_pData[m_nSize],nNewSize-m_nSize);

　　}

　　else if (m_nSize > nNewSize)

　　{

　　// 现在是元素减少的情况，我们是否要重新分配内存呢?

　　// No,这种做法不好，后面来讨论。

　　// 下面代码释放多余的元素,不是释放内存，只是调用析构函数

　　DestructElements(&m_pData[nNewSize],m_nSize-nNewSize);

　　}

　　m_nSize = nNewSize;

　　}

　　else

　　{

　　//这是最糟糕的情况，因为需要的元素大于m_nMaxSize，

　　// 意味着需要重新分配内存才能解决问题

　　// 计算需要分配的数组元素的个数

　　int nNewMax;

　　if (nNewSize < m_nMaxSize + nGrowBy)

　　nNewMax = m_nMaxSize + nGrowBy;

　　else

　　nNewMax = nNewSize;

　　// 重新分配一块内存

　　TYPE* pNewData = (TYPE*) new BYTE[nNewMax * sizeof(TYPE)];

　　//实现将已有的数据复制到新的的内存空间

　　memcpy(pNewData, m_pData, m_nSize * sizeof(TYPE));

　　// 对新增的元素调用构造函数

　　ConstructElements(&pNewData[m_nSize],nNewSize-m_nSize);

　　//释放内存

　　delete[] (BYTE*)m_pData;

　　//将数据保存

　　m_pData = pNewData;

　　m_nSize = nNewSize;

　　m_nMaxSize = nNewMax;

　　}

　　}

　　下面是ConstructElements函数的实现代码template

　　AFX_INLINE void AFXAPI ConstructElements(TYPE* pElements, int nCount)

　　{

　　// first do bit-wise zero initialization

　　memset((void*)pElements, 0, nCount * sizeof(TYPE));

　　for (; nCount--; pElements++)

　　::new((void*)pElements) TYPE;

　　}

　　ConstructElements是一个模板函数。对构造函数的调用是通过标为黑体的代码实现的。可能很多人不熟悉new 的这种用法，它可以实现指定的内存空间中构造类的实例，不会再分配新的内存空间。类的实例产生在已经分配的内存中，并且new操作会调用对象的构造函数。因为vc中没有办法直接调用构造函数，而通过这种方法，巧妙的实现对构造函数的调用。

　　再来看DestructElements 函数的代码template

　　AFX_INLINE void AFXAPI DestructElements(TYPE* pElements, int nCount)

　　{

　　for (; nCount--; pElements++)

　　pElements->~TYPE();

　　}

　　DestructElements函数同样是一个模板函数，实现很简单，直接调用类的析构函数即可。

　　如果定义一个CArray对象 CArray myObject ，对myObject就可象数组一样，通过下标来访问指定的数组元素。

　　CArray[]有两种实现，区别在于返回值不同。

　　template

　　AFX_INLINE TYPE CArray::operator[](int nIndex) const

　　{ return GetAt(nIndex); }

　　template

　　AFX_INLINE TYPE& CArray::operator[](int nIndex)

　　{ return ElementAt(nIndex); }

　　前一种情况是返回的对象的实例，后一种情况是返回对象的引用。分别调用不同的成员函数来实现。

　　TYPE GetAt(int nIndex) const

　　{ ASSERT(nIndex >= 0 && nIndex < m_nSize);

　　return m_pData[nIndex]; }

　　TYPE& ElementAt(int nIndex)

　　{ ASSERT(nIndex >= 0 && nIndex

　　return m_pData[nIndex]; }

　　除了返回值不同，其它都一样.

　　CArray arrInt;

　　arrInt.SetSize(10);

　　int n = arrInt.GetAt(0);

　　int& l = arrInt.ElementAt(0);

　　cout << arrInt[0] <

　　n = 10;

　　cout << arrInt[0] <

　　l = 20;

　　count << arrInt[0] << endl;

　　结果会发现，n的变化不会影响到数组，而l的变化会改变数组元素的值。实际即是对C++中引用运算符的运用。

　　CArray下标访问是非安全的，它并没有超标预警功能。虽然使用ASSERT提示，但下标超范围时没有进行处理，会引起非法内存访问的错误。

　　Add函数的作用是向数组添加一个元素。下面是它的定义： int CArray::Add(ARG_TYPE newElement).Add函数使用的参数是模板参数的二个参数，也就是说，这个参数的类型是我们来决定的，可以使用Object或Object&的方式。熟悉C++的朋友都知道，传引用的效率要高一些。如果是传值的话，会在堆栈中再产生一个新的对象，需要花费更多的时间。

　　template

　　AFX_INLINE int CArray::Add(ARG_TYPEnewElement)

　　{

　　int nIndex = m_nSize;

　　SetAtGrow(nIndex, newElement);

　　return nIndex;

　　}

　　它实际是通过SetAtGrow函数来完成这个功能的，它的作用是设置指定元素的值。

　　template

　　void CArray::SetAtGrow(intnIndex, ARG_TYPE newElement)

　　{

　　if (nIndex >= m_nSize)

　　SetSize(nIndex+1, -1);

　　m_pData[nIndex] = newElement;

　　}

　　SetAtGrow的实现也很简单，如果指定的元素已经存在，就把改变指定元素的值。如果指定的元素不存在，也就是nIndex>=m_nSize的情况，就调用SetSize来调整数组的大小

　　首先定义

　　CArray arryPChar;

　　这里以定义char*的为例子。

　　接下来我们来熟悉CArray这个类里的函数。

　　INT_PTR GetCount() const;

　　获得当前这个数组有多少个元素。

　　void SetSize(INT_PTR nNewSize, INT_PTR nGrowBy = -1);

　　设置数组的大小。

　　TYPE& GetAt(INT_PTR nIndex);

　　void SetAt(INT_PTR nIndex, ARG_TYPE newElement);

　　获得/设置序列的元素

　　INT_PTR Add(ARG_TYPE newElement);

　　在数组的末尾添加一个元素，数组的长度加1。如果之前使用SetSize是nGrowBy大于1，则内存按照nGrowBy增加。函数返回newElement的数组元素索引

　　void RemoveAt(INT_PTR nIndex, INT_PTR nCount = 1);

　　从指定的nIndex位置开始，删除nCount个数组元素，所有元素自动下移，并且减少数组的上限，但是不释放内存。这里我们自己手动的申请的就必须自己释放。new对应delete相信大家都知道的。

　　void RemoveAll();

　　从数组中移除素有的元素，如果数组为空，该行数也起作用。

　　INT_PTR Append(const CArray& src);

　　将同个类型的一个数组A附加到本书猪的尾部，返回A第一数组元素在本数组的索引。

　　void InsertAt(INT_PTR nIndex, ARG_TYPE newElement,INT_PTR nCount = 1);

　　void InsertAt(INT_PTR nStartIndex, CArray*pNewArray);

　　在指定饿nIndex或者nStartIndex位置插入nCount个newElement数组元素或者pNewArray数组

　　下面是我应用的实例：

　　view plaincopy to clipboardprint?

　　CArray arrPChar;

　　//初始化元素

　　arrPChar.SetSize(10);

　　for (int i=0;i<10;i++)

　　{

　　char *aChar=new char[10];

　　strcpy_s(aChar,10,"hello arr");

　　arrPChar.SetAt(i,aChar);

　　}

　　//在数组的末尾插入一个元素

　　char *bChar = new char[10];

　　strcpy_s(bChar,10,"asdfefdsd");

　　arrPChar.Add(bChar);

　　//在索引2的位置插入一个元素，即在第三位插入一个元素

　　char *cChar=new char[5];

　　strcpy_s(cChar,5,"aidy");

　　arrPChar.InsertAt(2,cChar);

　　for (int j=0;j

　　{

　　TRACE("%d,%s\n",j,arrPChar.GetAt(j));

　　}

　　//删除数组里的所有元素，要释放内存，如果单单Remove的话则内存不会被释放

　　//这里因为使用RemoveAll的话内存无法被释放，所以没有给实例。

　　int count = arrPChar.GetCount();

　　for (int k=0; k

　　{

　　char *dChar=arrPChar.GetAt(0);

　　arrPChar.RemoveAt(0);

　　delete dChar;