(转)使用MFC的数组类 vc多线程(续)关于_beginthread()的学习体会深入分析MFC中的CArray类

2012-03-28

MFC 的数组类支持的数组类似于C++中的常规数组,可以存放任何数据类型。C++的常规数组在使用前必须将其定义成能够容纳所有可能需要的元素,而MFC数组 类创建的对象可以根据需要动态地增大或减小,数组的起始下标是0,而上限可以是固定的,也可以随着元素的增加而增加,数组在内存中的地址仍然是连续分配 的。

MFC定义了数组模板类CArray,并针对各种常用变量类型定义了CByteArray,CWordArray,CUIntArray,CDWordArray,CStringArray,CObArray,CPtrArray。详见下表:

数组类 变量类型 变量数值范围 头文件

CArray 通过模板类的参数类型设定各种类型   Afxtempl.h

CByteArray 8位无符号整数 BYTE类型 0—255 Afxcoll.h

CWordArray 16位无符号整数 WORD类型 0—65535 Afxcoll.h

CDWordArray 32位无符号整数 DWORD类型 0—4294967295 Afxcoll.h

CUIntArray 32位无符号整数 UINT类型 0—4294967295 Afxcoll.h

CStringArray CString字符串 string字符串   Afxcoll.h

CObArray CObject类及其派生类   Afxcoll.h

CPtrArray void* 类型指针   Afxcoll.h

MFC数组类使用方法基本相同,下面分别以CArray和CUIntArray为例演示说明数组类的使用方法。

使用 CArray

打开VC++ 6.0,创建基于对话框的工程Array。CArrayDlg类声明文件(ArrayDlg.h)中添加语句: #include

请记住:使用CArray一定要包含头文件afxtempl.h。

打开主对话框资源IDD_ARRAY_DIALOG,添加一个按钮IDC_ARRAY_CPOINT,标题为CArray_CPoint,双击该按钮,在OnArrayCpoint()函数中添加如下代码:

void CArrayDlg::OnArrayCpoint()

