深入分析MFC中的CArray类

我们在使用vc进行比较复杂的编程时，经常需要用到复杂的数组结构，并希望能实现动态管理。由于C++并不支持动态数组，MFC提供了一个CArray类来实现动态数组的功能。有效的使用CArray类，可以提高程序的效率。
MFC提供了一套模板库，来实现一些比较常见的数据结构如Array,List,Map。CArray即为其中的一个，用来实现动态数组的功能。
CArray是从CObject派生,有两个模板参数，第一个参数就是CArray类数组元素的变量类型，后一个是函数调用时的参数类型。
我们有一个类 class Object，我们要定义一个Object的动态数组，那么我们可以用以下两种方法：

1.

CArray<Object,Object> 
 Var1;

2.

CArray<Object,Object&> 
 Var2;

Var1与Var2哪一个的效率要高呢？ Var2的效率要高。为什么呢？接下来我们对CArray的源代码做一个剖析就清楚了。
先了解一下CArray中的成员变量及作用。

1.

TYPE*
 m_pData;

//
 数据保存地址的指针

2.

int

m_nSize;

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

3.

int

m_nMaxSize;

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

4.

int

m_nGrowBy;

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

首先来看它的构造函数,对成员变量进行了初始化。

1.

CArray<TYPE,
 ARG_TYPE>::CArray()

2.

{

3.

m_pData
 = NULL;

4.

m_nSize
 = m_nMaxSize = m_nGrowBy = 0;

5.

}

SetSize成员函数是用来为数组分配空间的，从这里着手，看CArray是如何对数据进行管理的。SetSize的函数定义如下：

1.

void

SetSize(

int

nNewSize,

int

nGrowBy
 = -1 );

nNewSize 指定数组的大小
nGrowBy 如果需要增加数组大小时增加的元素的个数。
对SetSize的代码，进行分析。(由于代码太长，只列出部分重要部分)

01.

void

CArray<TYPE,
 ARG_TYPE>::SetSize(

int

nNewSize,

int

nGrowBy)

02.

{

03.

if

(nNewSize
 == 0)

04.

{

05.

//
 第一种情况

06.

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

07.

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

08.

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

09.

if

(m_pData
 != NULL)

10.

{

11.

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

12.

//不能使用delete
 m_pData  因为我们必须要调用数组元素的析构函数 <strong> DestructElements<TYPE>(m_pData, m_nSize);</strong> //现在才能释放内存

13.

delete

[]
 (

BYTE

*)m_pData;

14.

m_pData
 = NULL;

15.

}

16.

m_nSize
 = m_nMaxSize = 0;

17.

}

18.

else

if

(m_pData
 == NULL)

19.

{

20.

//
 第二种情况

21.

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

22.

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

23.

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

24.

m_pData
 = (TYPE*)

new

BYTE

[nNewSize
 *

sizeof

(TYPE)];

25.

//下面的函数调用数组元素的构造函数
 <strong> ConstructElements<TYPE>(m_pData, nNewSize);</strong> //记录下当前数组元素的个数

26.

m_nSize
 = m_nMaxSize = nNewSize;

27.

}

28.

else

if

(nNewSize
 <= m_nMaxSize)

29.

{

30.

//
 第三种情况

31.

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

32.

if

(nNewSize
 > m_nSize)

33.

{

34.

//
 需要增加元素的情况

35.

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

36.

//
 只要调用新增元素的构造函数就Ok <strong> ConstructElements<TYPE>(&m_pData[m_nSize], nNewSize-m_nSize);</strong> }

37.

else

if

(m_nSize
 > nNewSize)

38.

{

39.

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

40.

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

41.

// 
 下面代码释放多余的元素,不是释放内存，只是调用析构函数 <strong> DestructElements<TYPE>(&m_pData[nNewSize], m_nSize-nNewSize);</strong> }

42.

m_nSize
 = nNewSize;

43.

}

44.

else

45.

{

46.

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

47.

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

48.

49.

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

50.

int

nNewMax;

51.

if

(nNewSize
 < m_nMaxSize + nGrowBy)

52.

nNewMax
 = m_nMaxSize + nGrowBy;

53.

else

54.

nNewMax
 = nNewSize;

55.

//
 重新分配一块内存

56.

TYPE*
 pNewData = (TYPE*)

new

BYTE

[nNewMax
 *

sizeof

(TYPE)];

57.

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

58.

memcpy

(pNewData,
 m_pData, m_nSize *

sizeof

(TYPE));

59.

//
 对新增的元素调用构造函数 <strong> ConstructElements<TYPE>(&pNewData[m_nSize], nNewSize-m_nSize);</strong> //释放内存

60.

delete

[]
 (

BYTE

*)m_pData;

61.

62.

//将数据保存

63.

m_pData
 = pNewData;

64.

m_nSize
 = nNewSize;

65.

m_nMaxSize
 = nNewMax;

66.

}

67.

}

注意上面代码中标注为粗体的代码，它们实现了对象的构造与析构。如果我们只为对象分配内存，却没有调用构造与析构函数，会不会有问题呢?
如果只是使用c++的基本数据类型,如果int,long，那的确不会有什么问题。如果使用的是一个类，比如下面的类：

1.

class

Object

2.

{

3.

public

:

4.

Object(){
 ID = 0; }

5.

~Object();

6.

protected

:

7.

int

ID;

8.

};

