8. 1. Win32的进程和线程概念

进程是一个可执行的程序，由私有虚拟地址空间、代码、数据和其他操作系统资源（如进程创建的文件、管道、同步对象等）组成。一个应用程序可以有一个或多个进程，一个进程可以有一个或多个线程，其中一个是主线程。

线程是操作系统分时调度分配 CPU时间的基本实体。一个线程可以执行程序的任意部分的代码，即使这部分代码被另一个线程并发地执行；一个进程的所有线程共享它的虚拟地址空间、全局变量和操作系统资源。

之所以有线程这个概念，是因为以线程而不是进程为调度对象效率更高：

• 由于创建新进程必须加载代码，而线程要执行的代码已经被映射到进程的地址空间，所以创建、执行线程的速度比进程更快。

• 一个进程的所有线程共享进程的地址空间和全局变量，所以简化了线程之间的通讯。

1. Win32的进程处理简介

   因为 MFC没有提供类处理进程，所以直接使用了Win32 API函数。

   1. 进程的创建

      调用 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。

   2. 进程的终止

进程在以下情况下终止：

• 调用 ExitProcess结束进程；

• 进程的主线程返回，隐含地调用 ExitProcess导致进程结束；

• 进程的最后一个线程终止；

• 调用 TerminateProcess终止进程。

• 当要结束一个 GDI进程时，发送WM_QUIT消息给主窗口，当然也可以从它的任一线程调用ExitProcess。

1. Win32的线程

   1. 线程的创建

使用 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级以外的任意线程抢占。

1. 线程的终止

以下情况终止一个线程：

• 调用了 ExitThread函数；

• 线程函数返回：主线程返回导致 ExitProcess被调用，其他线程返回导致ExitThread被调用；

• 调用 ExitProcess导致进程的所有线程终止；

• 调用 TerminateThread终止一个线程；

• 调用 TerminateProcess终止一个进程时，导致其所有线程的终止。

当用TerminateProcess或者TerminateThread终止进程或线程时，DLL的入口函数DllMain不会被执行（如果有DLL的话）。

1. 线程局部存储