{

CArray m_Array;

m_Array.SetSize(10,10);

CPoint pt1(10,10);

m_Array.Add(pt1);

CPoint pt2(10,50);

m_Array.Add(pt2);

CPoint pt3(10,100);

m_Array.Add(pt3);

int size=m_Array.GetSize();

CClientDC dc(this);

dc.MoveTo(0,0);

CPoint pt;

for(int i=0;i

{

pt=m_Array.GetAt(i);

dc.LineTo(pt);

}

}

代码简要说明:

CArray m_Array;

该语句定义一个CArray数组对象,模板类CArray有两个参数,第一个参数为数组元素的类型,该例中是CPoint,即m_Array是 CPoint数组;第二个参数为引用类型,一般有两种选择,一种选择与第一个参数类型相同,它意味着数组对象作为参数传递时,传递的是数组对象。第二种选 择是第一个参数类型的引用,它意味着数组对象作为参数传递时,传递的是数组对象的指针。因此,尤其对于较复杂的数组结构类型,推荐使用引用传递,节约内存 同时加快程序运行速度,正如本例使用的是CPoint&。

m_Array.SetSize(10,10);

SetSize函数设定数组的大小,该函数有两个参数,第一个参数设定数组的大小;第二个参数设定数组增长时内存分配的大小,缺省值是-1,使用缺省 值可以保证内存分配得更加合理。本例中第二个参数是10,意即增加一个数组元素会分配10个元素大小的内存供数组使用。

您可以随时使用SetSize函数设定数组的大小,如果第一个参数值小于数组已有成员数量,多于第一个参数值的成员将被截去并释放相应内存。

在使用CArray数组前,最好先使用SetSize确定其大小并申请存储空间。如果不这样做,向数组中增加元素时,需要不断地移动和拷贝元素造成运行的低效率和内存碎块。

m_Array.Add(pt1);

Add函数添加数组元素。

int size=m_Array.GetSize();

GetSize返回数组元素的数目。

for(int i=0;i

{

pt=m_Array.GetAt(i);

dc.LineTo(pt);

}

为了直观显示,该段代码将各数组元素作成折线画到屏幕上,其中GetAt(int index)通过index值得到相应的元素值。编译并运行程序,观察运行结果。

继续演示如何使用CArray

再次打开主对话框资源IDD_ARRAY_DIALOG,添加一个按钮IDC_ARRAY_CSTRING,标题为CArray_CString,双击该按钮,在OnArrayCstring ()函数中添加如下代码:

void CArrayDlg::OnArrayCstring()

{

CArray m_string;

CString sztiger("tiger");

CString szbear("bear");

CString szdog("dog");

m_string.SetAtGrow(0,sztiger);

m_string.SetAtGrow(2,szdog);

m_string.InsertAt(1,szbear);

int count=m_string.GetSize();

CClientDC dc(this);

dc.SetBkMode(TRANSPARENT);

TEXTMETRIC textMetric;

dc.GetTextMetrics(&textMetric);

int fontHeight=textMetric.tmHeight;

int displayPos=10;

for(int x=0;x

{

dc.TextOut(10,displayPos,m_string[x]);

displayPos+=fontHeight;

}

AfxMessageBox("Continue...");

m_string.RemoveAt(2);

count=m_string.GetSize();

for(x=0;x

{

dc.TextOut(10,displayPos,m_string[x]);

displayPos+=fontHeight;

}

AfxMessageBox("A string has delete,continue...");

m_string.RemoveAll();

count=m_string.GetSize();

if(count==0)

AfxMessageBox("All elements are deleted.");

}

代码简要说明:

m_string.SetAtGrow(2,szdog);

SetAtGrow有两个参数,第一个参数决定数组元素的序号值,第二个参数是元素的值。该函数根据序号值设置相应数组元素的值,功能与SetAt相近,不同之处是使用该函数设置元素值时,如果序号值大于数组的上界,数组会自动增长。

编译运行程序,细心的读者您可能会看到,第一行字符是“tiger”,第二行字符是“bear”,这是我们预料之中的,但第三行是空串,第四行是“dog”。空串是怎样造成的呢?细分析下面三行代码就可以知道:

m_string.SetAtGrow(0,sztiger);

m_string.SetAtGrow(2,szdog);

m_string.InsertAt(1,szbear);

第一行设定元素0为“tiger”,这是没有疑义的。

第二行设定元素2为“dog”,但是在设定元素2的同时自动将元素1填充为空串。

第三行插入“bear”为元素1,同时原来的元素1和元素2后移为元素2和元素3。

怎么样,这回明白了吧。

m_string.InsertAt(1,szbear);

InsertAt函数在指定序号处插入相应元素,该函数在执行过程中,插入点后面的元素会自动后移。 dc.TextOut(10,displayPos,m_string[x]); 其中,m_string[x]是数组类对操作符[]的重载,数组类CArray允许使用[]操作符,类似于C++的常规数组。m_string[x]也可以用m_string.GetAt(x)替代。

m_string.RemoveAt(2);

RemoveAt只有一个参数,即元素序号值。该函数根据元素序号值删除相应元素值,后面的元素会自动前移。

m_string.RemoveAll();

RemoveAll删除所有元素值

演示使用CUIntArray类

打开主对话框资源IDD_ARRAY_DIALOG,添加一个按钮IDC_CUINTARRAY,标题为CUIntArray,双击该按钮,在OnCuintarray ()函数中添加如下代码:

void CArrayDlg::OnCuintarray()

{

CUIntArray m_array;

m_array.SetSize(5,5);

m_array.SetAt(0,0);

m_array.SetAt(1,1);

m_array.SetAt(2,2);

m_array.SetAt(3,3);

m_array.SetAt(4,4);

int count=m_array.GetSize();

CClientDC dc(this);

dc.SetBkMode(TRANSPARENT);

TEXTMETRIC textMetric;

dc.GetTextMetrics(&textMetric);

int fontHeight=textMetric.tmHeight;

int displayPos=10;

for(int x=0;x

{

CString str;

str.Format("%d",m_array.GetAt(x));

dc.TextOut(10,displayPos,str);

displayPos+=fontHeight;

}

}

这部分代码不作说明,请读者自行分析。

  最后再说明一点:RemoveAt,InsertAt函数操作时会使得数组元素移位,运行时间大于SetAt,RemoveAll,Add函数。

六、MFC多线程编程实例

在Visual C++

6.0编程环境中,我们既可以编写C风格的32位Win32应用程序,也可以利用MFC类库编写C++风格的应用程序,二者各有其优缺点。基于Win32的

应用程序执行代码小巧,运行效率高,但要求程序员编写的代码较多,且需要管理系统提供给程序的所有资源;而基于MFC类库的应用程序可以

快速建立起应用程序,类库为程序员提供了大量的封装类,而且Developer

Studio为程序员提供了一些工具来管理用户源程序,其缺点是类库代码很庞大。由于使用类库所带来的快速、简捷和功能强大等优越性,因此

除非有特殊的需要,否则Visual

C++推荐使用MFC类库进行程序开发。

我们知道,MFC中的线程分为两种:用户界面线程和工作者线程。我们将分别举例说明。

用 MFC 类库编程实现工作者线程

例程5 MultiThread5

为了与Win32 API对照,我们使用MFC 类库编程实现例程3 MultiThread3。

建立一个基于对话框的工程MultiThread5,在对话框IDD_MULTITHREAD5_DIALOG中加入一个编辑框IDC_MILLISECOND,一个按钮IDC_START,标题

为“开始”

,一个进度条IDC_PROGRESS1;

打开ClassWizard,为编辑框IDC_MILLISECOND添加int型变量m_nMilliSecond,为进度条IDC_PROGRESS1添加CProgressCtrl型变量

m_ctrlProgress;

在MultiThread5Dlg.h文件中添加一个结构的定义: struct threadInfo

{

UINT nMilliSecond;

CProgressCtrl* pctrlProgress;

};

线程函数的声明:UINT ThreadFunc(LPVOID lpParam);

注意,二者应在类CMultiThread5Dlg的外部。

在类CMultiThread5Dlg内部添加protected型变量:

CWinThread* pThread;

在MultiThread5Dlg.cpp文件中进行如下操作:定义公共变量:threadInfo Info;

双击按钮IDC_START,添加相应消息处理函数

void CMultiThread5Dlg::OnStart()

{

// TODO: Add your control notification handler code here

UpdateData(TRUE);

Info.nMilliSecond=m_nMilliSecond;

Info.pctrlProgress=&m_ctrlProgress;

pThread=AfxBeginThread(ThreadFunc,

&Info);

}

函数BOOL CMultiThread3Dlg::OnInitDialog()中添加语句: {

……

// TODO: Add extra initialization here

m_ctrlProgress.SetRange(0,99);

m_nMilliSecond=10;

UpdateData(FALSE);

return TRUE; // return TRUE unless you set the focus to a control

}

添加线程处理函数: UINT ThreadFunc(LPVOID lpParam)

{

threadInfo* pInfo=(threadInfo*)lpParam;

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

{

int nTemp=pInfo->nMilliSecond;

pInfo->pctrlProgress->SetPos(i);

Sleep(nTemp);

}

return 0;

}

用 MFC 类库编程实现用户界面线程

创建用户界面线程的步骤:

使用ClassWizard创建类CWinThread的派生类(以CUIThread类为例) class CUIThread : public

CWinThread

{

DECLARE_DYNCREATE(CUIThread)

protected:

CUIThread();           // protected constructor used by dynamic creation

// Attributes

public:

// Operations

public:

// Overrides

// ClassWizard generated virtual function overrides

//{{AFX_VIRTUAL(CUIThread)

public:

virtual BOOL InitInstance();

virtual int ExitInstance();

//}}AFX_VIRTUAL

// Implementation

protected:

virtual ~CUIThread();

// Generated message map functions

//{{AFX_MSG(CUIThread)

// NOTE - the ClassWizard will add and remove member functions here.

//}}AFX_MSG

DECLARE_MESSAGE_MAP()

};

重载函数InitInstance()和ExitInstance()。 BOOL CUIThread::InitInstance()

{

CFrameWnd* wnd=new CFrameWnd;

wnd->Create(NULL,"UI Thread Window");

wnd->ShowWindow(SW_SHOW);

wnd->UpdateWindow();

m_pMainWnd=wnd;

return TRUE;

}

创建新的用户界面线程 void CUIThreadDlg::OnButton1()

{

CUIThread* pThread=new CUIThread();

pThread->CreateThread();

}

请注意以下两点:

A、在UIThreadDlg.cpp的开头加入语句: #include "UIThread.h"

B、把UIThread.h中类CUIThread()的构造函数的特性由 protected 改为 public。

用户界面线程的执行次序与应用程序主线程相同,首先调用用户界面线程类的InitInstance()函数,如果返回TRUE,继续调用线程的Run()

函数,该函数的作用是运行一个标准的消息循环,并且当收到WM_QUIT消息后中断,在消息循环过程中,Run()函数检测到线程空闲时(没有消

息),也将调用OnIdle()函数,最后Run()函数返回,MFC调用ExitInstance()函数清理资源。

你可以创建一个没有界面而有消息循环的线程,例如:你可以从CWinThread派生一个新类,在InitInstance函数中完成某项任务并返回

FALSE,这表示仅执行InitInstance函数中的任务而不执行消息循环,你可以通过这种方法,完成一个工作者线程的功能。

例程6 MultiThread6

建立一个基于对话框的工程MultiThread6,在对话框IDD_MULTITHREAD6_DIALOG中加入一个按钮IDC_UI_THREAD,标题为“用户界面线程”

右击工程并选中“New Class…”为工程添加基类为CWinThread派生线程类CUIThread。

给工程添加新对话框IDD_UITHREADDLG,标题为“线程对话框”。

为对话框IDD_UITHREADDLG创建一个基于CDialog的类CUIThreadDlg。使用ClassWizard为CUIThreadDlg类添加WM_LBUTTONDOWN消息的处理函数

OnLButtonDown,如下:

void CUIThreadDlg::OnLButtonDown(UINT nFlags, CPoint point)

{

AfxMessageBox("You Clicked The Left Button!");

CDialog::OnLButtonDown(nFlags, point);

}

在UIThread.h中添加 #include "UIThreadDlg.h"

并在CUIThread类中添加protected变量CUIThread m_dlg: class CUIThread : public CWinThread

{

DECLARE_DYNCREATE(CUIThread)

protected:

CUIThread();           // protected constructor used by dynamic creation

// Attributes

public:

// Operations

public:

// Overrides

// ClassWizard generated virtual function overrides

//{{AFX_VIRTUAL(CUIThread)

public:

virtual BOOL InitInstance();

virtual int ExitInstance();

//}}AFX_VIRTUAL

// Implementation

protected:

CUIThreadDlg m_dlg;

virtual ~CUIThread();

// Generated message map functions

//{{AFX_MSG(CUIThread)

// NOTE - the ClassWizard will add and remove member functions here.

//}}AFX_MSG

DECLARE_MESSAGE_MAP()

};

分别重载InitInstance()函数和ExitInstance()函数: BOOL CUIThread::InitInstance()

{

m_dlg.Create(IDD_UITHREADDLG);

m_dlg.ShowWindow(SW_SHOW);

m_pMainWnd=&m_dlg;

return TRUE;

}

int CUIThread::ExitInstance()

{

m_dlg.DestroyWindow();

return CWinThread::ExitInstance();

}

双击按钮IDC_UI_THREAD,添加消息响应函数: void CMultiThread6Dlg::OnUiThread()

{

CWinThread *pThread=AfxBeginThread(RUNTIME_CLASS(CUIThread));

}

并在MultiThread6Dlg.cpp的开头添加: #include "UIThread.h"

好了,编译并运行程序吧。每单击一次“用户界面线程”按钮,都会弹出一个线程对话框,在任何一个线程对话框内按下鼠标左键,都会

弹出一个消息框。

在看多线程网络编程时看到了这两个函数,于是查了一下 vs.net 2003 文档,试了试里面的例子并且改了改。

beginthread 有两种调用形式:

uintptr_t _beginthread(

void( __cdecl *start_address )( void * ),

unsigned stack_size,

void *arglist

);

uintptr_t _beginthreadex(

void *security,

unsigned stack_size,

unsigned ( __stdcall *start_address )( void * ),

void *arglist,

unsigned initflag,

unsigned *thrdaddr

);

第一种是基本的调用形式,其中参数 *start_address 是要创建的新线程所要执行的例程的入口地址,可以是函数名,也可以是函数指针。第二个参数是线程栈的大小,可以是 0 ,

对这一点不太理解。例程可能要用到参数,这些参数由指针 *arglist 来指明,但如果有多个参数呢?还没有试。

第二种调用可以为用户提供更多、更灵活的对新创建线程的控制。尤其是其中的 initflag ,指明创建完线程后,它的状态是执行(running)还是挂起(suspended),由此想到这学期操作

系统中讲过关于“进程”的状态:引入挂起状态的原因之一是“...用户在自己的程序运行期间发现有可疑问题时,希望暂时使自己的程序静止下来。亦即,使正在执行的进程暂时停止执行

;若此时用户进程正处于就绪状态而未执行,则该进程不接受调度......”。相应地,线程也可以有挂起状态,而且原因与上相同。这个函数的使用就是一个很好的例子:用户在创建线程

时可将 initflag 设置为CREATE_SUSPENDED 来阻塞线程,需要执行时调用 ResumeThread 即可。

文档中给的例子是这样的:该程序实现的是在控制台上的一个随机的位置写一个字符 'A' ,之后 'A' 开始随机地、不停地向它的上、下、左、右四个方向之中的一个随机的移动一

个单位,在碰到某一个边界时(控制台的边界或人为设置的边界)会产生鸣叫,并回退。从产生 'A' 后,每隔一个固定的时间,会按 ASCII 码的递增顺序再产生一个字符(B, C, D...)

,每个字符也像 'A' 一样随机运动。这样下去,直到用户按任意键结束。

其中,每个线程执行的程序段(void Bounce( void *ch );)的功能是产生一个字符并让它作随机运动。通过一个循环,不断产生新线程来达到不断产生新字符的功能。这些线程之间

都是并发的。而监测用户是否按下键盘的功能(void CheckKey( void *dummy );)也由一个并发的线程来实现。

Bounce()和CheckKey()这两个函数都要用到一个全局变量 bool repeat ,Bounce()用它来进行判断,CheckKey()在监测到按键后会修改它。那么,这会不会产生多线程公用数据的冲突

呢?会不会因为repeat是全局变量,编译器在优化时就无论如何也不把它放入寄存器呢?register关键字只不过是建议,要是有__forceregister 就好了,可以看看会不会有冲突。

我试着把公用的变量该为局部变量,并改变参数传递的方式,没有成功,明天再试吧。

我们在使用vc进行比较复杂的编程时,经常需要用到复杂的数组结构,并希望能实现动态管理。由于C++并不支持动态数组,MFC提供了一个CArray类来实现动态数组的功能。有效的使用CArray类,可以提高程序的效率。

MFC提供了一套模板库,来实现一些比较常见的数据结构如Array,List,Map。CArray即为其中的一个,用来实现动态数组的功能。

CArray是从CObject派生,有两个模板参数,第一个参数就是CArray类数组元素的变量类型,后一个是函数调用时的参数类型。

我们有一个类 class Object,我们要定义一个Object的动态数组,那么我们可以用以下两种方法:CArray Var1;

CArray Var2;Var1与Var2哪一个的效率要高呢? Var2的效率要高。为什么呢?接下来我们对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成员函数是用来为数组分配空间的,从这里着手,看CArray是如何对数据进行管理的。SetSize的函数定义如下:void SetSize( int nNewSize, int nGrowBy = -1 );nNewSize 指定数组的大小

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

对SetSize的代码,进行分析。(由于代码太长,只列出部分重要部分)void CArray::SetSize(int nNewSize, 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;

}

}注意上面代码中标注为粗体的代码,它们实现了对象的构造与析构。如果我们只为对象分配内存,却没有调用构造与析构函数,会不会有问题呢?

如果只是使用c++的基本数据类型,如果int,long,那的确不会有什么问题。如果使用的是一个类,比如下面的类:class Object

{

public:

Object(){ ID = 0; }

~Object();

protected:

int ID;

};我们只为Object类分配了空间,也能正常使用。但是,类的成员变量ID的值却是不定的,因为没有初始化。如果是一个更复杂的组合类,在构造函数中做了许多工作,那可能就不能正常运行了。

同样,删除的数组元素时,也一定要调用它的析构函数。

我们来看下面的Preson类class Preson

{

public:

Preson()

{

name = new char[10];

}

~Preson()

{

delete []name;

}

char* name;

int  age;

}如果我没调用构造函数,那么对name操作肯定会出错。我们调用了构造函数后,删除元素时,如果不调用析构函数,那么,name所指向的内存不能正确释放,就会造成内存泄漏。

我们来看一下ConstructElements与DestructElements如何实现构造与析构函数的调用。

下面是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 < m_nSize);

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

下面来分析一下Add函数的代码:

template

AFX_INLINE int CArray::Add(ARG_TYPE newElement)

{

int nIndex = m_nSize;

SetAtGrow(nIndex, newElement);

return nIndex;

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

void CArray::SetAtGrow(int nIndex, ARG_TYPE newElement)

{

if (nIndex >= m_nSize)

SetSize(nIndex+1, -1);

m_pData[nIndex] = newElement;

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

其实,到这里,大家对CArray类的内部实现有了一定的了解,只要看看MSDN的文档,就可以灵活运用了。

你可能感兴趣的:((转)使用MFC的数组类 vc多线程(续)关于_beginthread()的学习体会深入分析MFC中的CArray类)