我们只为Object类分配了空间，也能正常使用。但是，类的成员变量ID的值却是不定的，因为没有初始化。如果是一个更复杂的组合类，在构造函数中做了许多工作，那可能就不能正常运行了。
同样，删除的数组元素时，也一定要调用它的析构函数。
我们来看下面的Preson类

01.

class

Preson

02.

{

03.

public

:

04.

Preson()

05.

{

06.

name
 =

new

char

[10];

07.

}

08.

~Preson()

09.

{

10.

delete

[]name;

11.

}

12.

char

*
 name;

13.

int

age;

14.

}

如果我没调用构造函数，那么对name操作肯定会出错。我们调用了构造函数后，删除元素时，如果不调用析构函数，那么，name所指向的内存不能正确释放，就会造成内存泄漏。
我们来看一下ConstructElements与DestructElements如何实现构造与析构函数的调用。
下面是ConstructElements函数的实现代码

01.

template

<

class

TYPE>

02.

AFX_INLINE

void

AFXAPI
 ConstructElements(TYPE* pElements,

int

nCount)

03.

{

04.

//
 first do bit-wise zero initialization

05.

memset

((

void

*)pElements,
 0, nCount *

sizeof

(TYPE));

06.

07.

for

(;
 nCount--; pElements++)

08.

::

new

((

void

*)pElements)
 TYPE;

09.

}

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

1.

template

<

class

TYPE>

2.

AFX_INLINE

void

AFXAPI
 DestructElements(TYPE* pElements,

int

nCount)

3.

{

4.

for

(;
 nCount--; pElements++)

5.

pElements->~TYPE();

6.

}

DestructElements函数同样是一个模板函数，实现很简单，直接调用类的析构函数即可。
如果定义一个CArray对象 CArray<Object,Object&> myObject ，对myObject就可象数组一样，通过下标来访问指定的数组元素。通过[]来访问数组元素是如何实现的呢？其实只要重载运算符[]即可。
CArray[]有两种实现，区别在于返回值不同。我们来看看代码：

1.

template

<

class

TYPE,

class

ARG_TYPE>

2.

AFX_INLINE
 TYPE CArray<TYPE,ARG_TYPE>::operator[](

int

nIndex)

const

3.

{

return

GetAt(nIndex);
 }

4.

template

<

class

TYPE,

class

ARG_TYPE>

5.

AFX_INLINE
 TYPE& CArray<TYPE,ARG_TYPE>::operator[](

int

nIndex)

6.

{

return

ElementAt(nIndex);
 }

前一种情况是返回的对象的实例，后一种情况是返回对象的引用。分别调用不同的成员函数来实现。我们来比较一下这两个函数的实现(省略部分):

1.

TYPE   
 GetAt(

int

nIndex)

const

2.

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

3.

return

m_pData[nIndex];
 }

4.

TYPE& 
 ElementAt(

int

nIndex)

5.

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

6.

return

m_pData[nIndex];
 }

除了返回值不同，其它都一样，有什么区别吗？我们来看一个实例说明。

01.

CArray<

int

,

int

&>
 arrInt;

02.

arrInt.SetSize(10);

03.

int

n
 = arrInt.GetAt(0);

04.

int

&
 l = arrInt.ElementAt(0);

05.

cout
 << arrInt[0] <<endl;

06.

n
 = 10;

07.

cout
 << arrInt[0] <<endl;

08.

l
 = 20;

09.

count
 << arrInt[0] << endl;

结果会发现，n的变化不会影响到数组，而l的变化会改变数组元素的值。实际即是对C++中引用运算符的运用。
CArray下标访问是非安全的，它并没有超标预警功能。虽然使用ASSERT提示，但下标超范围时没有进行处理，会引起非法内存访问的错误。
前面谈到模板实例化时有两个参数，后一个参数一般用引用，为什么呢？看看Add成员函数就可以明。Add函数的作用是向数组添加一个元素。下面是它的定义：

1.

int

CArray<TYPE,
 ARG_TYPE>::Add(ARG_TYPE newElement)

Add函数使用的参数是模板参数的二个参数，也就是说，这个参数的类型是我们来决定的，可以使用Object或Object&的方式。熟悉C++的朋友都知道，传引用的效率要高一些。如果是传值的话，会在堆栈中再产生一个新的对象，需要花费更多的时间。
下面来分析一下Add函数的代码：

1.

template

<

class

TYPE,

class

ARG_TYPE>

2.

AFX_INLINE

int

CArray<TYPE,
 ARG_TYPE>::Add(ARG_TYPE newElement)

3.

{

4.

int

nIndex
 = m_nSize;

5.

SetAtGrow(nIndex,
 newElement);

6.

return

nIndex;

7.

}

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

1.

template

<

class

TYPE,

class

ARG_TYPE>

2.

void

CArray<TYPE,
 ARG_TYPE>::SetAtGrow(

int

nIndex,
 ARG_TYPE newElement)

3.

{

4.

if

(nIndex
 >= m_nSize)

5.

SetSize(nIndex+1,
 -1);

6.

m_pData[nIndex]
 = newElement;

7.

}

SetAtGrow的实现也很简单，如果指定的元素已经存在，就把改变指定元素的值。如果指定的元素不存在，也就是 nIndex>=m_nSize的情况，就调用SetSize来调整数组的大小。
其实，到这里，大家对CArray类的内部实现有了一定的了解，只要看看MSDN的文档，就可以灵活运用了。