- MFC的进程和线程
-
- Win32的进程和线程概念
进程是一个可执行的程序，由私有虚拟地址空间、代码、数据和其他操作系统资源（如进程创建的文件、管道、同步对象等）组成。一个应用程序可以有一个或多个进程，一个进程可以有一个或多个线程，其中一个是主线程。
线程是操作系统分时调度分配 CPU时间的基本实体。一个线程可以执行程序的任意部分的代码，即使这部分代码被另一个线程并发地执行；一个进程的所有线程共享它的虚拟地址空间、全局变量和操作系统资源。
之所以有线程这个概念，是因为以线程而不是进程为调度对象效率更高：
- 由于创建新进程必须加载代码，而线程要执行的代码已经被映射到进程的地址空间，所以创建、执行线程的速度比进程更快。
- 一个进程的所有线程共享进程的地址空间和全局变量，所以简化了线程之间的通讯。
-
- Win32的进程处理简介
因为 MFC没有提供类处理进程，所以直接使用了Win32 API函数。
- 进程的创建
调用 CreateProcess函数创建新的进程，运行指定的程序。CreateProcess的原型如下：
BOOL CreateProcess(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
);
其中：
lpApplicationName 指向包含了要运行模块名字的字符串。
lpCommandLine 指向命令行字符串。
lpProcessAttributes 描述进程的安全性属性，NT下有用。
lpThreadAttributes 描述进程初始线程（主线程）的安全性属性，NT下有用。
bInHeritHandles 表示子进程（被创建的进程）是否可以继承父进程的句柄。可以继承的句柄有线程句柄、有名或无名管道、互斥对象、事件、信号量、映像文件、普通文件和通讯端口等；还有一些句柄不能被继承，如内存句柄、DLL实例句柄、GDI句柄、URER句柄等等。
子进程继承的句柄由父进程通过命令行方式或者进程间通讯（ IPC）方式由父进程传递给它。
dwCreationFlags 表示创建进程的优先级类别和进程的类型。创建进程的类型分控制台进程、调试进程等；优先级类别用来控制进程的优先级别，分Idle、Normal、High、Real_time四个类别。
lpEnviroment 指向环境变量块，环境变量可以被子进程继承。
lpCurrentDirectory 指向表示当前目录的字符串，当前目录可以继承。
lpStartupInfo 指向StartupInfo结构，控制进程的主窗口的出现方式。
lpProcessInformation 指向PROCESS_INFORMATION结构，用来存储返回的进程信息。
从其参数可以看出创建一个新的进程需要指定什么信息。
从上面的解释可以看出，一个进程包含了很多信息。若进程创建成功的话，返回一个进程信息结构类型的指针。进程信息结构如下：
typedef struct _PROCESS_INFORMATION {
HANDLE hProcess;
HANDLE hThread;
DWORD dwProcessId;
DWORD dwThreadId;
}PROCESS_INFORMATION;
进程信息结构包括进程句柄，主线程句柄，进程 ID，主线程ID。
- 进程的终止
进程在以下情况下终止：
- 调用 ExitProcess结束进程；
- 进程的主线程返回，隐含地调用 ExitProcess导致进程结束；
- 进程的最后一个线程终止；
- 调用 TerminateProcess终止进程。
- 当要结束一个 GDI进程时，发送WM_QUIT消息给主窗口，当然也可以从它的任一线程调用ExitProcess。
使用 CreateThread函数创建线程，CreateThread的原型如下：
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags, // creation flags
LPDWORD lpThreadId
);
其中：
lpThreadAttributes 表示创建线程的安全属性，NT下有用。
dwStackSize 指定线程栈的尺寸，如果为0则与进程主线程栈相同。
lpStartAddress 指定线程开始运行的地址。
lpParameter 表示传递给线程的32位的参数。
dwCreateFlages 表示是否创建后挂起线程(取值CREATE_SUSPEND)，挂起后调用ResumeThread继续执行。
lpThreadId 用来存放返回的线程ID。
- 线程的优先级别
进程的每个优先级类包含了五个线程的优先级水平。在进程的优先级类确定之后，可以改变线程的优先级水平。用 SetPriorityClass设置进程优先级类，用SetThreadPriority设置线程优先级水平。
Normal 级的线程可以被除了Idle级以外的任意线程抢占。
以下情况终止一个线程：
- 调用了 ExitThread函数；
- 线程函数返回：主线程返回导致 ExitProcess被调用，其他线程返回导致ExitThread被调用；
- 调用 ExitProcess导致进程的所有线程终止；
- 调用 TerminateThread终止一个线程；
- 调用 TerminateProcess终止一个进程时，导致其所有线程的终止。
当用TerminateProcess或者TerminateThread终止进程或线程时，DLL的入口函数DllMain不会被执行（如果有DLL的话）。
如果希望每个线程都可以有线程局部 (Thread local)的静态存储数据，可以使用TLS线程局部存储技术。TLS为进程分配一个TLS索引，进程的每个线程通过这个索引存取自己的数据变量的拷贝。
TLS 对DLL是非常有用的。当一个新的进程使用DLL时，在DLL入口函数DllMain中使用TlsAlloc分配TLS索引，TLS索引就作为进程私有的全局变量被保存；以后，当该进程的新的线程使用DLL时(Attahced to DLL），DllMain给它分配动态内存并且使用TlsSetValue把线程私有的数据按索引保存。DLL函数可以使用TlsGetValue按索引读取调用线程的私有数据。
TLS 函数如下：
-
- DWORD TlsAlloc()
在进程或 DLL初始化时调用，并且把返回值（索引值）作为全局变量保存。
-
- BOOL TlsSetValue(
DWORD dwTlsIndex, //TLS index to set value for
LPVOID lpTlsValue //value to be stored
);
其中：
dwTlsIndex 是TlsAlloc分配的索引。
lpTlsValue 是线程在TLS槽中存放的数据指针，指针指向线程要保存的数据。
线程首先分配动态内存并保存数据到此内存中，然后调用 TlsSetValue保存内存指针到TLS槽。
-
- LPVOID TlsGetValue(
DWORD dwTlsIndex // TLS index to retrieve value for
);
其中：
dwTlsIndex 是TlsAlloc分配的索引。
当要存取保存的数据时，使用索引得到数据指针。
-
- BOOL TlsFree(
DWORD dwTlsIndex // TLS index to free
);
其中：
dwTlsIndex 是TlsAlloc分配的索引。
当每一个线程都不再使用局部存储数据时，线程释放它分配的动态内存。在 TLS索引不再需要时，使用TlsFree释放索引。
同步对象有： Critical_section（关键段），Event（事件），Mutex（互斥对象），Semaphores（信号量）。
下面，解释怎么使用这些同步对象。
- 关键段对象：
首先，定义一个关键段对象 cs：
CRITICAL_SECTION cs;
然后，初始化该对象。初始化时把对象设置为 NOT_SINGALED，表示允许线程使用资源：
InitializeCriticalSection(&cs);
如果一段程序代码需要对某个资源进行同步保护，则这是一段关键段代码。在进入该关键段代码前调用 EnterCriticalSection函数，这样，其他线程都不能执行该段代码，若它们试图执行就会被阻塞。
完成关键段的执行之后，调用 LeaveCriticalSection函数，其他的线程就可以继续执行该段代码。如果该函数不被调用，则其他线程将无限期的等待。
- 事件对象
首先，调用 CreateEvent函数创建一个事件对象，该函数返回一个事件句柄。然后，可以设置（SetEvent）或者复位(ResetEvent)一个事件对象，也可以发一个事件脉冲（PlusEvent），即设置一个事件对象，然后复位它。复位有两种形式：自动复位和人工复位。在创建事件对象时指定复位形式。。
自动复位：当对象获得信号后，就释放下一个可用线程（优先级别最高的线程；如果优先级别相同，则等待队列中的第一个线程被释放）。
人工复位：当对象获得信号后，就释放所有可利用线程。
最后，使用 CloseHandle销毁创建的事件对象。
- 互斥对象
首先，调用 CreateMutex创建互斥对象；然后，调用等待函数，可以的话利用关键资源；最后，调用RealseMutex释放互斥对象。
互斥对象可以在进程间使用，但关键段对象只能用于同一进程的线程之间。
- 信号量对象
在 Win32中，信号量的数值变为0时给以信号。在有多个资源需要管理时可以使用信号量对象。
首先，调用 CreateSemaphore创建一个信号量；然后，调用等待函数，如果允许的话，则利用关键资源；最后，调用RealeaseSemaphore释放信号量对象。
- 此外，还有其他句柄可以用来同步线程：
文件句柄（FILE HANDLES）
命名管道句柄（NAMED PIPE HANDELS）
控制台输入缓冲区句柄（CONSOLE INPUT BUFFER HANDLES）
通讯设备句柄（COMMUNICTION DEVICE HANDLES）
进程句柄（PROCESS HANDLES）
线程句柄（THREAD HANDLES）
例如，当一个进程或线程结束时，进程或线程句柄获得信号，等待该进程或者线程结束的线程被释放。
Win32 提供了一组等待函数用来让一个线程阻塞自己的执行。等待函数分三类：
- 等待单个对象的 (FOR SINGLE OBJECT):
这类函数包括：
SignalObjectAndWait
WaitForSingleObject
WaitForSingleObjectEx
函数参数包括同步对象的句柄和等待时间等。
在以下情况下等待函数返回：
同步对象获得信号时返回；
等待时间达到了返回：如果等待时间不限制 (Infinite)，则只有同步对象获得信号才返回；如果等待时间为0，则在测试了同步对象的状态之后马上返回。
- 等待多个对象的 (FOR MULTIPLE OBJECTS)
这类函数包括：
WaitForMultipleObjects
WaitForMultipleObjectsEx
MsgWaitForMultipleObjects
MsgWaitForMultipleObjectsEx
函数参数包括同步对象的句柄，等待时间，是等待一个还是多个同步对象等等。
在以下情况下等待函数返回：
一个或全部同步对象获得信号时返回（在参数中指定是等待一个或多个同步对象）；
等待时间达到了返回：如果等待时间不限制 (Infinite)，则只有同步对象获得信号才返回；如果等待时间为0，则在测试了同步对象的状态之后马上返回。
- 可以发出提示的函数 (ALTERABLE)
这类函数包括：
MsgWaitForMultipleObjectsEx
SignalObjectAndWait
WaitForMultipleObjectsEx
WaitForSingleObjectEx
这些函数主要用于重叠 (Overlapped)的I/O（异步I/O）。
-
- MFC的线程处理
在 Win32 API的基础之上，MFC提供了处理线程的类和函数。处理线程的类是CWinThread，函数是AfxBeginThread、AfxEndThread等。
表 5-6解释了CWinThread的成员变量和函数。
CWinThread 是MFC线程类，它的成员变量m_hThread和m_hThreadID是对应的Win32线程句柄和线程ID。
MFC 明确区分两种线程：用户界面线程(User interface thread)和工作者线程(Worker thread)。用户界面线程一般用于处理用户输入并对用户产生的事件和消息作出应答。工作者线程用于完成不要求用户输入的任务，如耗时计算。
Win32 API 并不区分线程类型，它只需要知道线程的开始地址以便它开始执行线程。MFC为用户界面线程特别地提供消息泵来处理用户界面的事件。CWinApp对象是用户界面线程对象的一个例子，CWinApp从类CWinThread派生并处理用户产生的事件和消息。
通过以下步骤创建一个用户界面线程：
- 从 CWinThread派生一个有动态创建能力的类。使用DECLARE_DYNCREATE和IMPLEMENT_DYNCREATE宏来支持动态创建。
- 覆盖 CWinThread的一些虚拟函数，可以覆盖的函数见表5-4关于CWinThread的部分。其中，函数InitInstance是必须覆盖的，ExitInstance通常是要覆盖的。
- 使用 AfxBeginThread创建MFC线程对象和Win32线程对象。如果创建线程时没有指定CREATE_SUSPENDED，则开始执行线程。
- 如果创建线程是指定了 CREATE_SUSPENDED，则在适当的地方调用函数ResumeThread开始执行线程。
用户界面线程和工作者线程都是由 AfxBeginThread创建的。现在，考察该函数：MFC提供了两个重载版的AfxBeginThread，一个用于用户界面线程，另一个用于工作者线程，分别有如下的原型和过程：
- 用户界面线程的 AfxBeginThread
用户界面线程的 AfxBeginThread的原型如下：
CWinThread* AFXAPI AfxBeginThread(
CRuntimeClass* pThreadClass,
int nPriority,
UINT nStackSize,
DWORD dwCreateFlags,
LPSECURITY_ATTRIBUTES lpSecurityAttrs)
其中：
参数 1是从CWinThread派生的RUNTIME_CLASS类；
参数 2指定线程优先级，如果为0，则与创建该线程的线程相同；
参数 3指定线程的堆栈大小，如果为0，则与创建该线程的线程相同；
参数 4是一个创建标识，如果是CREATE_SUSPENDED，则在悬挂状态创建线程，在线程创建后线程挂起，否则线程在创建后开始线程的执行。
参数 5表示线程的安全属性，NT下有用。
- 工作者线程的 AfxBeginThread
工作者线程的 AfxBeginThread的原型如下：
CWinThread* AFXAPI AfxBeginThread(
AFX_THREADPROC pfnThreadProc,
LPVOID pParam,
int nPriority,
UINT nStackSize,
DWORD dwCreateFlags,
LPSECURITY_ATTRIBUTES lpSecurityAttrs)
其中：
参数 1指定控制函数的地址；
参数 2指定传递给控制函数的参数；
参数 3、4、5分别指定线程的优先级、堆栈大小、创建标识、安全属性，含义同用户界面线程。
- AfxBeginThread 创建线程的流程
不论哪个AfxBeginThread，首先都是创建MFC线程对象，然后创建Win32线程对象。在创建MFC线程对象时，用户界面线程和工作者线程的创建分别调用了不同的构造函数。用户界面线程是从CWinThread派生的，所以，要先调用派生类的缺省构造函数，然后调用CWinThread的缺省构造函数。图8-1中两个构造函数所调用的CommonConstruct是MFC内部使用的成员函数。
-
-
- CreateThread和_AfxThreadEntry
MFC 使用CWinThread::CreateThread创建线程，不论对工作者线程或用户界面线程，都指定线程的入口函数是_AfxThreadEntry。_AfxThreadEntry调用AfxInitThread初始化线程。
CreateThread 和_AfxThreadEntry在线程的创建过程中使用同步手段交互等待、执行。CreateThread由创建线程执行，_AfxThreadEntry由被创建的线程执行，两者通过两个事件对象(hEvent和hEvent2)同步：
在创建了新线程之后，创建线程将在 hEvent事件上无限等待直到新线程给出创建结果；新线程在创建成功或者失败之后，触发事件hEvent让父线程运行，并且在hEven2上无限等待直到父线程退出CreateThread函数；父线程(创建线程)因为hEvent的置位结束等待，继续执行，退出CreateThread之前触发hEvent2事件；新线程（子线程）因为hEvent2的置位结束等待，开始执行控制函数（工作者线程）或者进入消息循环（用户界面线程）。
MFC 在线程创建中使用了如下数据结构：
struct _AFX_THREAD_STARTUP
{
// 传递给线程启动的参数（IN）
_AFX_THREAD_STATE* pThreadState;// 父线程的线程状态
CWinThread* pThread; // 新创建的MFC线程对象
DWORD dwCreateFlags; // 线程创建标识
_PNH pfnNewHandler; // 新线程的句柄
HANDLE hEvent; // 同步事件，线程创建成功或失败后置位
HANDLE hEvent2; // 同步事件，新线程恢复执行后置位
// 返回给创建线程的参数，在新线程恢复执行后赋值
BOOL bError; // 如果创建发生错误，TRUE
};
该结构作为线程开始函数的参数被传递给 _beginthreadex函数来创建和启动线程。_beginthreadex函数是“C”的线程创建函数，具有如下原型：
unsigned long _beginthreadex(
void *security,
unsigned stack_size,
unsigned ( __stdcall *start_address )( void * ),
void *arglist,
unsigned initflag,
unsigned *thrdaddr );
图 8-2描述了上述过程。图中表示，_AfxThreadEntry在启动线程时，将创建本线程的线程状态，并且继承父线程的模块状态。关于MFC状态，见第9章。
- 线程的结束
从图 8-2可以看出，AfxEndThread用来结束调用它的线程：它将清理本线程创建的MFC对象和释放线程局部存储分配的内存空间；调用CWinThread的虚拟函数Delete；调用“C”的结束线程函数_endthreadex释放分配给线程的资源，但是不关闭线程句柄。
CWinThread::Delete 的缺省实现是：如果本线程的成员函数m_bDelete为TRUE，则调用“C”运算符号delete销毁MFC线程对象自身（delete this），这将导致线程对象的析构函数被调用。若析构函数检测线程句柄非空则调用CloseHandle关闭它。
通常，让 m_bDelete为TRUE以便自动地销毁线程对象，释放内存空间（MFC内存对象在堆中分配）。但是，有时候，在线程结束之后（Win32线程已经不存在）保留MFC线程对象是有用的，当然程序员自己最后要记得销毁该线程对象。
- 实现线程的消息循环
-
在 MFC中，消息循环是由线程完成的。一般地，可以使用MFC缺省的消息循环（即使用函数CWindThrad::Run），但是，有些时候需要程序员自己实现一个线程的消息循环，比如在用户界面线程进行一个长时间计算处理或者等待另一个线程时。一般有如下形式：
while ( bDoingBackgroundProcessing)
{
MSG msg;
while ( ::PeekMessage( &msg, NULL,0, 0, PM_NOREMOVE ) )
{
if ( !PumpMessage( ) )
{
bDoingBackgroundProcessing = FALSE;
::PostQuitMessage( );
break;
}
}
// let MFC do its idle processing
LONG lIdle = 0;
while ( AfxGetApp()->OnIdle(lIdle++ ) );
// Perform some background processing here
// using another call to OnIdle
}
该段代码的解释参见图 5-3对线程的Run函数的图解。
程序员实现线程的消息循环有两个好处，一是顾及了 MFC的Idle处理机制；二是在长时间的处理中可以响应用户产生的事件或者消息。
在同步对象上等待其他线程时，也可以使用同样的方式，只要把条件
bDoingBackgroundProcessing
换成如下形式：
WaitForSingObject(hHandleOfEvent,0) == WAIT_TIMEOUT
即可。
MFC 处理线程和进程时还引入了一个重要的概念：状态，如线程状态(Thread State)、进程状态(Process State)、模块状态(Module State)等。由于这个概念在MFC中占有重要地位，涉及的内容比较多，所以专门在下一章来讲述它。
- MFC的DLL
一般的，在介绍Windows编程的书中讲述DLL的有关知识较多，而介绍MFC的书则比较少地提到。即使使用MFC来编写动态链接库，对于初步接触DLL的程序员来说，了解DLL的背景知识是必要的。另外，MFC提供了新的手段来帮助编写DLL程序。所以，本节先简洁的介绍有关概念。
- 静态链接和动态链接
当前链接的目标代码(.obj)如果引用了一个函数却没有定义它，链接程序可能通过两种途径来解决这种从外部对该函数的引用：
- 静态链接
链接程序搜索一个或者多个库文件(标准库.lib)，直到在某个库中找到了含有所引用函数的对象模块，然后链接程序把这个对象模块拷贝到结果可执行文件(.exe)中。链接程序维护对该函数的所有引用，使它们指向该程序中现在含有该函数拷贝的地方。
- 动态链接
链接程序也是搜索一个或者多个库文件(输入库.lib)，当在某个库中找到了所引用函数的输入记录时，便把输入记录拷贝到结果可执行文件中，产生一次对该函数的动态链接。这里，输入记录不包含函数的代码或者数据，而是指定一个包含该函数代码以及该函数的顺序号或函数名的动态链接库。
当程序运行时，Windows装入程序，并寻找文件中出现的任意动态链接。对于每个动态链接，Windows装入指定的DLL并且把它映射到调用进程的虚拟地址空间（如果没有映射的话）。因此，调用和目标函数之间的实际链接不是在链接应用程序时一次完成的（静态），相反，是运行该程序时由Windows完成的（动态）。
这种动态链接称为加载时动态链接。还有一种动态链接方式下面会谈到。
- 动态链接的方法
链接动态链接库里的函数的方法如下：
- 加载时动态链接(Load_time dynamic linking)
如上所述。Windows搜索要装入的DLL时，按以下顺序：
应用程序所在目录→当前目录→Windows SYSTEM目录→Windows目录→PATH环境变量指定的路径。
- 运行时动态链接(Run_time dynamic linking)
程序员使用LoadLibrary把DLL装入内存并且映射DLL到调用进程的虚拟地址空间（如果已经作了映射，则增加DLL的引用计数）。首先，LoadLibrary搜索DLL，搜索顺序如同加载时动态链接一样。然后，使用GetProcessAddress得到DLL中输出函数的地址，并调用它。最后，使用FreeLibrary减少DLL的引用计数，当引用计数为0时，把DLL模块从当前进程的虚拟空间移走。
- 输入库(.lib)：
输入库以.lib为扩展名，格式是COFF(Common object file format)。COFF标准库（静态链接库）的扩展名也是.lib。COFF格式的文件可以用dumpbin来查看。
输入库包含了DLL中的输出函数或者输出数据的动态链接信息。当使用MFC创建DLL程序时，会生成输入库(.lib)和动态链接库(.dll)。
- 输出文件(.exp)
输出文件以.exp为扩展名，包含了输出的函数和数据的信息，链接程序使用它来创建DLL动态链接库。
- 映像文件(.map)
映像文件以.map为扩展名，包含了如下信息：
模块名、时间戳、组列表（每一组包含了形式如section::offset的起始地址，长度、组名、类名）、公共符号列表(形式如section::offset的地址，符号名，虚拟地址flat address，定义符号的.obj文件)、入口点如section::offset、fixup列表。
- lib.exe工具
它可以用来创建输入库和输出文件。通常，不用使用lib.exe，如果工程目标是创建DLL程序，链接程序会完成输入库的创建。
更详细的信息可以参见MFC使用手册和文档。
- 链接规范（Linkage Specification ）
这是指链接采用不同编程语言写的函数(Function)或者过程(Procedure)的链接协议。MFC所支持的链接规范是“C”和“C++”，缺省的是“C++”规范，如果要声明一个“C”链接的函数或者变量，则一般采用如下语法：
#if defined(__cplusplus)
extern "C"
{
#endif
//函数声明（function declarations）
…
//变量声明(variables declarations)
#if defined(__cplusplus)
}
#endif
所有的C标准头文件都是用如上语法声明的，这样它们在C++环境下可以使用。
- 修饰名(Decoration name)
“C”或者“C++”函数在内部（编译和链接）通过修饰名识别。修饰名是编译器在编译函数定义或者原型时生成的字符串。有些情况下使用函数的修饰名是必要的，如在模块定义文件里头指定输出“C++”重载函数、构造函数、析构函数，又如在汇编代码里调用“C””或“C++”函数等。
修饰名由函数名、类名、调用约定、返回类型、参数等共同决定。
调用约定(Calling convention)决定以下内容：函数参数的压栈顺序，由调用者还是被调用者把参数弹出栈，以及产生函数修饰名的方法。MFC支持以下调用约定：
- _cdecl
按从右至左的顺序压参数入栈，由调用者把参数弹出栈。对于“C”函数或者变量，修饰名是在函数名前加下划线。对于“C++”函数，有所不同。
如函数void test(void)的修饰名是_test；对于不属于一个类的“C++”全局函数，修饰名是?test@@ZAXXZ。
这是MFC缺省调用约定。由于是调用者负责把参数弹出栈，所以可以给函数定义个数不定的参数，如printf函数。
- _stdcall
按从右至左的顺序压参数入栈，由被调用者把参数弹出栈。对于“C”函数或者变量，修饰名以下划线为前缀，然后是函数名，然后是符号“@”及参数的字节数，如函数int func(int a, double b)的修饰名是_func@12。对于“C++”函数，则有所不同。
所有的Win32 API函数都遵循该约定。
- _fastcall
头两个DWORD类型或者占更少字节的参数被放入ECX和EDX寄存器，其他剩下的参数按从右到左的顺序压入栈。由被调用者把参数弹出栈，对于“C”函数或者变量，修饰名以“@”为前缀，然后是函数名，接着是符号“@”及参数的字节数，如函数int func(int a, double b)的修饰名是@func@12。对于“C++”函数，有所不同。
未来的编译器可能使用不同的寄存器来存放参数。
- thiscall
仅仅应用于“C++”成员函数。this指针存放于CX寄存器，参数从右到左压栈。thiscall不是关键词，因此不能被程序员指定。
- naked call
采用1-4的调用约定时，如果必要的话，进入函数时编译器会产生代码来保存ESI，EDI，EBX，EBP寄存器，退出函数时则产生代码恢复这些寄存器的内容。naked call不产生这样的代码。
naked call不是类型修饰符，故必须和_declspec共同使用，如下：
__declspec( naked ) int func( formal_parameters )
{
// Function body
}
- 过时的调用约定
原来的一些调用约定可以不再使用。它们被定义成调用约定_stdcall或者_cdecl。例如：
#define CALLBACK __stdcall
#define WINAPI __stdcall
#define WINAPIV __cdecl
#define APIENTRY WINAPI
#define APIPRIVATE __stdcall
#define PASCAL __stdcall
表7-1显示了一个函数在几种调用约定下的修饰名（表中的“C++”函数指的是“C++”全局函数，不是成员函数），函数原型是void CALLTYPE test(void)，CALLTYPE可以是_cdecl、_fastcall、_stdcall。
表7-1 不同调用约定下的修饰名
| 调用约定
| extern “C”或.C文件
| .cpp, .cxx或/TP编译开关
|
| _cdecl
| _test
| ?test@@ZAXXZ
|
| _fastcall
| @test@0
| ?test@@YIXXZ
|
| _stdcall
| _test@0
| ?test@@YGXXZ
|
- 静态链接到MFC的规则DLL应用程序
该类DLL应用程序里头的输出函数可以被任意Win32程序使用，包括使用MFC的应用程序。输入函数有如下形式：
extern "C" EXPORT YourExportedFunction( );
如果没有extern “C”修饰，输出函数仅仅能从C++代码中调用。
DLL应用程序从CWinApp派生，但没有消息循环。
- 动态链接到MFC的规则DLL应用程序
该类DLL应用程序里头的输出函数可以被任意Win32程序使用，包括使用MFC的应用程序。但是，所有从DLL输出的函数应该以如下语句开始：
AFX_MANAGE_STATE(AfxGetStaticModuleState( ))
此语句用来正确地切换MFC模块状态。关于MFC的模块状态，后面第9章有详细的讨论。
其他方面同静态链接到MFC的规则DLL应用程序。
- 扩展DLL应用程序
该类DLL应用程序动态链接到MFC，它输出的函数仅可以被使用MFC且动态链接到MFC的应用程序使用。和规则DLL相比，有以下不同：
- 它没有一个从CWinApp派生的对象；
- 它必须有一个DllMain函数；
- DllMain调用AfxInitExtensionModule函数，必须检查该函数的返回值，如果返回0，DllMmain也返回0；
- 如果它希望输出CRuntimeClass类型的对象或者资源(Resources)，则需要提供一个初始化函数来创建一个CDynLinkLibrary对象。并且，有必要把初始化函数输出。
- 使用扩展DLL的MFC应用程序必须有一个从CWinApp派生的类，而且，一般在InitInstance里调用扩展DLL的初始化函数。
为什么要这样做和具体的代码形式，将在后面9.4.2节说明。
MFC类库也是以DLL的形式提供的。通常所说的动态链接到MFC 的DLL，指的就是实现MFC核心功能的MFCXX.DLL或者MFCXXD.DLL（XX是版本号，XXD表示调试版）。至于提供OLE（MFCOXXD.DLL或者MFCOXX0.DLL）和NET（MFCNXXD.DLL或者MFCNXX.DLL）服务的DLL就是动态链接到MFC核心DLL的扩展DLL。
其实，MFCXX.DLL可以认为是扩展DLL的一个特例，因为它也具备扩展DLL的上述特点。
- DLL应用程序的入口点是DllMain。
对程序员来说，DLL应用程序的入口点是DllMain。
DllMain负责初始化(Initialization)和结束(Termination)工作，每当一个新的进程或者该进程的新的线程访问DLL时，或者访问DLL的每一个进程或者线程不再使用DLL或者结束时，都会调用DllMain。但是，使用TerminateProcess或TerminateThread结束进程或者线程，不会调用DllMain。
DllMain的函数原型符合DllEntryPoint的要求，有如下结构：
BOOL WINAPI DllMain (HANDLE hInst,
ULONG ul_reason_for_call,LPVOID lpReserved)
{
switch( ul_reason_for_call ) {
case DLL_PROCESS_ATTACH:
...
case DLL_THREAD_ATTACH:
...
case DLL_THREAD_DETACH:
...
case DLL_PROCESS_DETACH:
...
}
return TRUE;
}
其中：
参数1是模块句柄；
参数2是指调用DllMain的类别，四种取值：新的进程要访问DLL；新的线程要访问DLL；一个进程不再使用DLL(Detach from DLL)；一个线程不再使用DLL(Detach from DLL)。
参数3保留。
如果程序员不指定DllMain，则编译器使用它自己的DllMain，该函数仅仅返回TRUE。
规则DLL应用程序使用了MFC的DllMain，它将调用DLL程序的应用程序对象(从CWinApp派生)的InitInstance函数和ExitInstance函数。
扩展DLL必须实现自己的DllMain。
- _DllMainCRTStartup
为了使用“C”运行库(CRT，C Run time Library)的DLL版本（多线程），一个DLL应用程序必须指定_DllMainCRTStartup为入口函数，DLL的初始化函数必须是DllMain。
_DllMainCRTStartup完成以下任务：当进程或线程捆绑(Attach)到DLL时为“C”运行时的数据(C Runtime Data)分配空间和初始化并且构造全局“C++”对象，当进程或者线程终止使用DLL(Detach)时，清理C Runtime Data并且销毁全局“C++”对象。它还调用DllMain和RawDllMain函数。
RawDllMain在DLL应用程序动态链接到MFC DLL时被需要，但它是静态的链接到DLL应用程序的。在讲述状态管理时解释其原因。
- DLL的函数和数据
DLL的函数分为两类：输出函数和内部函数。输出函数可以被其他模块调用，内部函数在定义它们的DLL程序内部使用。
虽然DLL可以输出数据，但一般的DLL程序的数据仅供内部使用。
- DLL程序和调用其输出函数的程序的关系
DLL模块被映射到调用它的进程的虚拟地址空间。
DLL使用的内存从调用进程的虚拟地址空间分配，只能被该进程的线程所访问。
DLL的句柄可以被调用进程使用；调用进程的句柄可以被DLL使用。
DLL使用调用进程的栈。
DLL定义的全局变量可以被调用进程访问；DLL可以访问调用进程的全局数据。使用同一DLL的每一个进程都有自己的DLL全局变量实例。如果多个线程并发访问同一变量，则需要使用同步机制；对一个DLL的变量，如果希望每个使用DLL的线程都有自己的值，则应该使用线程局部存储(TLS，Thread Local Strorage)。
- 传统的方法
在模块定义文件的EXPORT部分指定要输入的函数或者变量。语法格式如下：
entryname[=internalname] [@ordinal[NONAME]] [DATA] [PRIVATE]
其中：
entryname是输出的函数或者数据被引用的名称；
internalname同entryname;
@ordinal表示在输出表中的顺序号(index)；
NONAME仅仅在按顺序号输出时被使用（不使用entryname）；
DATA表示输出的是数据项，使用DLL输出数据的程序必须声明该数据项为_declspec(dllimport)。
上述各项中，只有entryname项是必须的，其他可以省略。
对于“C”函数来说，entryname可以等同于函数名；但是对“C++”函数（成员函数、非成员函数）来说，entryname是修饰名。可以从.map映像文件中得到要输出函数的修饰名，或者使用DUMPBIN /SYMBOLS得到，然后把它们写在.def文件的输出模块。DUMPBIN是VC提供的一个工具。
如果要输出一个“C++”类，则把要输出的数据和成员的修饰名都写入.def模块定义文件。
- 在命令行输出
对链接程序LINK指定/EXPORT命令行参数，输出有关函数。
- 使用MFC提供的修饰符号_declspec(dllexport)
在要输出的函数、类、数据的声明前加上_declspec(dllexport)的修饰符，表示输出。MFC提供了一些宏，就有这样的作用，如表7-2所示。
表7-2 MFC定义的输入输出修饰符
| 宏名称 | 宏内容
|
| AFX_CLASS_IMPORT | __declspec(dllexport)
|
| AFX_API_IMPORT | __declspec(dllexport)
|
| AFX_DATA_IMPORT | __declspec(dllexport)
|
| AFX_CLASS_EXPORT | __declspec(dllexport)
|
| AFX_API_EXPORT | __declspec(dllexport)
|
| AFX_DATA_EXPORT | __declspec(dllexport)
|
| AFX_EXT_CLASS
| #ifdef _AFXEXT AFX_CLASS_EXPORT #else AFX_CLASS_IMPORT
|
| AFX_EXT_API
| #ifdef _AFXEXT AFX_API_EXPORT #else AFX_API_IMPORT
|
| AFX_EXT_DATA
| #ifdef _AFXEXT AFX_DATA_EXPORT #else AFX_DATA_IMPORT
|
| AFX_EXT_DATADEF
|
像AFX_EXT_CLASS这样的宏，如果用于DLL应用程序的实现中，则表示输出（因为_AFX_EXT被定义，通常是在编译器的标识参数中指定该选项/D_AFX_EXT）；如果用于使用DLL的应用程序中，则表示输入（_AFX_EXT没有定义）。
要输出整个的类，对类使用_declspec(_dllexpot)；要输出类的成员函数，则对该函数使用_declspec(_dllexport)。如：
class AFX_EXT_CLASS CTextDoc : public CDocument
{
…
}
extern "C" AFX_EXT_API void WINAPI InitMYDLL();
这几种方法中，最好采用第三种，方便好用；其次是第一种，如果按顺序号输出，调用效率会高些；最次是第二种。
在“C++”下定义“C”函数，需要加extern “C”关键词。输出的“C”函数可以从“C”代码里
如果你想使用Microsoft Visual C++,懂得C++中关于类的内容将会有极大的帮助。如果你习惯使用简单的C，你只有实践过才能掌握对类的处理。在开始VC++之前，让我们来复习一下你应该弄清楚的关于类的内容。
在很大程度上来说类是一种结构。我们从一个例子入手来而不是仅说明规则。写一个类来描述直线。在.h文件里这样定义类：
class CLine
{
int m_nX1;
int m_nY1;
int m_nX2;
int m_nY2;
public:
// constructors
CLine();
CLine(int x1, int y1, int x2, int y2);
// destructor
~CLine();
// set the line data
void SetPoints(int x1, int y1, int x2, int y2);
// draw the line
void Draw();
} ;
简短的说一下命名惯例。类的名字通常是由‘C’打头；成员变量使用前缀‘m_’，接着按照微软的习惯使用一个字母来指明数据类型，然后是变量的名称。所有的单词用大写开头。我推荐这种微软的标准（叫做匈牙利法），因为它使用广泛而且容易看懂。这样的话以后你看到m_pPoint，你就会想到这是一个成员变量而且是指向POINT类型的指针；看到fData就会想到这是一个浮点值。
回到关于类的讨论。整型变量记录线的端点。注意它们是放在‘public:’之前的，表明使用这个类的程序员不能直接使用这些变量，它们不是“公开”使用的。那些在公有声明下面的函数是公开使用的。前面的两个叫做构造函数，这些函数总是在一个新的Cline对象被建立的时候执行。下面是它们被调用的一些时候：
// this calls CLine()
CLine MyLine;
// this is a pointer to a CLine class
CLine *pMyLine;
// this calls CLine()
pMyLine = new CLine;
// this is a pointer to a CLine class
CLine *pMyLine;
// this calls CLine(int x1, int y1, int x2, int y2)
pMyLine = new CLine(0,0,10,10);
// this calls CLine(int x1, int y1, int x2, int y2)
CLine MyLine(0,0,10,10);
所有的这些都建立了一条直线。有的直线被初始化为默认的设置有的则用了新的参数。关键字“new”在C++里建立新的对象，类似于C里的malloc。你必须对使用“new”的所有对象使用“delete”，就像在c里用free。不仅对类是这样，其他的数据类型也一样。我分配一个有100个整型数据的数组：
// a pointer to some integers
int *pNumbers;
// make memory for 100 of them
pNumbers = new int[100];
// set the first element to 0
pNumbers[0]=0;
// set the last element to 99
pNumbers[99]=99;
// free the memory.
delete [] pNumbers; CLine::CLine()
注意在delete后面的[]，这是在对程序说删除整个数组。如果你写的是“delete pnumbers;”，就只删除了第一个元素。这样就会造成内存泄漏。
对不起啊，让我们回到Cline的构造函数。一条直线在建立的时候自动条用构造函数，代码是这样的：
{
m_nX1=0;
m_nX2=0;
m_nY1=0;
m_nY2=0;
}
CLine::CLine(int x1, int y1, int x2, int y2)
{
m_nX1=x1;
m_nX2=x2;
m_nY1=y1;
m_nY2=y2;
}
我们看到，除了把类名和两个冒号(CLine::)放在函数名的前面.，函数的声明很像标准的C函数。一个差异是构造函数没有返回值，析构函数也是如此。析构函数是在我们的Cline对象被删除或出了生存空间后被自动调用的。比如：
// this is a pointer to a CLine class
CLine *pMyLine;
// this calls CLine()
pMyLine = new CLine;
// memory for the class is cleared up and ~CLine() is called
delete pMyLine;
{
// this calls CLine()
CLine MyLine;
}
// this '}' ends the section of the program where MyLine is
// valid. ~CLine() will be called. (MyLine goes out of 'scope')
对于我们这个类，~Cline()不必做任何事情。但你可以把做清理的代码放在这里，象回收类中分配的内存。以为现在不必清理所以函数是空的：
CLine::~CLine()
{
// do nothing
}
现在我们来填写另外的两个函数：
void CLine::SetPoints(int x1, int y1, int x2, int y2)
{
m_nX1=x1;
m_nX2=x2;
m_nY1=y1;
m_nY2=y2;
return;
}
void CLine::Draw()
{
// psuedo code here, these are operating system
// functions to draw a line
MoveTo(m_nX1, m_nY1);
LineTo(m_nX2, m_nY2);
return;
}
怎么调用这些它们呢？这里有两个例子。 一个使用了指针另一个没有用指针：
CLine *pLine = new CLine(0,0,10,10);
pLine->Draw();
delete pLine;
CLine MyLine;
MyLine.SetPoints(0,0,10,10);
MyLine.Draw();
这个类就完成了。现在这个类可以在别的类里。你可以用4个直线来建立一个正方形类CSquare：
class CSquare
{
CLine m_LineTop;
CLine m_LineLeft;
CLine m_LineBottom;
CLine m_LineRight;
//...
}
还有更好的，根据类的特性，你可以用Cline类来建立你自己的类。这个用法在VC里用的太多了。比如你想在程序里画直线，那你就会想用直线类就好了，但这样做还缺少一个重要的特性，不能设置直线的颜色。当然不用再来写新的类了，更简单的办法是继承Cline类。像这样：
class CColorLine : public CLine
{
public:
void Draw(long color);
};
现在怎么样了呢？这个类有Cline类的所有功能，而且我们可以使用另外一个可以设置颜色的Draw()函数，在CPP文件里代码是这样的：
void CColorLine::Draw(long color)
{
// psuedo code here, these are operating system
// functions to draw a line
SetColor(color);
CLine::Draw();
return;
}
现在我们有了另外一个类的上所有功能而且添加了一个额外的Draw函数。但这个函数跟原来的Draw函数是同名的！没关系，C++足够聪明，它能辩明：如果你调用Draw(color)就使用新的函数而如果你调用Draw()就用旧的函数。在代码里CLine::Draw()也许会使你感到陌生。这是在告诉程序调用基类的画线函数。我们不必在费时重写LineTo 和MoveTo的代码了，很好，不是么？现在我们可以这样做了：
CColorLine MyLine;
MyLine.SetPoints(0,0,10,10);
// assuming 0 is black, this will draw a black line.
MyLine.Draw(0);
扫一扫
8238
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