如果希望每个线程都可以有线程局部 (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(

);

其中：

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释放索引。

1. 线程同步

   同步可以保证在一个时间内只有一个线程对某个资源（如操作系统资源等共享资源）有控制权。共享资源包括全局变量、公共数据成员或者句柄等。同步还可以使得有关联交互作用的代码按一定的顺序执行。

   Win32 提供了一组对象用来实现多线程的同步。

   这些对象有两种状态：获得信号 (Signaled)或者没有或则信号(Not signaled)。线程通过Win32 API提供的同步等待函数（Wait functions）来使用同步对象。一个同步对象在同步等待函数调用时被指定，调用同步函数地线程被阻塞(blocked)，直到同步对象获得信号。被阻塞的线程不占用CPU时间。

   1. 同步对象

同步对象有： Critical_section（关键段），Event（事件），Mutex（互斥对象），Semaphores（信号量）。

下面，解释怎么使用这些同步对象。

1. 关键段对象：

   首先，定义一个关键段对象 cs：

   CRITICAL_SECTION cs;

   然后，初始化该对象。初始化时把对象设置为 NOT_SINGALED，表示允许线程使用资源：

   InitializeCriticalSection(&cs);

   如果一段程序代码需要对某个资源进行同步保护，则这是一段关键段代码。在进入该关键段代码前调用 EnterCriticalSection函数，这样，其他线程都不能执行该段代码，若它们试图执行就会被阻塞。

   完成关键段的执行之后，调用 LeaveCriticalSection函数，其他的线程就可以继续执行该段代码。如果该函数不被调用，则其他线程将无限期的等待。

2. 事件对象

   首先，调用 CreateEvent函数创建一个事件对象，该函数返回一个事件句柄。然后，可以设置（SetEvent）或者复位(ResetEvent)一个事件对象，也可以发一个事件脉冲（PlusEvent），即设置一个事件对象，然后复位它。复位有两种形式：自动复位和人工复位。在创建事件对象时指定复位形式。。

   自动复位：当对象获得信号后，就释放下一个可用线程（优先级别最高的线程；如果优先级别相同，则等待队列中的第一个线程被释放）。

   人工复位：当对象获得信号后，就释放所有可利用线程。

   最后，使用 CloseHandle销毁创建的事件对象。

3. 互斥对象

   首先，调用 CreateMutex创建互斥对象；然后，调用等待函数，可以的话利用关键资源；最后，调用RealseMutex释放互斥对象。

   互斥对象可以在进程间使用，但关键段对象只能用于同一进程的线程之间。

4. 信号量对象

   在 Win32中，信号量的数值变为0时给以信号。在有多个资源需要管理时可以使用信号量对象。

   首先，调用 CreateSemaphore创建一个信号量；然后，调用等待函数，如果允许的话，则利用关键资源；最后，调用RealeaseSemaphore释放信号量对象。

5. 此外，还有其他句柄可以用来同步线程：

文件句柄（FILE HANDLES）

命名管道句柄（NAMED PIPE HANDELS）

控制台输入缓冲区句柄（CONSOLE INPUT BUFFER HANDLES）

通讯设备句柄（COMMUNICTION DEVICE HANDLES）

进程句柄（PROCESS HANDLES）

线程句柄（THREAD HANDLES）

例如，当一个进程或线程结束时，进程或线程句柄获得信号，等待该进程或者线程结束的线程被释放。

1. 等待函数

Win32 提供了一组等待函数用来让一个线程阻塞自己的执行。等待函数分三类：

1. 等待单个对象的 (FOR SINGLE OBJECT):

   这类函数包括：

   SignalObjectAndWait

   WaitForSingleObject

   WaitForSingleObjectEx

   函数参数包括同步对象的句柄和等待时间等。

   在以下情况下等待函数返回：

   同步对象获得信号时返回；

   等待时间达到了返回：如果等待时间不限制 (Infinite)，则只有同步对象获得信号才返回；如果等待时间为0，则在测试了同步对象的状态之后马上返回。

2. 等待多个对象的 (FOR MULTIPLE OBJECTS)

   这类函数包括：

   WaitForMultipleObjects

   WaitForMultipleObjectsEx

   MsgWaitForMultipleObjects

   MsgWaitForMultipleObjectsEx

   函数参数包括同步对象的句柄，等待时间，是等待一个还是多个同步对象等等。

   在以下情况下等待函数返回：

   一个或全部同步对象获得信号时返回（在参数中指定是等待一个或多个同步对象）；

   等待时间达到了返回：如果等待时间不限制 (Infinite)，则只有同步对象获得信号才返回；如果等待时间为0，则在测试了同步对象的状态之后马上返回。

3. 可以发出提示的函数 (ALTERABLE)

这类函数包括：

MsgWaitForMultipleObjectsEx

SignalObjectAndWait

WaitForMultipleObjectsEx

WaitForSingleObjectEx

这些函数主要用于重叠 (Overlapped)的I/O（异步I/O）。

1. 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派生并处理用户产生的事件和消息。

   1. 创建用户界面线程

通过以下步骤创建一个用户界面线程：

• 从 CWinThread派生一个有动态创建能力的类。使用DECLARE_DYNCREATE和IMPLEMENT_DYNCREATE宏来支持动态创建。

• 覆盖 CWinThread的一些虚拟函数，可以覆盖的函数见表5-4关于CWinThread的部分。其中，函数InitInstance是必须覆盖的，ExitInstance通常是要覆盖的。

• 使用 AfxBeginThread创建MFC线程对象和Win32线程对象。如果创建线程时没有指定CREATE_SUSPENDED，则开始执行线程。

• 如果创建线程是指定了 CREATE_SUSPENDED，则在适当的地方调用函数ResumeThread开始执行线程。

1. 创建工作者线程

   程序员不必从 CWinThread派生新的线程类，只需要提供一个控制函数,由线程启动后执行该函数。

   然后，使用 AfxBeginThread创建MFC线程对象和Win32线程对象。如果创建线程时没有指定CREATE_SUSPENDED（创建后挂起），则创建的新线程开始执行。

   如果创建线程是指定了 CREATE_SUSPENDED，则在适当的地方调用函数ResumeThread开始执行线程。

   虽然程序员没有从 CWinThread派生类，但是MFC给工作者线程提供了缺省的CWinThread对象。

2. AfxBeginThread

用户界面线程和工作者线程都是由 AfxBeginThread创建的。现在，考察该函数：MFC提供了两个重载版的AfxBeginThread，一个用于用户界面线程，另一个用于工作者线程，分别有如下的原型和过程：

1. 用户界面线程的 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下有用。

2. 工作者线程的 AfxBeginThread

   工作者线程的 AfxBeginThread的原型如下：

   CWinThread* AFXAPI AfxBeginThread(

   AFX_THREADPROC pfnThreadProc,

   LPVOID pParam,

   int nPriority,

   UINT nStackSize,

   DWORD dwCreateFlags,

   LPSECURITY_ATTRIBUTES lpSecurityAttrs)

   其中：

   参数 1指定控制函数的地址；

   参数 2指定传递给控制函数的参数；

   参数 3、4、5分别指定线程的优先级、堆栈大小、创建标识、安全属性，含义同用户界面线程。

3. AfxBeginThread 创建线程的流程

不论哪个AfxBeginThread，首先都是创建MFC线程对象，然后创建Win32线程对象。在创建MFC线程对象时，用户界面线程和工作者线程的创建分别调用了不同的构造函数。用户界面线程是从CWinThread派生的，所以，要先调用派生类的缺省构造函数，然后调用CWinThread的缺省构造函数。图8-1中两个构造函数所调用的CommonConstruct是MFC内部使用的成员函数。

1. 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在启动线程时，将创建本线程的线程状态，并且继承父线程的模块状态。

   

   　

   

   　

2. 线程的结束

   从图 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线程对象是有用的，当然程序员自己最后要记得销毁该线程对象。

3. 实现线程的消息循环

在 MFC中，消息循环是由线程完成的。一般地，可以使用MFC缺省的消息循环（即使用函数CWindThrad::Run），但是，有些时候需要程序员自己实现一个线程的消息循环，比如在用户界面线程进行一个长时间计算处理或者等待另一个线程时。一般有如下形式：

while ( bDoingBackgroundProcessing)

{

MSG msg;

while ( ::PeekMessage( &msg, NULL,0, 0, PM_NOREMOVE ) )

{

}

// 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

即可。

1. DLL的背景知识   

当前链接的目标代码(.obj)如果引用了一个函数却没有定义它，链接程序可能通过两种途径来解决这种从外部对该函数的引用：

• 静态链接

链接程序搜索一个或者多个库文件(标准库.lib)，直到在某个库中找到了含有所引用函数的对象模块，然后链接程序把这个对象模块拷贝到结果可执行文件(.exe)中。链接程序维护对该函数的所有引用，使它们指向该程序中现在含有该函数拷贝的地方。

• 动态链接

链接程序也是搜索一个或者多个库文件(输入库.lib)，当在某个库中找到了所引用函数的输入记录时，便把输入记录拷贝到结果可执行文件中，产生一次对该函数的动态链接。这里，输入记录不包含函数的代码或者数据，而是指定一个包含该函数代码以及该函数的顺序号或函数名的动态链接库。

当程序运行时，Windows装入程序，并寻找文件中出现的任意动态链接。对于每个动态链接，Windows装入指定的DLL并且把它映射到调用进程的虚拟地址空间（如果没有映射的话）。因此，调用和目标函数之间的实际链接不是在链接应用程序时一次完成的（静态），相反，是运行该程序时由Windows完成的（动态）。

这种动态链接称为加载时动态链接。还有一种动态链接方式下面会谈到。

1. 动态链接的方法

链接动态链接库里的函数的方法如下：

• 加载时动态链接(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模块从当前进程的虚拟空间移走。

1. 输入库(.lib)：

   输入库以.lib为扩展名，格式是COFF(Common object file format)。COFF标准库（静态链接库）的扩展名也是.lib。COFF格式的文件可以用dumpbin来查看。

   输入库包含了DLL中的输出函数或者输出数据的动态链接信息。当使用MFC创建DLL程序时，会生成输入库(.lib)和动态链接库(.dll)。

2. 输出文件(.exp)

   输出文件以.exp为扩展名，包含了输出的函数和数据的信息，链接程序使用它来创建DLL动态链接库。

3. 映像文件(.map)

   映像文件以.map为扩展名，包含了如下信息：

   模块名、时间戳、组列表（每一组包含了形式如section::offset的起始地址，长度、组名、类名）、公共符号列表(形式如section::offset的地址，符号名，虚拟地址flat address，定义符号的.obj文件)、入口点如section::offset、fixup列表。

4. lib.exe工具

   它可以用来创建输入库和输出文件。通常，不用使用lib.exe，如果工程目标是创建DLL程序，链接程序会完成输入库的创建。

   更详细的信息可以参见MFC使用手册和文档。

5. 链接规范（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++环境下可以使用。

6. 修饰名(Decoration name)

“C”或者“C++”函数在内部（编译和链接）通过修饰名识别。修饰名是编译器在编译函数定义或者原型时生成的字符串。有些情况下使用函数的修饰名是必要的，如在模块定义文件里头指定输出“C++”重载函数、构造函数、析构函数，又如在汇编代码里调用“C””或“C++”函数等。

修饰名由函数名、类名、调用约定、返回类型、参数等共同决定。

1. 调用约定

调用约定(Calling convention)决定以下内容：函数参数的压栈顺序，由调用者还是被调用者把参数弹出栈，以及产生函数修饰名的方法。MFC支持以下调用约定：

1. _cdecl

   按从右至左的顺序压参数入栈，由调用者把参数弹出栈。对于“C”函数或者变量，修饰名是在函数名前加下划线。对于“C++”函数，有所不同。

   如函数void test(void)的修饰名是_test；对于不属于一个类的“C++”全局函数，修饰名是?test@@ZAXXZ。

   这是MFC缺省调用约定。由于是调用者负责把参数弹出栈，所以可以给函数定义个数不定的参数，如printf函数。

2. _stdcall

   按从右至左的顺序压参数入栈，由被调用者把参数弹出栈。对于“C”函数或者变量，修饰名以下划线为前缀，然后是函数名，然后是符号“@”及参数的字节数，如函数int func(int a, double b)的修饰名是_func@12。对于“C++”函数，则有所不同。

   所有的Win32 API函数都遵循该约定。

3. _fastcall

   头两个DWORD类型或者占更少字节的参数被放入ECX和EDX寄存器，其他剩下的参数按从右到左的顺序压入栈。由被调用者把参数弹出栈，对于“C”函数或者变量，修饰名以“@”为前缀，然后是函数名，接着是符号“@”及参数的字节数，如函数int func(int a, double b)的修饰名是@func@12。对于“C++”函数，有所不同。

   未来的编译器可能使用不同的寄存器来存放参数。

4. thiscall

   仅仅应用于“C++”成员函数。this指针存放于CX寄存器，参数从右到左压栈。thiscall不是关键词，因此不能被程序员指定。

5. naked call

   采用1-4的调用约定时，如果必要的话，进入函数时编译器会产生代码来保存ESI，EDI，EBX，EBP寄存器，退出函数时则产生代码恢复这些寄存器的内容。naked call不产生这样的代码。

   naked call不是类型修饰符，故必须和_declspec共同使用，如下：

   __declspec( naked ) int func( formal_parameters )

   {

   // Function body

   }

6. 过时的调用约定

原来的一些调用约定可以不再使用。它们被定义成调用约定_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 不同调用约定下的修饰名

1. MFC的DLL应用程序的类型

1. 静态链接到MFC的规则DLL应用程序

   该类DLL应用程序里头的输出函数可以被任意Win32程序使用，包括使用MFC的应用程序。输入函数有如下形式：

   extern "C" EXPORT YourExportedFunction( );

   如果没有extern “C”修饰，输出函数仅仅能从C++代码中调用。

   DLL应用程序从CWinApp派生，但没有消息循环。

2. 动态链接到MFC的规则DLL应用程序

   该类DLL应用程序里头的输出函数可以被任意Win32程序使用，包括使用MFC的应用程序。但是，所有从DLL输出的函数应该以如下语句开始：

   AFX_MANAGE_STATE(AfxGetStaticModuleState( ))

   此语句用来正确地切换MFC模块状态。关于MFC的模块状态，后面第9章有详细的讨论。

   其他方面同静态链接到MFC的规则DLL应用程序。

3. 扩展DLL应用程序

该类DLL应用程序动态链接到MFC，它输出的函数仅可以被使用MFC且动态链接到MFC的应用程序使用。和规则DLL相比，有以下不同：

1. 它没有一个从CWinApp派生的对象；

2. 它必须有一个DllMain函数；

3. DllMain调用AfxInitExtensionModule函数，必须检查该函数的返回值，如果返回0，DllMmain也返回0；

4. 如果它希望输出CRuntimeClass类型的对象或者资源(Resources)，则需要提供一个初始化函数来创建一个CDynLinkLibrary对象。并且，有必要把初始化函数输出。

5. 使用扩展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的上述特点。

1. DLL的几点说明

1. 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。

2. _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应用程序的。在讲述状态管理时解释其原因。

3. DLL的函数和数据

   DLL的函数分为两类：输出函数和内部函数。输出函数可以被其他模块调用，内部函数在定义它们的DLL程序内部使用。

   虽然DLL可以输出数据，但一般的DLL程序的数据仅供内部使用。

4. DLL程序和调用其输出函数的程序的关系

DLL模块被映射到调用它的进程的虚拟地址空间。

DLL使用的内存从调用进程的虚拟地址空间分配，只能被该进程的线程所访问。

DLL的句柄可以被调用进程使用；调用进程的句柄可以被DLL使用。

DLL使用调用进程的栈。

DLL定义的全局变量可以被调用进程访问；DLL可以访问调用进程的全局数据。使用同一DLL的每一个进程都有自己的DLL全局变量实例。如果多个线程并发访问同一变量，则需要使用同步机制；对一个DLL的变量，如果希望每个使用DLL的线程都有自己的值，则应该使用线程局部存储(TLS，Thread Local Strorage)。

1. 输出函数的方法

1. 传统的方法

   在模块定义文件的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模块定义文件。

2. 在命令行输出

   对链接程序LINK指定/EXPORT命令行参数，输出有关函数。

3. 使用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”代码里调用。

图12.1 Terminal终端仿真程序

　　当用户选择File->Settings...命令时，会弹出一个Communication settings对话框，如图12.2所示。该对话框主要用来设置串行口，包括端口、波特率、每字节位数、校验、停止位数和流控制。

图12.2 Communication settings对话框

　　通过该对话框也可以设置TTY终端仿真的属性，如果选择New Line（自动换行），那么每当从串口读到回车符(‘\r’)时，视图中的正文就会换行，否则，只有在读到换行符(‘\n’)时才会换行。如果选择Local echo（本地回显），那么发送的字符会在视图中显示出来。

　　终端仿真程序的特点是数据的传输没有规律。因为键盘输入速度有限，所以发送的数据量较小，但接收的数据源是不确定的，所以有可能会有大量数据高速涌入的情况发生。根据Terminal的这些特性，我们在程序中创建了一个辅助工作者线程专门来监视串行口的输入。由于写入串行口的数据量不大，不会太费时，所以在主线程中完成写端口的任务是可以的，不必另外创建线程。

　　现在就让我们开始工作。请读者按下面几步进行：

用AppWizard建立一个名为Terminal的MFC应用程序。在MFC AppWizard对话框的第1步选择Single document，在第4步去掉Docking toolbar的选择，在第6步把CTerminalView的基类改为CEditView。

在Terminal工程的资源视图中打开IDR_MAINFRAME菜单资源。去掉Edit菜单和View菜单，并去掉File菜单中除Exit以外的所有菜单项。然后在File菜单中加入三个菜单项，如表12.5所示。

　表12.5 新菜单项

用ClassWizard为CTerminalDoc类创建三个与上表菜单消息对应的命令处理函数，使用缺省的函数名。为ID_FILE_CONNECT和ID_FILE_DISCONNECT命令创建命令更新处理函数。另外，用ClassWizard为该类加入CanCloseFrame成员函数。

用ClassWizard为CTerminalView类创建OnChar函数，该函数用来把用户键入的字符向串行口输出。

新建一个对话框模板资源，令其ID为IDD_COMSETTINGS。请按图12.2和表12.6设计对话框模板。

　表12.6 通信设置对话框中的主要控件

打开ClassWizard，为IDD_COMSETTINGS模板创建一个名为CSetupDlg的对话框类。为该类加入OnInitDialog成员函数，并按表12.7加入数据成员。

　表12.7 CSetupDlg类的数据成员

按清单12.6、12.7和12.8修改程序。清单12.6列出了CTerminalDoc类的部分代码，清单12.7是CTerminalView的部分代码，清单12.8是CSetupDlg类的部分代码。在本例中使用了WM_COMMNOTIFY消息。虽然在Win32中，WM_COMMNOTIFY消息已经取消，系统自己不会产生该消息，但Visual C++对该消息的定义依然保留。考虑到使用习惯，Terminal程序辅助线程通过发送该消息来通知视图有通信事件发生。

　清单12.6 CTerminalDoc类的部分代码

// TerminalDoc.h : interface of the CTerminalDoc class

//

/////////////////////////////////////////////////////////////////////////////

#define MAXBLOCK 2048

#define XON 0x11

#define XOFF 0x13

UINT CommProc(LPVOID pParam);　

class CTerminalDoc : public CDocument

{

protected: // create from serialization only

CTerminalDoc();

DECLARE_DYNCREATE(CTerminalDoc)

// Attributes

public:

　CWinThread* m_pThread; // 代表辅助线程

volatile BOOL m_bConnected;

volatile HWND m_hTermWnd;

volatile HANDLE m_hPostMsgEvent; // 用于WM_COMMNOTIFY消息的事件对象

OVERLAPPED m_osRead, m_osWrite; // 用于重叠读/写

volatile HANDLE m_hCom; // 串行口句柄

int m_nBaud;

int m_nDataBits;

BOOL m_bEcho;

int m_nFlowCtrl;

BOOL m_bNewLine;

int m_nParity;

CString m_sPort;

int m_nStopBits;　

// Operations

public:

　BOOL ConfigConnection();

BOOL OpenConnection();

void CloseConnection();

DWORD ReadComm(char *buf,DWORD dwLength);

DWORD WriteComm(char *buf,DWORD dwLength);// Overrides

. . .

};

/////////////////////////////////////////////////////////////////////////////

// TerminalDoc.cpp : implementation of the CTerminalDoc class

//

　＃i nclude "SetupDlg.h"

CTerminalDoc::CTerminalDoc()

{

// TODO: add one-time construction code here

　m_bConnected=FALSE;

m_pThread=NULL;

m_nBaud = 9600;

m_nDataBits = 8;

m_bEcho = FALSE;

m_nFlowCtrl = 0;

m_bNewLine = FALSE;

m_nParity = 0;

m_sPort = "COM2";

m_nStopBits = 0;}

CTerminalDoc::~CTerminalDoc()

{

　if(m_bConnected)

CloseConnection();

// 删除事件句柄

if(m_hPostMsgEvent)

CloseHandle(m_hPostMsgEvent);

if(m_osRead.hEvent)

CloseHandle(m_osRead.hEvent);

if(m_osWrite.hEvent)

CloseHandle(m_osWrite.hEvent);}

BOOL CTerminalDoc::OnNewDocument()

{

if (!CDocument::OnNewDocument())

return FALSE;

((CEditView*)m_viewList.GetHead())->SetWindowText(NULL);

// TODO: add reinitialization code here

// (SDI documents will reuse this document)

　// 为WM_COMMNOTIFY消息创建事件对象，手工重置，初始化为有信号的

if((m_hPostMsgEvent=CreateEvent(NULL, TRUE, TRUE, NULL))==NULL)

return FALSE;

memset(&m_osRead, 0, sizeof(OVERLAPPED));

memset(&m_osWrite, 0, sizeof(OVERLAPPED));

// 为重叠读创建事件对象，手工重置，初始化为无信号的

if((m_osRead.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL))==NULL)

return FALSE;

// 为重叠写创建事件对象，手工重置，初始化为无信号的

if((m_osWrite.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL))==NULL)

return FALSE;return TRUE;

}

void CTerminalDoc::OnFileConnect()

{

// TODO: Add your command handler code here

　if(!OpenConnection())

AfxMessageBox("Can't open connection");}

void CTerminalDoc::OnFileDisconnect()

{

// TODO: Add your command handler code here

　CloseConnection();

}

void CTerminalDoc::OnUpdateFileConnect(CCmdUI* pCmdUI)

{

// TODO: Add your command update UI handler code here

　pCmdUI->Enable(!m_bConnected);

}

void CTerminalDoc::OnUpdateFileDisconnect(CCmdUI* pCmdUI)

{

// TODO: Add your command update UI handler code here

　pCmdUI->Enable(m_bConnected);

}

　// 打开并配置串行口，建立工作者线程

BOOL CTerminalDoc::OpenConnection()

{

COMMTIMEOUTS TimeOuts;

POSITION firstViewPos;

CView *pView;

firstViewPos=GetFirstViewPosition();

pView=GetNextView(firstViewPos);

m_hTermWnd=pView->GetSafeHwnd();

if(m_bConnected)

return FALSE;

m_hCom=CreateFile(m_sPort, GENERIC_READ | GENERIC_WRITE, 0, NULL,

OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,

NULL); // 重叠方式

if(m_hCom==INVALID_HANDLE_VALUE)

return FALSE;

SetupComm(m_hCom,MAXBLOCK,MAXBLOCK);

SetCommMask(m_hCom, EV_RXCHAR);

// 把间隔超时设为最大，把总超时设为0将导致ReadFile立即返回并完成操作

TimeOuts.ReadIntervalTimeout=MAXDWORD;

TimeOuts.ReadTotalTimeoutMultiplier=0;

TimeOuts.ReadTotalTimeoutConstant=0;

/* 设置写超时以指定WriteComm成员函数中的

GetOverlappedResult函数的等待时间*/

TimeOuts.WriteTotalTimeoutMultiplier=50;

TimeOuts.WriteTotalTimeoutConstant=2000;

SetCommTimeouts(m_hCom, &TimeOuts);

if(ConfigConnection())

{

m_pThread=AfxBeginThread(CommProc, this, THREAD_PRIORITY_NORMAL,

0, CREATE_SUSPENDED, NULL); // 创建并挂起线程

if(m_pThread==NULL)

{

CloseHandle(m_hCom);

return FALSE;

}

else

{

m_bConnected=TRUE;

m_pThread->ResumeThread(); // 恢复线程运行

}

}

else

{

CloseHandle(m_hCom);

return FALSE;

}

return TRUE;

}　

　// 结束工作者线程，关闭串行口

void CTerminalDoc::CloseConnection()

{

if(!m_bConnected) return;

m_bConnected=FALSE;

//结束CommProc线程中WaitSingleObject函数的等待

SetEvent(m_hPostMsgEvent);

//结束CommProc线程中WaitCommEvent的等待

SetCommMask(m_hCom, 0);

//等待辅助线程终止

WaitForSingleObject(m_pThread->m_hThread, INFINITE);

m_pThread=NULL;

CloseHandle(m_hCom);

}　

// 让用户设置串行口

void CTerminalDoc::OnFileSettings()

{

// TODO: Add your command handler code here

　CSetupDlg dlg;

CString str;

dlg.m_bConnected=m_bConnected;

dlg.m_sPort=m_sPort;

str.Format("%d",m_nBaud);

dlg.m_sBaud=str;

str.Format("%d",m_nDataBits);

dlg.m_sDataBits=str;

dlg.m_nParity=m_nParity;

dlg.m_nStopBits=m_nStopBits;

dlg.m_nFlowCtrl=m_nFlowCtrl;

dlg.m_bEcho=m_bEcho;

dlg.m_bNewLine=m_bNewLine;

if(dlg.DoModal()==IDOK)

{

m_sPort=dlg.m_sPort;

m_nBaud=atoi(dlg.m_sBaud);

m_nDataBits=atoi(dlg.m_sDataBits);

m_nParity=dlg.m_nParity;

m_nStopBits=dlg.m_nStopBits;

m_nFlowCtrl=dlg.m_nFlowCtrl;

m_bEcho=dlg.m_bEcho;

m_bNewLine=dlg.m_bNewLine;

if(m_bConnected)

if(!ConfigConnection())

AfxMessageBox("Can't realize the settings!");

}}

　// 配置串行口

BOOL CTerminalDoc::ConfigConnection()

{

DCB dcb;

if(!GetCommState(m_hCom, &dcb))

return FALSE;

dcb.fBinary=TRUE;

dcb.BaudRate=m_nBaud; // 波特率

dcb.ByteSize=m_nDataBits; // 每字节位数

dcb.fParity=TRUE;

switch(m_nParity) // 校验设置

{

case 0: dcb.Parity=NOPARITY;

break;

case 1: dcb.Parity=EVENPARITY;

break;

case 2: dcb.Parity=ODDPARITY;

break;

default:;

}

switch(m_nStopBits) // 停止位

{

case 0: dcb.StopBits=ONESTOPBIT;

break;

case 1: dcb.StopBits=ONE5STOPBITS;

break;

case 2: dcb.StopBits=TWOSTOPBITS;

break;

default:;

}

// 硬件流控制设置

dcb.fOutxCtsFlow=m_nFlowCtrl==1;

dcb.fRtsControl=m_nFlowCtrl==1?

RTS_CONTROL_HANDSHAKE:RTS_CONTROL_ENABLE;

// XON/XOFF流控制设置

dcb.fInX=dcb.fOutX=m_nFlowCtrl==2;

dcb.XonChar=XON;

dcb.XoffChar=XOFF;

dcb.XonLim=50;

dcb.XoffLim=50;

return SetCommState(m_hCom, &dcb);

}　

　// 从串行口输入缓冲区中读入指定数量的字符

DWORD CTerminalDoc::ReadComm(char *buf,DWORD dwLength)

{

DWORD length=0;

COMSTAT ComStat;

DWORD dwErrorFlags;

ClearCommError(m_hCom,&dwErrorFlags,&ComStat);

length=min(dwLength, ComStat.cbInQue);

ReadFile(m_hCom,buf,length,&length,&m_osRead);

return length;

}

// 将指定数量的字符从串行口输出

DWORD CTerminalDoc::WriteComm(char *buf,DWORD dwLength)

{

BOOL fState;

DWORD length=dwLength;

COMSTAT ComStat;

DWORD dwErrorFlags;

ClearCommError(m_hCom,&dwErrorFlags,&ComStat);

fState=WriteFile(m_hCom,buf,length,&length,&m_osWrite);

if(!fState){

if(GetLastError()==ERROR_IO_PENDING)

{

GetOverlappedResult(m_hCom,&m_osWrite,&length,TRUE);// 等待

}

else

length=0;

}

return length;

}

// 工作者线程，负责监视串行口

UINT CommProc(LPVOID pParam)

{

OVERLAPPED os;

DWORD dwMask, dwTrans;

COMSTAT ComStat;

DWORD dwErrorFlags;

CTerminalDoc *pDoc=(CTerminalDoc*)pParam;

memset(&os, 0, sizeof(OVERLAPPED));

os.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL);

if(os.hEvent==NULL)

{

AfxMessageBox("Can't create event object!");

return (UINT)-1;

}

while(pDoc->m_bConnected)

{

ClearCommError(pDoc->m_hCom,&dwErrorFlags,&ComStat);

if(ComStat.cbInQue)

{

// 无限等待WM_COMMNOTIFY消息被处理完

WaitForSingleObject(pDoc->m_hPostMsgEvent, INFINITE);

ResetEvent(pDoc->m_hPostMsgEvent);

// 通知视图

PostMessage(pDoc->m_hTermWnd, WM_COMMNOTIFY, EV_RXCHAR, 0);

continue;

}

dwMask=0;

if(!WaitCommEvent(pDoc->m_hCom, &dwMask, &os)) // 重叠操作

{

if(GetLastError()==ERROR_IO_PENDING)

// 无限等待重叠操作结果

GetOverlappedResult(pDoc->m_hCom, &os, &dwTrans, TRUE);

else

{

CloseHandle(os.hEvent);

return (UINT)-1;

}

}

}

CloseHandle(os.hEvent);

return 0;

}　

BOOL CTerminalDoc::CanCloseFrame(CFrameWnd* pFrame)

{

// TODO: Add your specialized code here and/or call the base class

　SetModifiedFlag(FALSE); // 将文档的修改标志设置成未修改

return CDocument::CanCloseFrame(pFrame);

}

　　毫无疑问，CTerminalDoc类是研究重点。该类负责Terminal的通信任务，主要包括设置通信参数、打开和关闭串行口、建立和终止辅助工作线程、用辅助线程监视串行口等等。　　在CTerminalDoc类的头文件中，有些变量是用volatile关键字声明的。当两个线程都要用到某一个变量且该变量的值会被改变时，应该用volatile声明，该关键字的作用是防止优化编译器把变量从内存装入CPU寄存器中。如果变量被装入寄存器，那么两个线程有可能一个使用内存中的变量，一个使用寄存器中的变量，这会造成程序的错误执行。

　　成员m_bConnected用来表明当前是否存在一个通信连接。m_hTermWnd用来保存是视图的窗口句柄。m_hPostMsgEvent事件对象用于WM_COMMNOTIFY消息的允许和禁止。m_pThread用来指向AfxBeginThread创建的CWinThread对象，以便对线程进行控制。OVERLAPPED结构m_osRead和m_osWrite用于串行口的重叠读/写，程序应该为它们的hEvent成员创建事件句柄。

　　CTerminalDoc类的构造函数主要完成一些通信参数的初始化工作。OnNewDocument成员函数创建了三个事件对象，CTerminalDoc的析构函数关闭串行口并删除事件对象句柄。

　　OnFileSettings是File->Settings...的命令处理函数，该函数弹出一个CSetupDlg对话框来设置通信参数。实际的设置工作由ConfigConnection函数完成，在OpenConnection和OnFileSettings中都会调用该函数。

　　OpenConnection负责打开串行口并建立辅助工作线程，当用户选择了File->Connect命令时，消息处理函数OnFileConnect将调用该函数。该函数调用CreateFile以重叠方式打开指定的串行口并把返回的句柄保存在m_hCom成员中。接着，函数对m_hCom通信设备进行各种设置。需要注意的是对超时的设定，将读间隔超时设置为MAXDWORD并使其它读超时参数为0会导致ReadFile函数立即完成操作并返回，而不管读入了多少字符。设置超时就规定了GetOverlappedResult函数的等待时间，因此有必要将写超时设置成适当的值，这样如果不能完成写串口的任务，GetOverlappedResult函数会在超过规定超时后结束等待并报告实际传输的字符数。

　　如果对m_hCom设置成功，则函数会建立一个辅助线程并暂时将其挂起。在最后，调用CWinThread:: ResumeThread使线程开始运行。

　　OpenConnection调用成功后，线程函数CommProc就开始工作。该函数的主体是一个while循环，在该循环内，混合了两种方法监视串行口输入的方法。先是调用ClearCommError函数查询输入缓冲区中是否有字符，如果有，就向视图发送WM_COMMNOTIFY消息通知其接收字符。如果没有，则调用WaitCommEvent函数监视EV_RXCHAR通信事件，该函数执行重叠操作，紧接着调用的GetOverlappedResult函数无限等待通信事件，如果EV_RXCHAR事件发生（串口收到字符并放入输入缓冲区中），那么函数就结束等待。

　　上述两种方法的混合使用兼顾了线程的效率和可靠性。如果只用ClearCommError函数，则辅助线程将不断耗费CPU时间来查询，效率较低。如果只用WaitCommEvent来监视，那么由于该函数对输入缓冲区中已有的字符不会产生EV_RXCHAR事件，因此在通信速率较高时，会造成数据的延误和丢失。

　　注意到辅助线程用m_PostMsgEvent事件对象来同步WM_COMMNOTIFY消息的发送。在发送消息之前，WaitForSingleObject函数无限等待m_PostMsgEvent对象，WM_COMMNOTIFY的消息处理函数CTerminalView::OnCommNotify在返回时会把该对象置为有信号，因此，如果WaitForSingleObject函数返回，则说明上一个WM_COMMNOTIFY消息已被处理完，这时才能发下一个消息，在发消息前还要调用ResetEvent把m_PostMsgEvent对象置为无信号的，以供下次使用。

　　由于PostMessage函数在消息队列中放入消息后会立即返回，所以如果不采取上述措施，那么辅助线程可能在主线程未处理之前重复发出WM_COMMNOTIFY消息，这会降低系统的效率。

　　可能有读者会问，为什么不用SendMessage？该函数在发送的消息被处理完毕后才返回，这样不就不用考虑同步问题了吗？是的，本例中也可以使用SendMessage，但该函数会阻塞辅助线程的执行直到消息处理完毕，这会降低效率。如果用PostMessage，那么在函数立即返回后线程还可以干别的事情，因此，考虑到效率问题，这里使用了PostMessage而不是SendMessage。

　　函数ReadComm和WriteComm分别用来从m_hCom通信设备中读/写指定数量的字符。ReadComm函数很简单，由于对读超时的特殊设定，ReadFile函数会立即返回并完成操作，并在length变量中报告实际读入的字符数。此时，没有必要调用等待函数或GetOverlappedResult。在WriteComm中，调用GerOverlappedResult来等待操作结果，直到超时发生。不管是否超时，该函数在结束等待后都会报告实际的传输字符数。

　　CloseConnection函数的主要任务是终止辅助线程并关闭m_hCom通信设备。为了终止线程，该函数设置了一系列信号，以结束辅助线程中的等待和循环，然后调用WaitForSingleObject等待线程结束。清单12.7 CTerminalView类的部分代码

// TerminalView.h : interface of the CTerminalView class

/////////////////////////////////////////////////////////////////////////////

class CTerminalView : public CEditView

{

. . .afx_msg LRESULT OnCommNotify(WPARAM wParam, LPARAM lParam);

DECLARE_MESSAGE_MAP()

};

// TerminalView.cpp : implementation of the CTerminalView class

//

BEGIN_MESSAGE_MAP(CTerminalView, CEditView)

. . .ON_MESSAGE(WM_COMMNOTIFY, OnCommNotify)

END_MESSAGE_MAP()

　LRESULT CTerminalView::OnCommNotify(WPARAM wParam, LPARAM lParam)

{

char buf[MAXBLOCK/4];

CString str;

int nLength, nTextLength;

CTerminalDoc* pDoc=GetDocument();

CEdit& edit=GetEditCtrl();

if(!pDoc->m_bConnected ||

(wParam & EV_RXCHAR)!=EV_RXCHAR) // 是否是EV_RXCHAR事件?

{

SetEvent(pDoc->m_hPostMsgEvent); // 允许发送下一个WM_COMMNOTIFY消息

return 0L;

}

nLength=pDoc->ReadComm(buf,100);

if(nLength)

{

nTextLength=edit.GetWindowTextLength();

edit.SetSel(nTextLength,nTextLength); //移动插入光标到正文末尾

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

{

switch(buf[i])

{

case '\r': // 回车

if(!pDoc->m_bNewLine)

break;

case '\n': // 换行

str+="\r\n";

break;

case '\b': // 退格

edit.SetSel(-1, 0);

edit.ReplaceSel(str);

nTextLength=edit.GetWindowTextLength();

edit.SetSel(nTextLength-1,nTextLength);

edit.ReplaceSel(""); //回退一个字符

str="";

break;

case '\a': // 振铃

MessageBeep((UINT)-1);

break;

default :

str+=buf[i];

}

}

edit.SetSel(-1, 0);

edit.ReplaceSel(str); // 向编辑视图中插入收到的字符

}

SetEvent(pDoc->m_hPostMsgEvent); // 允许发送下一个WM_COMMNOTIFY消息

return 0L;

}　

void CTerminalView::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)

{

// TODO: Add your message handler code here and/or call default

　CTerminalDoc* pDoc=GetDocument();

char c=(char)nChar;

if(!pDoc->m_bConnected)return;

pDoc->WriteComm(&c, 1);

if(pDoc->m_bEcho) CEditView::OnChar(nChar, nRepCnt, nFlags); // 本地回显

}

　　CTerminalView是CEditView的派生类，利用CEditView的编辑功能，可以大大简化程序的设计。

　　OnChar函数对WM_CHAR消息进行处理，它调用CTerminalDoc::WriteComm把用户键入的字符从串行口输出。如果设置了Local echo，那么就调用CEditView::OnChar把字符输出到视图中。

　　OnCommNotify是WM_COMMNOTIFY消息的处理函数。该函数调用CTerminalDoc::ReadComm从串行口输入缓冲区中读入字符并把它们输出到编辑视图中。在输出前，函数会对一些特殊字符进行处理。如果读者对控制编辑视图的代码不太明白，那么请参见6.1.4。在函数返回时，要调用SetEvent把m_hPostMsgEvent置为有信号。　

清单12.8 CSetupDlg类的部分代码// SetupDlg.h : header file

//

class CSetupDlg : public CDialog

{

　. . .

public:

BOOL m_bConnected;

. . .};

// SetupDlg.cpp : implementation file

//

BOOL CSetupDlg::OnInitDialog()

{

CDialog::OnInitDialog();

// TODO: Add extra initialization here

　GetDlgItem(IDC_PORT)->EnableWindow(!m_bConnected);

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

// EXCEPTION: OCX Property Pages should return FALSE

}

　　CSetupDlg的主要任务是配置通信参数。在OnInitDialog函数中，要根据当前是否连接来允许/禁止Port组合框。因为在打开一个连接后，显然不能随便改变端口。　

【程序91】
题目：时间函数举例1
1.程序分析：
2.程序源代码：
＃i nclude "stdio.h"
＃i nclude "time.h"
void main()
{ time_t lt; /*define a longint time varible*/
lt=time(NULL);/*system time and date*/
printf(ctime(<)); /*english format output*/
printf(asctime(localtime(<)));/*tranfer to tm*/
printf(asctime(gmtime(<))); /*tranfer to Greenwich time*/
}
==============================================================
【程序92】
题目：时间函数举例2
1.程序分析：　　　　　　　　　　　
2.程序源代码：
/*calculate time*/
＃i nclude "time.h"
＃i nclude "stdio.h"
main()
{ time_t start,end;
int i;
start=time(NULL);
for(i=0;i<3000;i++)
{ printf("\1\1\1\1\1\1\1\1\1\1\n");}
end=time(NULL);
printf("\1: The different is %6.3f\n",difftime(end,start));
}
==============================================================
【程序93】
题目：时间函数举例3
1.程序分析：
2.程序源代码：
/*calculate time*/
＃i nclude "time.h"
＃i nclude "stdio.h"
main()
{ clock_t start,end;
int i;
double var;
start=clock();
for(i=0;i<10000;i++)
{ printf("\1\1\1\1\1\1\1\1\1\1\n");}
end=clock();
printf("\1: The different is %6.3f\n",(double)(end-start));
}
==============================================================
【程序94】
题目：时间函数举例4,一个猜数游戏，判断一个人反应快慢。（版主初学时编的）
1.程序分析：
2.程序源代码：
＃i nclude "time.h"
＃i nclude "stdlib.h"
＃i nclude "stdio.h"
main()
{char c;
clock_t start,end;
time_t a,b;
double var;
int i,guess;
srand(time(NULL));
printf("do you want to play it.('y' or 'n') \n");
loop:
while((c=getchar())=='y')
{
i=rand()%100;
printf("\nplease input number you guess:\n");
start=clock();
a=time(NULL);
scanf("%d",&guess);
while(guess!=i)
{if(guess>i)
{printf("please input a little smaller.\n");
scanf("%d",&guess);}
else
{printf("please input a little bigger.\n");
scanf("%d",&guess);}
}
end=clock();
b=time(NULL);
printf("\1: It took you %6.3f seconds\n",var=(double)(end-start)/18.2);
printf("\1: it took you %6.3f seconds\n\n",difftime(b,a));
if(var<15)
printf("\1\1 You are very clever! \1\1\n\n");
else if(var<25)
printf("\1\1 you are normal! \1\1\n\n");
else
printf("\1\1 you are stupid! \1\1\n\n");
printf("\1\1 Congradulations \1\1\n\n");
printf("The number you guess is %d",i);
}
printf("\ndo you want to try it again?(\"yy\".or.\"n\")\n");
if((c=getch())=='y')
goto loop;
}
==============================================================
【程序95】
题目：家庭财务管理小程序
1.程序分析：
2.程序源代码：
/*money management system*/
＃i nclude "stdio.h"
＃i nclude "dos.h"
main()
{
FILE *fp;
struct date d;
float sum,chm=0.0;
int len,i,j=0;
int c;
char ch[4]="",ch1[16]="",chtime[12]="",chshop[16],chmoney[8];
pp: clrscr();
sum=0.0;
gotoxy(1,1);printf("|---------------------------------------------------------------------------|");
gotoxy(1,2);printf("| money management system(C1.0) 2000.03 |");
gotoxy(1,3);printf("|---------------------------------------------------------------------------|");
gotoxy(1,4);printf("| -- money records -- | -- today cost list -- |");
gotoxy(1,5);printf("| ------------------------ |-------------------------------------|");
gotoxy(1,6);printf("| date: -------------- | |");
gotoxy(1,7);printf("| | | | |");
gotoxy(1,8);printf("| -------------- | |");
gotoxy(1,9);printf("| thgs: ------------------ | |");
gotoxy(1,10);printf("| | | | |");
gotoxy(1,11);printf("| ------------------ | |");
gotoxy(1,12);printf("| cost: ---------- | |");
gotoxy(1,13);printf("| | | | |");
gotoxy(1,14);printf("| ---------- | |");
gotoxy(1,15);printf("| | |");
gotoxy(1,16);printf("| | |");
gotoxy(1,17);printf("| | |");
gotoxy(1,18);printf("| | |");
gotoxy(1,19);printf("| | |");
gotoxy(1,20);printf("| | |");
gotoxy(1,21);printf("| | |");
gotoxy(1,22);printf("| | |");
gotoxy(1,23);printf("|---------------------------------------------------------------------------|");
i=0;
getdate(&d);
sprintf(chtime,"%4d.%02d.%02d",d.da_year,d.da_mon,d.da_day);
for(;;)
{
gotoxy(3,24);printf(" Tab __browse cost list Esc __quit");
gotoxy(13,10);printf(" ");
gotoxy(13,13);printf(" ");
gotoxy(13,7);printf("%s",chtime);
j=18;
ch[0]=getch();
if(ch[0]==27)
break;
strcpy(chshop,"");
strcpy(chmoney,"");
if(ch[0]==9)
{
mm:i=0;
fp=fopen("home.dat","r+");
gotoxy(3,24);printf(" ");
gotoxy(6,4);printf(" list records ");
gotoxy(1,5);printf("|-------------------------------------|");
gotoxy(41,4);printf(" ");
gotoxy(41,5);printf(" |");
while(fscanf(fp,"%10s%14s%f\n",chtime,chshop,&chm)!=EOF)
{ if(i==36)
{ getch();
i=0;}
if ((i%36)<17)
{ gotoxy(4,6+i);
printf(" ");
gotoxy(4,6+i);}
else
if((i%36)>16)
{ gotoxy(41,4+i-17);
printf(" ");
gotoxy(42,4+i-17);}
i++;
sum=sum+chm;
printf("%10s %-14s %6.1f\n",chtime,chshop,chm);}
gotoxy(1,23);printf("|---------------------------------------------------------------------------|");
gotoxy(1,24);printf("| |");
gotoxy(1,25);printf("|---------------------------------------------------------------------------|");
gotoxy(10,24);printf("total is %8.1f$",sum);
fclose(fp);
gotoxy(49,24);printf("press any key to.....");getch();goto pp;
}
else
{
while(ch[0]!='\r')
{ if(j<10)
{ strncat(chtime,ch,1);
j++;}
if(ch[0]==8)
{
len=strlen(chtime)-1;
if(j>15)
{ len=len+1; j=11;}
strcpy(ch1,"");
j=j-2;
strncat(ch1,chtime,len);
strcpy(chtime,"");
strncat(chtime,ch1,len-1);
gotoxy(13,7);printf(" ");}
gotoxy(13,7);printf("%s",chtime);ch[0]=getch();
if(ch[0]==9)
goto mm;
if(ch[0]==27)
exit(1);
}
gotoxy(3,24);printf(" ");
gotoxy(13,10);
j=0;
ch[0]=getch();
while(ch[0]!='\r')
{ if (j<14)
{ strncat(chshop,ch,1);
j++;}
if(ch[0]==8)
{ len=strlen(chshop)-1;
strcpy(ch1,"");
j=j-2;
strncat(ch1,chshop,len);
strcpy(chshop,"");
strncat(chshop,ch1,len-1);
gotoxy(13,10);printf(" ");}
gotoxy(13,10);printf("%s",chshop);ch[0]=getch();}
gotoxy(13,13);
j=0;
ch[0]=getch();
while(ch[0]!='\r')
{ if (j<6)
{ strncat(chmoney,ch,1);
j++;}
if(ch[0]==8)
{ len=strlen(chmoney)-1;
strcpy(ch1,"");
j=j-2;
strncat(ch1,chmoney,len);
strcpy(chmoney,"");
strncat(chmoney,ch1,len-1);
gotoxy(13,13);printf(" ");}
gotoxy(13,13);printf("%s",chmoney);ch[0]=getch();}
if((strlen(chshop)==0)||(strlen(chmoney)==0))
continue;
if((fp=fopen("home.dat","a+"))!=NULL);
fprintf(fp,"%10s%14s%6s",chtime,chshop,chmoney);
fputc('\n',fp);
fclose(fp);
i++;
gotoxy(41,5+i);
printf("%10s %-14s %-6s",chtime,chshop,chmoney);
}}}
==============================================================
【程序96】
题目：计算字符串中子串出现的次数
1.程序分析：
2.程序源代码：
＃i nclude "string.h"
＃i nclude "stdio.h"
main()
{ char str1[20],str2[20],*p1,*p2;
int sum=0;
printf("please input two strings\n");
scanf("%s%s",str1,str2);
p1=str1;p2=str2;
while(*p1!='\0')
{
if(*p1==*p2)
{while(*p1==*p2&&*p2!='\0')
{p1++;
p2++;}
}
else
p1++;
if(*p2=='\0')
sum++;
p2=str2;
}
printf("%d",sum);
getch();}
==============================================================
【程序97】
题目：从键盘输入一些字符，逐个把它们送到磁盘上去，直到输入一个#为止。
1.程序分析：　　　　　
2.程序源代码：
＃i nclude "stdio.h"
main()
{ FILE *fp;
char ch,filename[10];
scanf("%s",filename);
if((fp=fopen(filename,"w"))==NULL)
{printf("cannot open file\n");
exit(0);}
ch=getchar();
ch=getchar();
while(ch!='#')
{fputc(ch,fp);putchar(ch);
ch=getchar();
}
fclose(fp);
}
==============================================================
【程序98】
题目：从键盘输入一个字符串，将小写字母全部转换成大写字母，然后输出到一个磁盘文件“test”中保存。
　　　输入的字符串以！结束。
1.程序分析：
2.程序源代码：
＃i nclude "stdio.h"
main()
{FILE *fp;
char str[100],filename[10];
int i=0;
if((fp=fopen("test","w"))==NULL)
{ printf("cannot open the file\n");
exit(0);}
printf("please input a string:\n");
gets(str);
while(str[i]!='!')
{ if(str[i]>='a'&&str[i]<='z')
str[i]=str[i]-32;
fputc(str[i],fp);
i++;}
fclose(fp);
fp=fopen("test","r");
fgets(str,strlen(str)+1,fp);
printf("%s\n",str);
fclose(fp);
}
==============================================================
【程序99】
题目：有两个磁盘文件A和B,各存放一行字母，要求把这两个文件中的信息合并（按字母顺序排列），
　　　输出到一个新文件C中。
1.程序分析：
2.程序源代码：
＃i nclude "stdio.h"
main()
{ FILE *fp;
int i,j,n,ni;
char c[160],t,ch;
if((fp=fopen("A","r"))==NULL)
{printf("file A cannot be opened\n");
exit(0);}
printf("\n A contents are :\n");
for(i=0;(ch=fgetc(fp))!=EOF;i++)
{c[i]=ch;
putchar(c[i]);
}
fclose(fp);
ni=i;
if((fp=fopen("B","r"))==NULL)
{printf("file B cannot be opened\n");
exit(0);}
printf("\n B contents are :\n");
for(i=0;(ch=fgetc(fp))!=EOF;i++)
{c[i]=ch;
putchar(c[i]);
}
fclose(fp);
n=i;
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
if(c[i]>c[j])
{t=c[i];c[i]=c[j];c[j]=t;}
printf("\n C file is:\n");
fp=fopen("C","w");
for(i=0;i<n;i++)
{ putc(c[i],fp);
putchar(c[i]);
}
fclose(fp);
}
==============================================================
【程序100】
题目：有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），计算出
　　　平均成绩，况原有的数据和计算出的平均分数存放在磁盘文件"stud"中。
1.程序分析：
2.程序源代码：
＃i nclude "stdio.h"
struct student
{ char num[6];
char name[8];
int score[3];
float avr;
} stu[5];
main()
{int i,j,sum;
FILE *fp;
/*input*/
for(i=0;i<5;i++)
{ printf("\n please input No. %d score:\n",i);
printf("stuNo:");
scanf("%s",stu[i].num);
printf("name:");
scanf("%s",stu[i].name);
sum=0;
for(j=0;j<3;j++)
{ printf("score %d.",j+1);
scanf("%d",&stu[i].score[j]);
sum+=stu[i].score[j];
}
stu[i].avr=sum/3.0;
}
fp=fopen("stud","w");
for(i=0;i<5;i++)
if(fwrite(&stu[i],sizeof(struct student),1,fp)!=1)
printf("file write error\n");
fclose(fp);
}

【程序81】
题目：809*??=800*??+9*??+1 其中??代表的两位数,8*??的结果为两位数，9*??的结果为3位数。求??代表的两位数，及809*??后的结果。
1.程序分析：
2.程序源代码：
output(long b,long i)
{ printf("\n%ld/%ld=809*%ld+%ld",b,i,i,b%i);
}
main()
{long int a,b,i;
a=809;
for(i=10;i<100;i++)
{b=i*a+1;
if(b>=1000&&b<=10000&&8*i<100&&9*i>=100)
output(b,i); }
}
==============================================================
【程序82】
题目：八进制转换为十进制
1.程序分析：　　　　　　　　　　　
2.程序源代码：
main()
{ char *p,s[6];int n;
p=s;
gets(p);
n=0;
while(*(p)!='\0')
{n=n*8+*p-'0';
p++;}
printf("%d",n);
}
==============================================================
【程序83】
题目：求0—7所能组成的奇数个数。
1.程序分析：
2.程序源代码：
main()
{
long sum=4,s=4;
int j;
for(j=2;j<=8;j++)/*j is place of number*/
{ printf("\n%ld",sum);
if(j<=2)
s*=7;
else
s*=8;
sum+=s;}
printf("\nsum=%ld",sum);
}
==============================================================
【程序84】
题目：一个偶数总能表示为两个素数之和。
1.程序分析：
2.程序源代码：
＃i nclude "stdio.h"
＃i nclude "math.h"
main()
{ int a,b,c,d;
scanf("%d",&a);
for(b=3;b<=a/2;b+=2)
{ for(c=2;c<=sqrt(b);c++)
if(b%c==0) break;
if(c>sqrt(b))
d=a-b;
else
break;
for(c=2;c<=sqrt(d);c++)
if(d%c==0) break;
if(c>sqrt(d))
printf("%d=%d+%d\n",a,b,d);
}
}
==============================================================
【程序85】
题目：判断一个素数能被几个9整除
1.程序分析：
2.程序源代码：
main()
{ long int m9=9,sum=9;
int zi,n1=1,c9=1;
scanf("%d",&zi);
while(n1!=0)
{ if(!(sum%zi))
n1=0;
else
{m9=m9*10;
sum=sum+m9;
c9++;
}
}
printf("%ld,can be divided by %d \"9\"",sum,c9);
}
==============================================================
【程序86】
题目：两个字符串连接程序
1.程序分析：
2.程序源代码：
＃i nclude "stdio.h"
main()
{char a[]="acegikm";
char b[]="bdfhjlnpq";
char c[80],*p;
int i=0,j=0,k=0;
while(a[i]!='\0'&&b[j]!='\0')
{if (a[i] { c[k]=a[i];i++;}
else
c[k]=b[j++];
k++;
}
c[k]='\0';
if(a[i]=='\0')
p=b+j;
else
p=a+i;
strcat(c,p);
puts(c);
}
==============================================================
【程序87】
题目：回答结果（结构体变量传递）
1.程序分析：　　　　　
2.程序源代码：
＃i nclude "stdio.h"
struct student
{ int x;
char c;
} a;
main()
{a.x=3;
a.c='a';
f(a);
printf("%d,%c",a.x,a.c);
}
f(struct student b)
{
b.x=20;
b.c='y';
}
==============================================================
【程序88】
题目：读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的＊。
1.程序分析：
2.程序源代码：
main()
{int i,a,n=1;
while(n<=7)
{ do {
　　　scanf("%d",&a);
　　　}while(a<1||a>50);
for(i=1;i<=a;i++)
　printf("*");
printf("\n");
n++;}
getch();
}
==============================================================
【程序89】
题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：
　　　每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。
1.程序分析：
2.程序源代码：
main()
{int a,i,aa[4],t;
scanf("%d",&a);
aa[0]=a%10;
aa[1]=a%100/10;
aa[2]=a%1000/100;
aa[3]=a/1000;
for(i=0;i<=3;i++)
　{aa[i]+=5;
　aa[i]%=10;
　}
for(i=0;i<=3/2;i++)
　{t=aa[i];
　aa[i]=aa[3-i];
　aa[3-i]=t;
　}
for(i=3;i>=0;i--)
printf("%d",aa[i]);
}
==============================================================
【程序90】
题目：专升本一题，读结果。
1.程序分析：
2.程序源代码：
＃i nclude "stdio.h"
#define M 5
main()
{int a[M]={1,2,3,4,5};
int i,j,t;
i=0;j=M-1;
while(i {t=*(a+i);
*(a+i)=*(a+j);
*(a+j)=t;
i++;j--;
}
for(i=0;i printf("%d",*(a+i));
}

【程序61】
题目：打印出杨辉三角形（要求打印出10行如下图）　　　
1.程序分析：
　　　 　　 1
　　　　　　1 　1
　　　　　　1 　2 　1
　　　　　　1　 3 　3　 1
　　　　　　1　 4　 6 　4 　1
　　　　　　1　 5　 10　10　5 　1　
2.程序源代码：
main()
{int i,j;
int a[10][10];
printf("\n");
for(i=0;i<10;i++)
　{a[i][0]=1;
　a[i][i]=1;}
for(i=2;i<10;i++)
　for(j=1;j<i;j++)
　a[i][j]=a[i-1][j-1]+a[i-1][j];
for(i=0;i<10;i++)
　{for(j=0;j<=i;j++)
　printf("%5d",a[i][j]);
　printf("\n");
　}
}
==============================================================
【程序62】
题目：学习putpixel画点。
1.程序分析：　　　　　　　　　　　　
2.程序源代码：
＃i nclude "stdio.h"
＃i nclude "graphics.h"
main()
{
int i,j,driver=VGA,mode=VGAHI;
initgraph(&driver,&mode,"");
setbkcolor(YELLOW);
for(i=50;i<=230;i+=20)
　for(j=50;j<=230;j++)
　putpixel(i,j,1);
for(j=50;j<=230;j+=20)
　for(i=50;i<=230;i++)
　putpixel(i,j,1);
}
==============================================================
【程序63】
题目：画椭圆ellipse　　　
1.程序分析：
2.程序源代码：
＃i nclude "stdio.h"
＃i nclude "graphics.h"
＃i nclude "conio.h"
main()
{
int x=360,y=160,driver=VGA,mode=VGAHI;
int num=20,i;
int top,bottom;
initgraph(&driver,&mode,"");
top=y-30;
bottom=y-30;
for(i=0;i<num;i++)
{
ellipse(250,250,0,360,top,bottom);
top-=5;
bottom+=5;
}
getch();
}
==============================================================
【程序64】
题目：利用ellipse and rectangle 画图。
1.程序分析：
2.程序源代码：
＃i nclude "stdio.h"
＃i nclude "graphics.h"
＃i nclude "conio.h"
main()
{
int driver=VGA,mode=VGAHI;
int i,num=15,top=50;
int left=20,right=50;
initgraph(&driver,&mode,"");
for(i=0;i<num;i++)
{
ellipse(250,250,0,360,right,left);
ellipse(250,250,0,360,20,top);
rectangle(20-2*i,20-2*i,10*(i+2),10*(i+2));
right+=5;
left+=5;
top+=10;
}
getch();
}
==============================================================
【程序65】
题目：一个最优美的图案。　　　
1.程序分析：
2.程序源代码：
＃i nclude "graphics.h"
＃i nclude "math.h"
＃i nclude "dos.h"
＃i nclude "conio.h"
＃i nclude "stdlib.h"
＃i nclude "stdio.h"
＃i nclude "stdarg.h"
#define MAXPTS 15
#define PI 3.1415926
struct PTS {
int x,y;
};
double AspectRatio=0.85;
void LineToDemo(void)
{
struct viewporttype vp;
struct PTS points[MAXPTS];
int i, j, h, w, xcenter, ycenter;
int radius, angle, step;
double rads;
printf(" MoveTo / LineTo Demonstration" );
getviewsettings( &vp );
h = vp.bottom - vp.top;
w = vp.right - vp.left;
xcenter = w / 2; /* Determine the center of circle */
ycenter = h / 2;
radius = (h - 30) / (AspectRatio * 2);
step = 360 / MAXPTS; /* Determine # of increments */
angle = 0; /* Begin at zero degrees */
for( i=0 ; i<MAXPTS ; ++i ){ /* Determine circle intercepts */
rads = (double)angle * PI / 180.0; /* Convert angle to radians */
points[i].x = xcenter + (int)( cos(rads) * radius );
points[i].y = ycenter - (int)( sin(rads) * radius * AspectRatio );
angle += step; /* Move to next increment */
}
circle( xcenter, ycenter, radius ); /* Draw bounding circle */
for( i=0 ; i<MAXPTS ; ++i ){ /* Draw the cords to the circle */
for( j=i ; j<MAXPTS ; ++j ){ /* For each remaining intersect */
moveto(points[i].x, points[i].y); /* Move to beginning of cord */
lineto(points[j].x, points[j].y); /* Draw the cord */
} } }
main()
{int driver,mode;
driver=CGA;mode=CGAC0;
initgraph(&driver,&mode,"");
setcolor(3);
setbkcolor(GREEN);
LineToDemo();}
==============================================================
【程序66】
题目：输入3个数a,b,c，按大小顺序输出。　　　
1.程序分析：利用指针方法。
2.程序源代码：
/*pointer*/
main()
{
int n1,n2,n3;
int *pointer1,*pointer2,*pointer3;
printf("please input 3 number:n1,n2,n3:");
scanf("%d,%d,%d",&n1,&n2,&n3);
pointer1=&n1;
pointer2=&n2;
pointer3=&n3;
if(n1>n2) swap(pointer1,pointer2);
if(n1>n3) swap(pointer1,pointer3);
if(n2>n3) swap(pointer2,pointer3);
printf("the sorted numbers are:%d,%d,%d\n",n1,n2,n3);
}
swap(p1,p2)
int *p1,*p2;
{int p;
p=*p1;*p1=*p2;*p2=p;
}
==============================================================
【程序67】
题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
1.程序分析：谭浩强的书中答案有问题。　　　　　　
2.程序源代码：
main()
{
int number[10];
input(number);
max_min(number);
output(number);
}
input(number)
int number[10];
{int i;
for(i=0;i<9;i++)
　scanf("%d,",&number[i]);
　scanf("%d",&number[9]);
}
max_min(array)
int array[10];
{int *max,*min,k,l;
int *p,*arr_end;
arr_end=array+10;
max=min=array;
for(p=array+1;p<arr_end;p++)
　if(*p>*max) max=p;
　else if(*p<*min) min=p;
　k=*max;
　l=*min;
　*p=array[0];array[0]=l;l=*p;
　*p=array[9];array[9]=k;k=*p;
　return;
}
output(array)
int array[10];
{ int *p;
for(p=array;p<array+9;p++)
　printf("%d,",*p);
printf("%d\n",array[9]);
}
==============================================================
【程序68】
题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
1.程序分析：
2.程序源代码：
main()
{
int number[20],n,m,i;
printf("the total numbers is:");
scanf("%d",&n);
printf("back m:");
scanf("%d",&m);
for(i=0;i<n-1;i++)
　scanf("%d,",&number[i]);
scanf("%d",&number[n-1]);
move(number,n,m);
for(i=0;i<n-1;i++)
　printf("%d,",number[i]);
printf("%d",number[n-1]);
}
move(array,n,m)
int n,m,array[20];
{
int *p,array_end;
array_end=*(array+n-1);
for(p=array+n-1;p>array;p--)
　*p=*(p-1);
　*array=array_end;
　m--;
　if(m>0) move(array,n,m);
}
==============================================================
【程序69】
题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出
　　　圈子，问最后留下的是原来第几号的那位。
1. 程序分析：
2.程序源代码：
#define nmax 50
main()
{
int i,k,m,n,num[nmax],*p;
printf("please input the total of numbers:");
scanf("%d",&n);
p=num;
for(i=0;i<n;i++)
　*(p+i)=i+1;
　i=0;
　k=0;
　m=0;
　while(m<n-1)
　{
　if(*(p+i)!=0) k++;
　if(k==3)
　{ *(p+i)=0;
　k=0;
　m++;
　}
i++;
if(i==n) i=0;
}
while(*p==0) p++;
printf("%d is left\n",*p);
}
==============================================================
【程序70】
题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。　　　
1.程序分析：
2.程序源代码：
main()
{
int len;
char *str[20];
printf("please input a string:\n");
scanf("%s",str);
len=length(str);
printf("the string has %d characters.",len);
}
length(p)
char *p;
{
int n;
n=0;
while(*p!='\0')
{
　n++;
　p++;
}
return n;
}