键盘基础

　　Windows程序获得键盘输入的方式：键盘输入以消息的形式传递给程序的窗口过程。实际上，第一次学习消息时，键盘就是一个明显的例子：消息应该传递给应用程序的信息类型。
　　Windows用8种不同的消息来传递不同的键盘事件。这好像太多了，但是（就像我们所看到的一样）程序可以忽略其中至少一半的消息而不会有任何问题。并且，在大多数情况下，这些消息中包含的键盘信息会多于程序所需要的。处理键盘的部分工作就是识别出哪些消息是重要的，哪些是不重要的。
一、键盘基础知识
　　虽然应用程序在很多情况下可以通过鼠标实现信息的输入，但到现在为止键盘仍然是PC机中不可替代的重要输入设备。
　　用键盘当作输入设备，每当用户按下或释放某一个键时，会产生一个中断，该中断激活键盘驱动程序KEYBOARD.DRV来对键盘中断进行处理。 KEYBOARD.DRV程序会根据用户的不同操作进行编码，然后调用Windows用户模块USER.EXE生成键盘消息，并将该消息发送到消息队列中等候处理。
1．扫描码和虚拟码
　　扫描码对应着键盘上的不同键，每一个键被按下或释放时，都会产生一个唯一的扫描码作为本身的标识。扫描码依赖于具体的硬件设备，即当相同的键被按下或释放时，在不同的机器上可能产生不同的扫描码。在程序中通常使用由Windows系统定义的与具体设备无关的虚拟码。在击键产生扫描码的同时，键盘驱动程序KEYBOARD.DRV截取键的扫描码，然后将其翻译成对应的虚拟码，再将扫描码和虚拟码一齐编码形成键盘消息。所以，最后发送到消息队列的键盘消息中，既包含了扫描码又包含了虚拟码。
　　经常使用的虚拟码在WINDOWS．H文件中定义，常用虚拟码的数值、常量符号和含义如表所示。

取值（16进制） 常量符号 含义
01 VK_LBUTTON 鼠标左键
02 VK_RBUTTON 鼠标右键
03 VK_CANCEL Break中断键
04 VK_MBUTTON 鼠标中键
05-07 -- 未定义
08 VK_BACK (BackSpace)键
09 VK_TAB Tab键
0A-0B -- 未定义
0C VK_CLEAR Clear键
0D VK_RETURN Enter键
0E-0F -- 未定义
10 VK_SHIFT Shift键
11 VK_CONTROL Ctrl键
12 VK_MENU Alt键
13 VK_PAUSE Pause键
14 VK_CAPTIAL CapsLock键
15-19 -- 汉字系统保留
1A -- 未定义
1B VK_ESCAPE Esc键
1C-1F -- 汉字系统保留
20 VK_SPACE 空格键
21 VK_PRIOR PageUp键
22 VK_NEXT PageDown键
23 VK_END End键
24 VK_HOME Home键
25 VK_LEFT ←(Left Arrow)键
26 VK_UP ↑(Up Arrow)键
27 VK_RIGHT →(Right Arrow)键
28 VK_DOWN ↓(Down Arrow)键
29 VK_SELECT Select键
2A -- OEM保留
2B VK_EXECUTE Execute键
2C VK_SNAPSHOT Print Screen键
2D VK_INSERT Insert键
2E VK_DELETE Delete键
2F VK_HELP Help键
30-39 VK_0-VK_9 数字键0-9
3A-40 -- 未定义
41-5A VK_A-VK_Z 字母键A-Z
5B-5F -- 未定义
60-69 VK_NUMPAD0-VK_NUMPAD9 小键盘数字键0-9
6A VK_MULTIPLY *(乘号)键
6B VK_ADD +(加号)键
6C VK_SEPAPATOR 分隔符键
6E VK_SUBTRACT -(减号)键
6F VK_DECIMAL .(小数点)键
70-87 VK_DIVIDE /(除号)键
88-8F VK_F1-VK_F24 F1-F24功能键
90 VK_NUMBERLOCK Number lock键
91 VK_SCROLL Scroll lock键
92-B9 -- 未定义
BA-C0 -- OEM保留
C1-DA -- 未定义
DB_E4 -- OEM保留
E5 -- 未定义
E6 -- OEM保留
E7-E8 -- 未定义
E9-F5 -- OEM保留
F6-FE -- 未定义

2．输入焦点
　　同一时刻，Windows中可能有多个不同的程序在运行，也就是说有多个窗口同时存在。这时，键盘由多个窗口共享，但只有一个窗口能够接收到键盘消息，这个能够接收键盘消息的窗口被称为拥有输入焦点的窗口。
　　拥有输入焦点的窗口应该是当前的活动窗口，或者是活动窗口的子窗口，其标题和边框会以高亮度显示，以区别于其他窗口。拥有输入焦点的也可以是图标而不是窗口，此时，Windows也将消息发送给图标，只是消息的格式略有不同。
　　窗口过程可以通过发送WM_SETFOCUS和 WM_KILLFOCUS消息使窗体获得或失去输入焦点。程序也可以通过捕获WM_SETFOCUS和WM_KILLFOCUS消息来判断窗体何时获得或失去输入焦点。其中WM_SETFOCUS消息表示窗口正获得输入焦点，WM_ KILLFOCUS消息表示窗口正失去输入焦点。
3．键盘消息
　　键盘消息分为系统键消息和非系统键消息。系统键消息是指由Aft键和其他键组合而产生的按键消息。当系统键被按下时产生WM_ SYSKEYDOWN消息，当系统键被释放时产生WM_SYSKEYUP消息。 Aft键与其他键形成的组合键通常用于对程序菜单和系统菜单进行选择，或用于在不同的程序之间进行切换。因此，系统键消息应该交由Windows进行处理，用户所编制的程序一般不处理系统键消息，而是将这些消息交由DefWindowProc函数进行处理。如果用户想对系统键消息进行处理，应该在处理完这些消息后，再将其发送给DefWindowProc函数，使得Windows系统能够正常工作。
　　某些击键消息可以被转换成字符消息，例如字母键、数字键等。而有些键只能产生按键消息而没有字符消息，例如 Shift键、Insert键等。消息循环中的 TranslateMessage函数可以实现从击键消息向字符消息的转化。当GetMessage函数捕获一个WM_SYSKEYDOWN消息或 WM_KEYDOWN消息后，TranslateMessage函数判断产生该消息的键是否能够被转换成字符消息，如果能，就将该消息转换成字符消息，再通过DispatchMessape函数将转换后的字符消息发送到消息队列中去。字符消息共有以下四种，如表所示。

字符 系统字符 非系统字符
普通字符 WM_SYSCHAR WM_CHAR
死字符 WM_SYSDEADCHAR WM_DEADCHAR

　　其中死字符是由某些特殊键盘上的按键所造成的，Windows一般忽略死字符所产生的消息。
　　Windows的消息一般是通过一个MSG结构体变量传送给消息处理函数的。对于键盘消息， MSG结构体变量的各个域中较重要的是lParam域和 wParam域。wParam域用于保存按键的虚拟键代码或字符的ASCII码。对于非字符消息，wParam域保存按键的虚拟健代码；对于字符消息， wParam域不保存字符的ASCII码。lParam域则用于保存击键时产生的附加信息，实际上一个32位的lParam变量被分为六部分，记录了以下相关信息：重复次数、OEM扫描码、扩展键标志、关联键标志、前一击键状态和转换状态。lParam域各位的含义如表所示。

位数 含义
0-15 击键重复次数累加
16-23 OEM扫描码
24 是否为扩展键
25-28 未定义
29 是否便用关联键，及Alt键是否同时按下。
30 前一次击键状态，0表示该键前一次状态为抬起，1表示前一次状态为按下
31 转换状态

　　按键的次序不同，产生的消息也不相同。例如，按下并释放1键，读过程依次产生如表所示三条消息。按下1键所产生的消息和wParam的取值

消息 wParam变量取值
WM_KEYDOWN 虚拟码1
WM_CHAR ASCII码“1”
WM_KEYUP 虚拟码1

　　如果按下Shift键后再按下1键并释放，则依次产生如表所示的消息。按下 Shift键后按 1健所产生的消息和 wParam的取值

消息 wParam变量取值
WM_KEYDOWN 虚拟码 VK_SHIFT
WM_KEYDOWN 虚拟码 VK_1
WM_CHAR ASCII码　“1”
WM_KEYUP 虚拟码 VK_1
WM_KEYUP 虚拟码 VK_SHIFT

二、键盘应用实例
　　下面通过一个应用程序实例来说明在实际编程中如何处理键盘消息。
#include <windows.h>
#include <stdio.h>
// 全局变量
RECT rc; //记录滚屏的矩形区域
?
int xChar, yChar; //文本输入点坐标

WNDCLASSEX wnd; //窗口类结构变量

char szAppName[] = "键盘消息监视程序"; //窗口类名
//函数声明
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
BOOL MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE hInstance,int iCmdShow);
//函数：WinMain
//作用：入口函数
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR szCmdLine,int iCmdShow)
{
　　MSG msg;
　　if(!MyRegisterClass(hInstance))
　　{
　　　　return FALSE;
　　}
　　
　　 if(!InitInstance(hInstance,iCmdShow))
　　{
　　　　return FALSE;
　　}
　　
　　while (GetMessage (&msg, NULL, 0, 0))
　　{
　　　　TranslateMessage (&msg);
　　　　DispatchMessage (&msg);
　　}
　　return msg.wParam;
}
//函数：ShowKey
//作用：实现在窗口中显示按键信息
void ShowKey (HWND hwnd, int iType,char *szMessage,WPARAM wParam,LPARAM lParam)
{
　　static char *szFormat[2] ={"%-14s %3d %c %6u %4d %5s %5s %6s %6s",
　　　　　　　　　　　　　 　　"%-14s %3d %c %6u %4d %5s %5s %6s %6s" };
　　char szBuffer[80];
　　HDC hdc;
　　ScrollWindowEx(hwnd, 0, -yChar, &rc,&rc,NULL,NULL,SW_INVALIDATE);
　　hdc = GetDC (hwnd);
　　SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT));
　　TextOut (hdc,
　　　　　　 xChar,
　　　　　　 rc.bottom - yChar,
　　　　　　 szBuffer,
　　　　　　 wsprintf szBuffer,
　　　　　　 szFormat[iType],
　　　　　　 szMessage, //消息
　　　　　　 wParam, //虚拟键代码
　　　　　　 (BYTE) (iType ? wParam :‘ ’),//显示字符值
　　　　　　 LOWORD (lParam), // 重复次数
　　　　　　 HIWORD (lParam) & 0xFF, // OEM键盘扫描码
　　　　　　 //判断是否为增强键盘的扩展键
　　　　　　 (PSTR) (0x01000000 & lParam ? “是” : “否”),
　　　　　　 //判断是否同时使用了ALT键
　　　　　　 (PSTR) (0x20000000 & lParam ? “是” : “否”),
　　　　　　 (PSTR) (0x40000000 & lParam ? “按下” : “抬”),
　　　　　　 //判断前一次击键状
　　　　　　 (PSTR)(0x80000000 & lParam ? “按下” : “抬起”))
　　　　　　 //判断转换状态?
　　　　　　 );
　　ReleaseDC (hwnd, hdc); ?
　　ValidateRect (hwnd, NULL); ?
}
//函数：WndProc
//作用：处理主窗口的消息
LRESULT CALLBACK WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
　　static char szTop[] ="消息键 字符 重复数 扫描码 扩展码 ALT 前一状态 转换状态";
　　static char szUnd[] ="_______ __ ____ _____ ______ ______ ___ _______ ______";

　　//在窗口中输出文字作为信息标题
　　HDC hdc;
　　PAINTSTRUCT ps;
　　TEXTMETRIC tm;

　　switch (iMsg)
　　{
　　　　case WM_CREATE://处理窗口创建的消息
　　　　hdc = GetDC (hwnd); //设定字体
　　　　SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)); //检取当前字体的度量数据
　　　　GetTextMetrics (hdc, &tm);
　　　　xChar = tm.tmAveCharWidth;//保存字体平均宽度
　　　　yChar = tm.tmHeight; //保存字体高度
　　　　ReleaseDC (hwnd, hdc);
　　　　rc.top = 3 * yChar / 2;
　　　　return 0;

　　　　case WM_SIZE://处理窗口大小改变的消息
　　　　//窗体改变后保存新的滚屏区域右下角坐标
　　　　rc.right = LOWORD (lParam);
　　　　rc.bottom = HIWORD (lParam);
　　　　UpdateWindow (hwnd);
　　　　return 0;

　　　　case WM_PAINT: //处理窗口重绘消息
　　　　InvalidateRect (hwnd, NULL, TRUE);
　　　　hdc = BeginPaint (hwnd, &ps);
　　　　SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;
　　　　SetBkMode (hdc, TRANSPARENT) ;
　　　　TextOut (hdc, xChar, yChar / 2, szTop, (sizeof szTop) - 1) ;
　　　　TextOut (hdc, xChar, yChar / 2, szUnd, (sizeof szUnd) - 1) ;
　　　　EndPaint (hwnd, &ps);
　　　　return 0;

　　　　case WM_KEYDOWN:
　　　　//处理键盘上某一键按下的消息
　　　　ShowKey (hwnd, 0, "WM_KEYDOWN",wParam, lParam);
　　　　return 0;

　　　　case WM_KEYUP:
　　　　//处理键盘上某一按下键被释放的消息
　　　　ShowKey (hwnd, 0, "WM_KEYUP", wParam, lParam);
　　　　return 0;

　　　　case WM_CHAR:
　　　　//处理击键过程中产生的非系统键的可见字符消息
　　　　howKey (hwnd, 1, "WM_CHAR", wParam, lParam);
　　　　return 0;

　　　　case WM_DEADCHAR:
　　　　//处理击键过程中产生的非系统键"死字符"消息
　　　　ShowKey (hwnd, 1, "WM_DEADCHAR", wParam, lParam);
　　　　return 0;

　　　　case WM_SYSKEYDOWN:
　　　　//处理系统键按下的消息
　　　　ShowKey (hwnd, 0, "WM_SYSKEYDOWN",wParam, lParam);
　　　　break;

　　　　case WM_SYSKEYUP:
　　　　//处理系统键抬起的消息
　　　　ShowKey (hwnd, 0, "WM_SYSKEYUP", wParam, lParam);
　　　　break;

　　　　case WM_SYSCHAR://处理系统键可见字符消息
　　　　ShowKey (hwnd, 1, "WM_SYSCHAR", wParam, lParam);
　　　　break;

　　　　case WM_SYSDEADCHAR://处理系统键"死字符"消息
　　　　ShowKey (hwnd, 1, "WM_SYSDEADCHAR", wParam, lParam);
　　　　break;

　　　　case WM_DESTROY:
　　　　//处理结束应用程序的消息
　　　　PostQuitMessage (0);
　　　　return 0;
　　}
　　return DefWindowProc (hwnd, iMsg, wParam, lParam);
}
//函数：MyRegisterClass
//作用：注册窗口类
BOOL MyRegisterClass(HINSTANCE hInstance)
{
　　wnd.cbSize= sizeof (wnd);
　　wnd.style = CS_HREDRAW | CS_VREDRAW;
　　wnd.lpfnWndProc = WndProc;
　　wnd.cbClsExtra = 0;
　　wnd.cbWndExtra = 0;
　　wnd.hInstance = hInstance;
　　wnd.hIcon = LoadIcon (NULL, IDI_APPLICATION);?
　　wnd.hCursor = LoadCursor (NULL, IDC_ARROW);
　　wnd.hbrBackground = (HBRUSH)
　　GetStockObject (WHITE_BRUSH);
　　wnd.lpszMenuName = NULL;
　　wnd.lpszClassName = szAppName;
　　wnd.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
　　return RegisterClassEx (&wnd);
}
//函数：InitInstance
//作用：创建主窗口
BOOL InitInstance(HINSTANCE hInstance,int iCmdShow)
{
　　HWND hwnd;
　　hwnd = CreateWindow (szAppName,
　　　　　　　　　　　　 "键盘消息监视程序",
　　　　　　　　　　　　 WS_OVERLAPPEDWINDOW,
　　　　　　　　　　　　 CW_USEDEFAULT,CW_USEDEFAULT,
　　　　　　　　　　　　 CW_USEDEFAULT,CW_USEDEFAULT,
　　　　　　　　　　　　 NULL,NULL,hInstance,NULL
　　　　　　　　　　　　 );
　　if(!hwnd)
　　{
　　　　return FALSE;
　　}

　　ShowWindow (hwnd, iCmdShow);
　　UpdateWindow (hwnd);
　　return TRUE;
}

　　本实例的作用是通过程序捕获键盘消息，然后将wParam参数所包含的数据进行分解，最后将各项信息通过窗口显示出来。实例的源文件包含了 Initlnstance、MyRegisterClass、ShowKey、WinMain和WndProc五个函数。程序的基本思路是以 WinMain函数作为程序入口，再调用 MyRegisterClass函数和 InitInstance函数注册窗口类并创建和保存窗日，然后创建和显示窗口，最后进入消息循环。
　　下面重点分析函数WndProc和 ShowKey。
1．WndProc函数
在本实例中WndProc函数处理的消息主要有WM_CREATE、WM_SIZE、WM_PAINT和键盘消息。
　　case WM_CREATE://处理窗口创建的消息
　　hdc = GetDC (hwnd);//设定字体
　　SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT));//检取当前字体的度量数据
　　GetTextMetrics (hdc, &tm);
　　xChar = tm.tmAveCharWidth;//保存字体平均宽度
　　yChar = tm.tmHeight;//保存字体高度
　　ReleaseDC (hwnd, hdc);
　　rc.top = 3 * yChar / 2;
　　return 0;
　　这一程序段的主要作用是将字体对象选入当前窗体的设备描述表中，同时取得字体高度和平均宽度，再初始化编辑区的滚屏区域的右上角Y坐标。进入该程序段后，首先通过GetDC函数获得当前窗体的设备描述表，再通过GetStockObject函数获得系统字体，然后用 SelectObject函数将字体对家选入窗体的设备描述表中。其中，hdc为设备描述表句柄。在完成所有操作后，程序还必须通过ReleaseDC函数释放设备描述表。在该程序段中使用了GetTextMetrics函数来获得字体的几何尺寸。GetTextMetrics函效的原型定义如下：
BOOL GetTextMetrics(HDC hdc，// 指向设备描述表的句柄
　　　　　　　　　　LPTEXTMETRIC lptm // TEXTMETRIC结构体变量的指针
　　　　　　　　　　// 所获得的所有信息保存在TEXTMETRIC结构体变量中
　　　　　　　　　　)；
　　其中lptm是一个指向 TEXTMETRIC结构体的指针。TEXTMETRIC结构体包含了与字体的几何尺寸相关的基本信息。该结构体的具体定义如下：
typedef struct tagTEXTMETRIC
{ // tm
　　LONG tmHeight；// 字体高度
　　LONG tmAscent；//字体高于基准线的高度
　　LONG tmDescent；// 字体低于基准线的高度
　　LONG tmInternalLeading；// 给大写字母留出的空间
　　LONG tmExtenalLeading； // 由字体设计者推荐的附加行距
　　LONG tmAveCharWidth；// 字体平均宽度
　　LONG tmMaxCharWidth；// 字体最大宽度
　　LONG tmWeight； // 字体黑度
　　LONG tmOverhang； // 在合成斜体或黑体时加在字符上的附加宽度值
　　LONG tmDigitizedAspectX；// 字体所适合的高宽比的宽
　　LONG tmDigitizedAspectY; // 字体所适合的高宽比的高
　　BCHAR tmFirstChar； // 字体中定义的第一个字符
　　BCHAR tmLastChar； //字体中定义的最后一个字符
　　BCHAR trnDefaultChar； //字体中的默认字符
　　BCHAR trnBreakChar； // windows在调整文本时用于分裂词的字符
　　BYTE tmItalic； // 取非零值时表示斜体字体
　　BYTE tmUnderLined； // 取非零值时表示下划线字体
　　BYTE tmStruckOut；// 取非零值时为删除线字体
　　BYTE tmPitchAndFamily； // 低二位为字符间距，高四位为系列值
　　BYTE tmCharSet； // 指定字符集
} TEXTMETRIC；
　　该结构中所有的字体大小都是按逻辑单位给出的，这就是说字体的大小取决于当前显示设备的映射模式。
　　在例中，所获得的字体几何尺寸保存在TEXTMETRIC结构体变量tm中。滚屏区域的范围是通过RECT结构体变量re保存的，RECT结构体变量可以通过记录矩形区域的右上角和左下角的坐标来确定一个矩形区域。
RECT结构的原型定义如下：
typedef struc RECT｛
　　LONG left； // 矩形左上角 X坐标
　　LONG top； // 左上角 Y坐标
　　LONG right； // 右下角 X坐标
　　LONG bottom； // 右下角Y坐标
} RECT;
　　该结构定义了一个矩形区域的左上角和右下角的坐标。由结构的原型定义我们可以知道该结构包括四个域，其中left域表示矩形的左上角X坐标，top域表示左上角Y坐标，right域表示右下角X坐标，bottom域表示右下角Y坐标。通常用于一个矩形区域范围的记录和传递。
　　例如，通过RECT结构的变量将一个矩形区域范围的四个角的值传递FillRect函数，则调用该函数后，矩形区域除了最下方的一行和最右方一列外都被填充。在本实例中，初始化编辑区的滚屏区域的左上角Y坐标时，使用了如下程序：
　　rc.top＝ 3 * yChar／2；
　　这是因为在窗口中首先要输出两行的题头信息，一行为中文，一行为下划线。中文字符的高度为1个字体高度单位，而下划线的高度为半个字体高度单位。这两行信息是一直保持，不参与滚屏的。因此，滚屏区域的左上角Y坐标从3／2个字体高度处开始。
在WndProc函数中，处理WM_ SIZE
消息的程序段如下：
　　case WM_SIZE: //处理窗口大小改变的消息
　　//窗体改变后保存新的滚屏区域右下角坐标
　　rc.right = LOWORD (lParam);
　　rc.bottom = HIWORD (lParam);
　　UpdateWindow (hwnd);
　　return 0;
　　该程序段比较简单，只是当窗口的尺寸改变时重新设定滚屏区域的右下角坐标，并更新窗口。值得注意的是， WM_SIZE消息的wParam变量保存了窗体新尺寸的左上角坐标，变量的32位分为两个部分，低16位保存X坐标，高16位保存Y坐标。 lParam变量保存了窗体新尺寸的右下角坐标，保存方式与wParam变量相同。在编程过程中，通常通过LOWORD宏定义来获得32位变量的低16位数值，通过HIWORD宏定义来获得32位变量的高历位数值。
　　该程序段比较简单，只是当窗口的尺寸改变时重新设定滚屏区域的右下角坐标，并更新窗口。值得注意的是，WM_SIZE消息的wParam变量保存了窗体新尺寸的左上角坐标，变量的32位分为两个部分，低16位保存X坐标，高16位保存Y坐标。 lParam变量保存了窗体新尺寸的右下角坐标，保存方式与wParam变量相同。在编程过程中，通常通过LOWORD宏定义来获得32位变量的低16位数值，通过HIWORD宏定义来获得32位变量的高历位数值。
WndProc函数中，处理WM＿PAINT消息的程序段如下：
　　case WM_PAINT: //处理窗口重绘消息 ?
　　InvalidateRect (hwnd, NULL, TRUE); ?
　　hdc = BeginPaint (hwnd, &ps); ?
　　SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ; ?
　　SetBkMode (hdc, TRANSPARENT) ; ?
　　TextOut (hdc, xChar, yChar / 2, szTop, (sizeof szTop) - 1) ; ?
　　TextOut (hdc, xChar, yChar / 2, szUnd, (sizeof szUnd) - 1) ; ?
　　EndPaint (hwnd, &ps); ?
　　return 0;
　　该程序段首先调用InvalidateRect函数使窗口无效，InvalidateRect函数的功能是使窗口的某一部分无效，也就是通知Windows该部分需要被刷新和重画。
　　在InvalidateRect函数之后，程序调用函数BeginPaint准备重画窗口。
BeginPaint 函数的原型定义如下：
HDC BeginPaint (HWND hwnd ， // 重画窗口的句柄
　　　　　　　　LPPAINTSTRUCT lpPaint // 指向一个用于保存所有重
　　　　　　　　// 画信息的 PAINTSTRUCT 结构体变量的指针)；
　　BeginPaint 函数的作用是完成重画窗体之前的准备，并将重画窗体 的数据保存在一个 PAINTSTRUCT 结构体变量中。 PAINTSTRUCT 结构体可以用于保存窗口重画时的数据以方便以后使用。
PAINTSTRUCT结构体的定义如下：
typedef struct tagPAINTSTRUCT｛ // ps
　　HDC hdc； // 重画区域所在窗口的句柄
　　BOOL fErase；// 是否擦去背景
　　RECT rcPaint； // 指定重画窗体的范围
　　BOOL fRestore； // 系统保留域
　　BOOL fIncUpdate；// 系统保留域
　　BYTE rgbReserved［32］；// 系统保留
｝PA INTSTRU CT;
　　BeginPaint函数如果操作成功会返回一个被操作窗口的设备描述表的句柄。如果操作不成功则函数返回NULL值，表明显示设备不可用。该函数在运行过程中，会进行自动调整，使得所有区域都包含在刷新区域的范围内。而原有需要刷新的区域是由InvalidateRect函数或 InvalidateRgn函数指定的。一般来说，只有当程序处理 WM_PAINT消息时才调用BeginPaint函数，而且，每次调用BeginPaint函数都需要对应调用一个EndPaint函数来结束重画过程。在BeginPaint函数调用后，会将插入符光标自动隐藏。EndPaint函数原型定义如下：
BOOL EndPaint ( HWND hWnd, // 窗口句柄
　　　　　　　　CONST PAINTSTRUCT* lpPaint // 指向 PAINTSTRUCT结构体变量的指针
　　　　　　　)；
　　EndPaint函数标志着窗口重画过程的结束。该函数执行后总返回一个非零值。如果在BeginPaint函数执行时将插入符号隐藏了，那么EndPaint函数会重新显示插入符号。
消息处理函数 WndProc处理的键盘消息有：
WM_ KEYDOWN、WM_KEYUP
WM_CHAR、WM_DEADCHAR、
WM_SYSKEYDOWN、WM_SYSKEYUP、
WM_SYSCHAR 和 WM_SYSDEADCHAR。
　　根据不同的消息，程序会用不同的参数调用 ShowKey函数在窗口中显示各键盘消息的相关信息。
2．ShowKey函数
ShowKey函数是用户自定义函数，其作用是从键盘消息的各域中提取信息并显示在窗口中。
ShowKey函数的具体定义如下：
// 作用：实现在窗口中显示按键信息
void ShowKey (HWND hwnd, int iType, char *szMessage,WPARAM wParam, LPARAM lParam)
{
　　static char *szFormat[2] = {"%-14s %3d %c %6u %4d %5s %5s %6s %6s",
　　　　　　　　　　　　　　　　"%-14s %3d %c %6u %4d %5s %5s %6s %6s" } ;
　　char szBuffer[80];
　　HDC hdc;
　　SelectObject( hdc,
　　　　　　　　　GetStockObject(SYSTEM_FIXED_FONT));
　　　　　　　　　TextOut (hdc, xChar, rc.bottom - yChar,
　　　　　　　　　szBuffer,wsprintf (szBuffer, szFormat [iType],
　　　　　　　　　szMessage, //消息
　　　　　　　　　wParam, //虚拟键代码
　　　　　　　　　(BYTE) (iType ? wParam : ' '),//显示字符值
　　　　　　　　　LOWORD (lParam), //重复次数
　　　　　　　　　HIWORD (lParam) & 0xFF, //OEM键盘扫描码
　　　　　　　　　//判断是否为增强键盘的扩展键
　　　　　　　　　(PSTR) (0x01000000 & lParam ? "是" : "否"),
　　　　　　　　　//判断是否同时使用了ALT键
　　　　　　　　　(PSTR) (0x20000000 & lParam ? "是" : "否"),
　　　　　　　　　(PSTR) (0x40000000 & lParam ? "按下" : "抬起"),
　　　　　　　　　//判断前一次击键状态
　　　　　　　　　(PSTR) (0x80000000 & lParam ? "按下" : "抬起"))
　　　　　　　　　//判断转换状态
　　　　　　　　　);
}

　　ShowKey函数首先定义了szFormat字符串，并在其中针对字符消息和非字符消息定义了两种不同的输出格式。然后调用ScrollWindowEx函数使显示区域滚屏，为信息输出作准备。ScrollWindowEx函数的主要功能是使窗口编辑区中的某一矩形区域产生滚屏效果。
ScrollWindowEx函数的原型定义如下：
int ScrollWindowEx (HWND hwnd， // 发生滚屏的窗口的句柄
　　　　　　　　　　int dx， // 水平滚屏的数值
　　　　　　　　　　int dy, // 垂直滚屏的数值
　　　　　　　　　　CONST RECT*prcScroll，//记录发生滚屏的矩形区域的RECT结构体的地址
　　　　　　　　　　CONST RECT* prcClip， //记录发生剪切的矩形区域的 RECT结构体的地址
　　　　　　　　　　HRGN hrgnUpdate，// 需要更新区域的句柄
　　　　　　　　　　LPRECT prcUpdate， // 记录需要更新矩形区域的 RECT结构体的地址
　　　　　　　　　　UINT flags // 滚屏控制标志
　　　　　　　　　　)；
　　其中，dx参数给出了以设备单位尺寸（对于显示器为像素）为单位的每一次水平滚屏的度量值。dx参数取正值表示向右滚屏，取负值表示向左滚屏。如参数给出了以设备单位尺寸（对于显示器为像素）为单位的每一次垂直滚屏的度量值。如参数取正值表示向下滚屏，取负值表示向上滚屏。dx和dy两个参数不能同时取非零值，也就是说，ScrollWindowEx函数不能使编辑区同时向水平和垂直方向滚屏。
　　prcScroll参数为一个指向记录滚屏的矩形区域的RECT结构体变量的指针，如果取值为NULL，则整个编辑区发生滚屏。
　　hrgnUpdate参数为因滚屏而变得无效的矩形区域的句柄，多数情况下可以取NULL。 prcUpdate参数指向一个记录因为滚屏而变得无效的矩形区域的 RECT结构体变量。多数情况下取NULL。
flags变量可以通过不同的取值来控制滚屏的状况，其取值和意义如下所示。
　　SW_ ERASE当和 SW_INVALIDATE值同时使用时，会通过向 window发送一个WM_ ERASEBKGND消息将最近变得无效的区域抹去；
　　SW_INVALIDATE在发生滚屏后使由hrgnUpdate参数指定的区域无效；
　　SW_SCROLLCHILDREN使所有的子窗口都发生滚屏；
　　SW_ SMOOTHSCROLL在 Windows 95及以后的版本中使窗口发生平滑滚屏。如果ScrollWindowEx函数执行成功，则返回值为以下三者之一：
　　SIMPLEREGION表示有一个矩形的无效区域；
　　COMPLEXREGION表示没有无效区域和重叠区域；
　　NULLREGION表示没有无效区域。
　　如果ScrollWindowEx函数执行不成功，则返回ERROR。
ScrollWindowEx函数的功能也可以通过ScrollWindow函数来实现，ScrollWindow 函数的原型定义如下：
BOOL Scrollwindow(HWND hwnd //窗口句柄
　　　　　　　　　int XAmount， // 水平滚屏的数值
　　　　　　　　　int YAmount， // 垂直滚屏的数值
　　　　　　　　　CONST RECT* lpReCt， //记录发生滚屏的矩形区域的 RECT结构体的地址
　　　　　　　　　CONST RECT* lpClipRect， //记录发生剪切的矩形区域的 RECT结构体的地址
　　　　　　　　　)；
　　可以看出，ScrollWindow函数与ScrollWindowEx函数十分相似，其参数的意义也基本相同。事实上，ScrollWindow函数是为了保持对较低版本的Windows兼容而设计的，用户在编程时，除非需要考虑程序的向下兼容，否则一般都应使用ScrollWindowEx函数。
　　在滚屏后，函数开始调用TextOut函数进行信息输出。TextOut函数的原型定义如下：
BOOL TextOut( HDC hdc，// 设备描述表句柄
　　　　　　　int nXStart， // 文本输出起始点 X坐标
　　　　　　　int nYStart， // 文本输出起始点 Y坐标
　　　　　　　LPCTSTR lpString， // 指向输出字符串的指针
　　　　　　　int cbString // 字符串中字符的数目
　　　　　　　);
　　TextOut函数能够用当前设定的字体在窗口的指定部位输出一段文本信息。如果操作成功则返回一非零值，否则返回零值。捕获键盘消息的信息主要根据表中的描述，通过使用按位操作确定某些特定位的值，然后再判断具体的状态。
　　在TextOut函数调用过程中，还调用了wsprintf函数，并使其返回值作为TextOut函数的一个参数值。wsprintf函数的原型定义如下：
int wsprintf (LPTSTR lpOut，// 指向需要输出的字符串的指针
　　　　　　　LPCTSTR lpFmt， //指向格式控制字符串的指针
　　　　　　　…… // 其他可选参数
　　　　　　　)；
　　wsprintf函数能够将一组字符序列按lpFmt参数指定的格式转换，然后保存在lpOut参数指定的字符缓冲区中等待输出。其中，字符序列由可选参数决定，而可选参数的数目和具体内容应该与lpFmt所指定的格式一致。
　　如果wsprintf函数操作成功，则返回输出字符的数目，但这个字符数目不包括表示结束的NULL标志。如果操作失败，返回的整数值将与输出的字符数目不相符。
　　实例主要说明了如何处理键盘消息，读者应该着重理解各种信息在MSG结构体变量中是如何保存的，怎样才能够对其中的具体信息进行识别和提取。程序运行后将产生一个背景色为灰色的简单窗口，并在窗口的顶部出现标题提示信息。这时用户如果进行键盘操作，则窗体中便会显示该操作所产生的键盘消息，每显示一条消息程序都会滚屏和重绘窗口，滚屏区域的颜色为白色。

键盘消息实例2:
#include <windows.h>
int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int);
LRESULT CALLBACK WndProc( HWND,UINT, WPARAM,LPARAM);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
　　WNDCLASSEX wcex;
　　wcex.cbSize = sizeof(WNDCLASSEX);
　　wcex.style = CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS;
　　wcex.lpfnWndProc = (WNDPROC)WndProc;
　　wcex.cbClsExtra = 0;
　　wcex.cbWndExtra = 0;
　　wcex.hInstance = hInstance;
　　wcex.hIcon= LoadIcon(NULL, (LPCTSTR)IDI_APPLICATION);
　　wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
　　wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
　　wcex.lpszMenuName = NULL;
　　wcex.lpszClassName = "SeeKeyMessage";
　　wcex.hIconSm = LoadIcon(NULL,(LPCTSTR)IDI_APPLICATION);

　　if(!RegisterClassEx(&wcex)) return FALSE;

　　int SW_XFS = GetSystemMetrics(SM_CXSCREEN);
　　int SW_YFS = GetSystemMetrics(SM_CYSCREEN);
　　HWND hWnd;
　　hWnd = CreateWindowEx(WS_EX_CLIENTEDGE,
　　　　　　　　　　　　　"SeeKeyMessage",
　　　　　　　　　　　　　"Trace Key Operation",
　　　　　　　　　　　　　WS_OVERLAPPEDWINDOW,
　　　　　　　　　　　　　0, 0, SW_XFS, SW_YFS-25,
　　　　　　　　　　　　　NULL,
　　　　　　　　　　　　　NULL,
　　　　　　　　　　　　　hInstance,
　　　　　　　　　　　　　NULL);
　　if(!hWnd) return FALSE;

　　ShowWindow(hWnd, nCmdShow);
　　UpdateWindow(hWnd);
　　MSG msg;

　　while(GetMessage(&msg, NULL, 0, 0))
　　{
　　　　TranslateMessage(&msg);
　　　　DispatchMessage(&msg);
　　}
　　return msg.wParam;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
　　HDC hDC;
　　PAINTSTRUCT ps;
　　static char Buffer[256];
　　switch(message)
　　{
　　　　case WM_KEYDOWN:
　　　　hDC = GetDC(hWnd);
　　　　wsprintf(Buffer," ");
　　　　TextOut(hDC,20,40,Buffer,strlen(Buffer));
　　　　wsprintf(Buffer," WM_KEYDOWN %3d %3d%3d", wParam,LOWORD(lParam),HIWORD(lParam));
　　　　TextOut(hDC,20,40,Buffer,strlen(Buffer));
　　　　ReleaseDC(hWnd,hDC);
　　　　break;

　　　　case WM_KEYUP:
　　　　hDC = GetDC(hWnd);
　　　　wsprintf(Buffer," ");
　　　　TextOut(hDC,20,60,Buffer,strlen(Buffer));
　　　　wsprintf(Buffer," WM_KEYUP %3d %3d %3d",wParam,LOWORD(lParam),HIWORD(lParam));
　　　　TextOut(hDC,20,60,Buffer,strlen(Buffer));
　　　　ReleaseDC(hWnd,hDC);
　　　　break;

　　　　case WM_PAINT:
　　　　hDC = BeginPaint(hWnd,&ps);
　　　　wsprintf(Buffer," ");
　　　　TextOut(hDC,20,20,Buffer,strlen(Buffer));
　　　　wsprintf(Buffer," Message wParam LOWORD(lParam) HIWORD(lParam)");
　　　　TextOut(hDC,20,20,Buffer,strlen(Buffer));
　　　　EndPaint(hWnd,&ps);
　　　　break;

　　　　case WM_DESTROY:
　　　　PostQuitMessage(0);
　　　　break;

　　　　default:
　　　　return DefWindowProc(hWnd,message,wParam,lParam);
　　}
　　return 0;
}

鼠标消息

　　随着 Windows 操作系统的流行，鼠标因为其精确定位和操作方便的优点而成为计算机不可缺少的输入设备。
一、鼠标的基础知识
　　本节将介绍在程序中用鼠标作为输入设备的方法和技巧。 1 ．鼠标操作和鼠标消息用户在使用鼠标操作的过程中，经常会使用的主要方式有五种 ，如表所示。

操作名称 描述
单击（Click） 按下并迅速释放鼠标按钮。
双击（Double Click） 连续快速完成两次单击操作。
移动（Move） 鼠标光标移动。
拖动（Drag） 按下鼠标一键不放，同时执行鼠标移动操作。
与键盘的特殊键组合 在按下Ctrl键或Shift键的同时执行鼠标单击操作。

　　其中，前三种操作是最为基本的操作，可以产生Windows内部定义的消息，并通过这些消息来判断用户具体执行了哪种操作。
　　Windows定义的鼠标消息共有20条，其中非编辑区的鼠标消息一般交由系统处理，程序只处理编辑区内的鼠标消息。编辑区内的鼠标消息共有10条，如表所示。

消息常量 操作描述
WM_MOUSEMOVE 移动鼠标
WM_LVBUTTONDOWN 按下鼠标左键
WM_LBUTTONUP 释放鼠标左键
WM_LBUTTONDBLCLK 双击鼠标左键
WM_RVBUTTONDBLCLK 按下鼠标右键
WM_RBUTTONUP 释放鼠标右键
WM_RBUTTONDBLCLK 双击鼠标右键
WM_MVBUTTONDOWM 按下鼠标中键
WM_MBUTTONUP 释放鼠标中键
WM_MBUTTONDBLCLK 双击鼠标中键

　　对于前表所列的鼠标操作中的最后两种，不能直接使用Windows定义的消息来判断，只能通过编程，将多种消息和数据组合之后判断。例如，判断用户是否按下鼠标左键之后进行拖动操作可以通过以下程序段来实现，用case语句来实现：
case WM_MOUSEMOVE：

if (wParam&MK_LBUTTON) //只处理鼠标拖动的消息
{ …… // 处理程序
}

　　在处理鼠标消息的过程中，消息的wParam参数和lParam参数起了重要的作用。wParam参数中保存了在消息产生时其他操作进行的状态；用户可以通过位屏蔽操作来判断在该消息产生的同时，其余操作是否正在进行。这正是在程序中判断复杂鼠标操作的基本方法。例如，上面判断拖动操作的程序段就用了位操作 wParam＆ MK_LBUTTON, 判断在鼠标移动（WM_MOUSEMOVE）的同时鼠标左键是否同时被接下。如果，鼠标左键同时按下，则位操作的结果为TRUE，说明当前操作为拖动操作，程序可以继续进行下一步处理。又如需要判断单击鼠标左键时是否同时按下了Ctrl键或Shift键，可以用以下程序段来处理：
case WM_ LBUTTONDOWN：
if（wParam＆ MK_CTROL）
{//Ctrl键同时按下
　　if (wParam＆MK_ SHIFT)
　　{// Ctrl 键和Shift键都同时按下
　　　　…… // 处理程序
　　}
　　else { // Ctrl健同时按下，但 Shift键没有被按下
　　　　……. // 处理程序
　　}
}
else if（wParam＆MK_ SHIFT）
{ // Shift键同时按下，但 Ctrl键没有被接下
　　…… // 处理程序
}
else
{// Shift 键和Ctrl键都未按下
　　…… // 处理程序
}
　　lParam参数保存了消息产生时鼠标所在点的坐标，其中低16位为X坐标，高16位为Y坐标。
　　在处理鼠标消息的时候，如果需要处理鼠标双击消息，则在注册窗口类时，窗口的风格必须包括CS_DBCLCKS。否则即使执行了双击操作，窗口也只能收到两条WM_ BUTTONUP和 WM_BUTTONDOWN消息。区分双击操作和两次单击操作是以两次击键的时间间隔为标准的。当两次击键的时间间隔小于 500毫秒时， Windows将其视为双击操作：如果两次击键的时间间隔大于500毫秒，Windows将其视为两次单击操作。500毫秒为默认的时间间隔，用户可以通过调用SetDoubleClickTime函数来修改这一时间间隔。SetDoubleClickTime函数的原型定义如下：
BOOL SetDoubleClickTime（UINT uInterval // 新的击键时间间隔）
2．鼠标捕捉
　　在通常情况下，只有当鼠标位于窗体内时，窗体才能接收到鼠标的消息。如果需要接收所有的鼠标消息而不论鼠标是否在窗口内，这时可以调用SetCapture函数来实现。SetCapture函数的原型定义如下：
HWND SetCapture (
　　HWND hwnd // 窗口句柄
）；
　　调用SetCapture函数后，所有鼠标操作所产生的消息都直接发送到指定窗口。因为此时鼠标可能位于窗口之外，所以鼠标的坐标可能为负值。由于调用该函数会使其他窗口不能接收到键盘和鼠标的消息，因此在完成操作后应及时调用ReleaseCapture 函数释放鼠标捕获。ReleaseCapture函数的原型定义如下：
BOOL ReleaseCapture（VOID）；
二、鼠标应用实例
下面是一个在程序设计中如何捕获鼠标消息的实例。
#include <windows.h>
//全局变量
WNDCLASSEX wnd;
static char szAppName[] = "mouse";//窗口类名
//函数声明
long WINAPI WndProc (HWND, UINT, WPARAM, LPARAM);
BOOL MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE hInstance, int iCmdShow);
//函数：WinMain
//作用：入口函数
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,PSTR szCmdLine,int iCmdShow) ?
{
　　MSG msg;
　　if(!MyRegisterClass(hInstance))
　　{
　　　　return FALSE;
　　}

　　if(!InitInstance(hInstance,iCmdShow))
　　{
　　　　return FALSE;
　　}

　　while (GetMessage (&msg, NULL, 0, 0))
　　{
　　　　TranslateMessage (&msg);
　　　　DispatchMessage (&msg);
　　}
　　return msg.wParam;
}
//函数：WndProc
//作用：处理主窗口的消息
long WINAPI WndProc (HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
　　static POINT points[256];//保存点坐标
　　static POINT center;//保存中心点坐标
　　static int iCount;//点数目累加值
　　HDC hdc;
　　PAINTSTRUCT ps;
　　int i;//循环计数
　　RECT rect;
　　switch (msg)
　　{
　　　　case WM_MBUTTONDOWN:
　　　　//处理鼠标中键按下的消息
　　　　iCount = 0;//重新初始化点数目
　　　　InvalidateRect (hwnd, NULL, TRUE);
　　　　//通知系统重画窗口
　　　　hdc = BeginPaint (hwnd,&ps);
　　　　GetClientRect(hwnd,&rect);
　　　　if(wParam&MK_CONTROL)//判断Shift键和Ctrl键是否被按下
　　　　{
　　　　　　if(wParam&MK_SHIFT)
　　　　　　{ //根据不同的情况给出不同的提示
　　　　　　　　DrawText(hdc,"Ctrland Shift", -1,&rect,DT_SINGLELINE|DT_CENTER|DT_VCENTER?);
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　DrawText(hdc,"Ctrl Only" ,-1,&rect, DT_SINGLELINE|DT_CENTER|DT_VCENTER);
　　　　　　}
　　　　}
　　　　else if(wParam&MK_SHIFT)
　　　　{
　　　　　　DrawText(hdc,"Shift Only",-1,&rect,DT_SINGLELINE|DT_CENTER|DT_VCENTER);
　　　　}
　　　　else
　　　　{
　　　　　　DrawText(hdc,
　　　　　　　　　　 "Middle Button of mouse only",
　　　　　　　　　　 -1,
　　　　　　　　　　 &rect,
　　　　　　　　　　 DT_SINGLELINE|DT_CENTER|DT_VCENTER);
　　　　}
　　　　EndPaint(hWnd,&ps);
　　　　return 0;

　　　　case WM_RBUTTONDOWN:
　　　　//处理鼠标右键按下的消息
　　　　iCount = 0;//重新初始化点数目
　　　　center.x=LOWORD (lParam);
　　　　//保存新的中心点坐标
　　　　center.y=HIWORD (lParam);
　　　　InvalidateRect (hwnd, NULL, TRUE);//通知系统重画窗口
　　　　return 0;

　　　　case WM_MOUSEMOVE://处理鼠标移动的消息
　　　　if (wParam & MK_LBUTTON && iCount < 256)//只处理鼠标拖动的消息
　　　　{
　　　　　　points[iCount].x = LOWORD (lParam);//保存点的X坐标
　　　　　　points[iCount++].y = HIWORD (lParam);//保存点的Y坐标
　　　　　　hdc = GetDC (hwnd);//获得窗口的设备描述表句柄
　　　　　　SetPixel (hdc, LOWORD (lParam), HIWORD (lParam), 0L);//绘点
　　　　　　ReleaseDC (hwnd, hdc);//释放设备描述表句柄
　　　　}?return 0;

　　　　case WM_LBUTTONUP:
　　　　//处理鼠标左键抬起的消息
　　　　InvalidateRect (hwnd, NULL, FALSE);
　　　　//通知系统重画窗口
　　　　return 0;

　　　　case WM_PAINT://处理窗口重画的消息
　　　　hdc = BeginPaint (hwnd, &ps);//获得设备描述表句柄
　　　　SetCursor (LoadCursor (NULL, IDC_WAIT));//设置新的鼠标光标
　　　　ShowCursor (TRUE);//显示鼠标光标
　　　　for (i = 0 ; i < iCount ; i++)
　　　　{
　　　　　　MoveToEx(hdc, center.x, center.y,NULL);//绘制直线
　　　　　　LineTo(hdc, points.x, points.y);
　　　　}
　　　　ShowCursor(FALSE);//隐藏鼠标
　　　　SetCursor(LoadCursor (NULL, IDC_ARROW));
　　　　//恢复原来的鼠标光标 ?
　　　　EndPaint(hwnd, &ps);
　　　　return 0;

　　　　case WM_DESTROY://处理销毁窗口的消息
　　　　PostQuitMessage (0);
　　　　return 0;
　　}
　　return DefWindowProc (hwnd, msg, wParam, lParam);
}
//函数：MyRegisterClass
//作用：注册窗口类
BOOL MyRegisterClass(HINSTANCE hInstance)
{
　　wnd.cbSize= sizeof (wnd);
　　wnd.style= CS_HREDRAW | CS_VREDRAW;
　　wnd.lpfnWndProc = WndProc;
　　wnd.cbClsExtra = 0;
　　wnd.cbWndExtra = 0;
　　wnd.hInstance = hInstance;
　　wnd.hIcon = LoadIcon (NULL, IDI_APPLICATION);
　　wnd.hCursor = LoadCursor (NULL, IDC_ARROW);
　　wnd.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH);
　　wnd.lpszMenuName= NULL;
　　wnd.lpszClassName = szAppName;
　　wnd.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
　　return RegisterClassEx (&wnd);
}
//函数：InitInstance
//作用：创建窗口
BOOL InitInstance(HINSTANCE hInstance, int iCmdShow)
{
　　HWND hwnd;
　　hwnd = CreateWindow(szAppName,
　　　　　　　　　　　　"跟踪鼠标移动",
　　　　　　　　　　　　WS_OVERLAPPEDWINDOW,
　　　　　　　　　　　　CW_USEDEFAULT, CW_USEDEFAULT,
　　　　　　　　　　　　CW_USEDEFAULT, CW_USEDEFAULT,
　　　　　　　　　　　　NULL, NULL, hInstance, NULL);
　　if(!hwnd) return FALSE;
　　ShowWindow (hwnd, iCmdShow);
　　UpdateWindow (hwnd);
　　return TRUE;
}
　　例题的主要功能是在窗口中某个位置单击鼠标右键时，程序保存捕获的鼠标点处的坐标。紧接着按下鼠标左键在窗口中拖动，程序会记录下鼠标运动的轨迹，并以刚才右击鼠标时确定的点为中心绘制一簇射线。本实例最多可以绘制256条射线。程序的另一目的是为了让读者进一步了解如何捕获鼠标与Ctrl键或 Shift键组合时的复杂鼠标消息。如果在窗口中单击鼠标中键，程序会在窗口中央显示文本信息说明用户是否同时按下Ctrl键和Shift键。
　　源文件与本书前面所介绍的其他实例一样，都具有基本的 Windows API 程序的结构。即以WinMain函数作为程序入口，调用MyRegisterClass函数和InitInstance函数注册窗口类和创建窗口，再进入消息循环。并在消息循环中调用WndProc函数处理鼠标消息。下面主要介绍WndProc函数处理鼠标消息的方法和技巧。
　　在例中WndProc函数能够处理的消息包括 WM_MBUTTONDOWN、WM_RBUTTONDOWN、WM_MOUSEMOVE、WM_LBUTTONUP和WM_PAINT。
处理WM_ MBUTTONDOWN消息的程序段如下：
case WM_MBUTTONDOWN:
//处理鼠标中键按下的消息
iCount = 0;//重新初始化点数目
InvalidateRect (hwnd, NULL, TRUE);//通知系统重画窗口
hdc = BeginPaint (hwnd,&ps);
GetClientRect(hwnd,&rect);
if(wParam&MK_CONTROL)//判断Shift键和Ctrl键是否被按下
{
　　if(wParam&MK_SHIFT)
　　{ //根据不同的情况给出不同的提示
　　　　DrawText(hdc,"Ctrland Shift", -1,&rect,DT_SINGLELINE|DT_CENTER|DT_VCENTER);
　　}
　　else
　　{
　　　　DrawText(hdc,"Ctrl Only" ,-1,&rect,
　　　　DT_SINGLELINE|DT_CENTER|DT_VCENTER);
　　}
}
else
{
　　if(wParam&MK_SHIFT)
　　{
　　　　DrawText(hdc,"Shift Only",-1,&rect,DT_SINGLELINE|DT_CENTER|DT_VCENTER);
　　}
　　else
　　{
　　　　DrawText(hdc,"Middle Button of mouse only",-1,&rect,DT_SINGLELINE|DT_CENTER|DT_VCENTER);
　　}
}
EndPaint(hWnd,&ps);
return 0;
　　这种判断复杂鼠标操作的方法在基础知识部分已经详细介绍过，这里不再赘述。这一段程序的作用是根据在按下鼠标中键的同时，再按Ctrl键或Shift键的不同情况而在窗口中输出不同的信息。
处理WM_ RBUTTONDOWN消息的程序段如下：
case WM_RBUTTONDOWN://处理鼠标右键按下的消息
iCount = 0;//重新初始化点数目
center.x=LOWORD (lParam);//保存新的中心点坐标
center.y=HIWORD (lParam);
InvalidateRect (hwnd, NULL, TRUE);//通知系统重画窗口
return 0;
　　这一段程序的主要作用是将鼠标右击点的坐标保存在POINT结构体变量center中，再将计数变量iCount归零，为绘制一簇射线作准备。完成以上工作后，程序调用InvalidateRect函数通知系统重画窗口，将窗口中原有的射线族擦去。处理WM_MOUSEMOVE消息的程序段如下：
case WM_MOUSEMOVE://处理鼠标移动的消息
if (wParam & MK_LBUTTON && iCount<256)//只处理鼠标拖动的消息
{
　　points[iCount].x = LOWORD (lParam);//保存点的X坐标
　　points[iCount++].y = HIWORD (lParam);//保存点的Y坐标
　　hdc = GetDC (hwnd);//获得窗口的设备描述表句柄
　　SetPixel (hdc, LOWORD (lParam), HIWORD (lParam), 0L);
　　//绘点
　　ReleaseDC (hwnd, hdc);//释放设备描述表句柄
}
　　事实上，该程序只是处理鼠标左键拖动操作的消息。在执行拖动操作的过程中，程序不断将鼠标点的坐标记录在points数组中。points数组是 WndProc函数中定义的一个静态的POINT结构体数组。在记录点坐标的同时，程序调用了SetPixel函数在窗口上的绘制点，对被记录的点进行标志。对于WM_ LBUTTONUP消息，程序只调用了IvalidateRect函数通知系统拖动操作已经结束，可以开始绘制射线族了。
处理WM _PAINT消息的程序段如下：
case WM_PAINT://处理窗口重画的消息
hdc = BeginPaint (hwnd, &ps);//获得设备描述表句柄
SetCursor (LoadCursor (NULL, IDC_WAIT));//设置新的鼠标光标
ShowCursor (TRUE);//显示鼠标光标
for (i = 0 ; i < iCount ; i++)
{
　　MoveToEx(hdc, center.x, center.y,NULL);//绘制直线
　　LineTo(hdc, points.x, points.y);
}
ShowCursor(FALSE);//隐藏鼠标
SetCursor(LoadCursor (NULL, IDC_ARROW));
//恢复原来的鼠标光标
EndPaint(hwnd, &ps);
return 0;
　　以上程序的功能是实现射线族的绘制。程序使用了一个for循环，循环次数为iCoun变量记录的点数。在循环体中反复调用 MoveToEx函数和 LineTo函数绘制直线。MoveToEx函数使直线的起点回到有center变量记录的中点，LineTo函数实现由中点向points数组中的各点绘制直线。
　　在处理WM_PAINT消息的程序中还使用了SetCursor函数和ShowCursor函数。SetCursor函数能设定一个鼠标图标，ShowCursor函数能将设定好的图标显示出来。在本实例中，调用这两个函数的目的是当程序绘制射线族的时候将鼠标图标转换成沙漏图案，表示程序正在执行某次操作。当给制完成后，又重新设置鼠标图像为箭头图标。
　　程序运行后，首先生成一个窗口，等待用户执行鼠标操作。用户右击后，再按下鼠标左键并拖动，则程序会绘制出一簇美丽的射线。运行结果如图所示。

鼠标消息实例2
#include <windows.h>
int WINAPI WinMain(HINSTANCE, HINSTANCE,LPSTR,int);
LRESULT CALLBACK WndProc(HWND,UINT, WPARAM,LPARAM);
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{
　　WNDCLASSEX wcex;
　　wcex.cbSize = sizeof(WNDCLASSEX);
　　wcex.style = CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS;
　　wcex.lpfnWndProc = (WNDPROC)WndProc;
　　wcex.cbClsExtra = 0;
　　wcex.cbWndExtra = 0;
　　wcex.hInstance = hInstance;
　　wcex.hIcon = LoadIcon (NULL,(LPCTSTR)IDI_APPLICATION);
　　wcex.hCursor = LoadCursor (NULL,IDC_ARROW);
　　wcex.hbrBackground = (HBRUSH) (COLOR_WINDOW+1);
　　wcex.lpszMenuName = NULL;
　　wcex.lpszClassName = "SeeMouseMessage";
　　wcex.hIconSm = LoadIcon(NULL,(LPCTSTR)IDI_APPLICATION);
　　if(!RegisterClassEx(&wcex)) return FALSE;
　　int SW_XFS = GetSystemMetrics(SM_CXSCREEN);
　　int SW_YFS = GetSystemMetrics(SM_CYSCREEN);
　　HWND hWnd;
　　hWnd = CreateWindowEx(WS_EX_CLIENTEDGE,
　　　　　　　　　　　　　"SeeMouseMessage",
　　　　　　　　　　　　　"Trace Mouse Operation",
　　　　　　　　　　　　　WS_OVERLAPPEDWINDOW,
　　　　　　　　　　　　　0,
　　　　　　　　　　　　　0,
　　　　　　　　　　　　　SW_XFS,
　　　　　　　　　　　　　SW_YFS-25,
　　　　　　　　　　　　　NULL,
　　　　　　　　　　　　　NULL,
　　　　　　　　　　　　　hInstance,
　　　　　　　　　　　　　NULL);
　　if(!hWnd) return FALSE;
　　ShowWindow(hWnd, nCmdShow);
　　UpdateWindow(hWnd);
　　MSG msg;

　　while(GetMessage(&msg, NULL, 0, 0))
　　{
　　　　TranslateMessage(&msg);
　　　　DispatchMessage(&msg);
　　}
　　return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{
　　HDC hDC;
　　PAINTSTRUCT ps;
　　static char Buffer[256];
　　switch(message)
　　{
　　　　case WM_MOUSEMOVE:
　　　　hDC = GetDC(hWnd);
　　　　wsprintf(Buffer," ");
　　　　TextOut(hDC,20,40,Buffer,strlen(Buffer));
　　　　wsprintf(Buffer," WM_MOUSEMOVE %04x %3d %3d", wParam,LOWORD(lParam),HIWORD(lParam));
　　　　TextOut(hDC,20,40,Buffer,strlen(Buffer));
　　　　ReleaseDC(hWnd,hDC);
　　　　break;

　　　　case WM_LBUTTONDOWN:
　　　　hDC = GetDC(hWnd);
　　　　wsprintf(Buffer," ");
　　　　TextOut(hDC,20,60,Buffer,strlen(Buffer));
　　　　wsprintf(Buffer," WM_LBUTTONDOWN %04x %3d %3d", wParam,LOWORD(lParam),HIWORD(lParam));
　　　　TextOut(hDC,20,60,Buffer,strlen(Buffer));
　　　　ReleaseDC(hWnd,hDC);
　　　　break;

　　　　case WM_LBUTTONUP:
　　　　hDC = GetDC(hWnd);
　　　　wsprintf(Buffer," ");
　　　　TextOut(hDC,20,80,Buffer,strlen(Buffer));
　　　　wsprintf(Buffer," WM_LBUTTONUP %04x %3d %3d", wParam,LOWORD(lParam),HIWORD(lParam));
　　　　TextOut(hDC,20,80,Buffer,strlen(Buffer));
　　　　ReleaseDC(hWnd,hDC);
　　　　break;

　　　　case WM_LBUTTONDBLCLK:
　　　　hDC = GetDC(hWnd);
　　　　wsprintf(Buffer," ");
　　　　TextOut(hDC,20,100,Buffer,strlen(Buffer));
　　　　wsprintf(Buffer," WM_LBUTTONDBLCLK %04x %3d %3d", wParam,LOWORD(lParam),HIWORD(lParam));
　　　　TextOut(hDC,20,100,Buffer,strlen(Buffer));
　　　　ReleaseDC(hWnd,hDC);
　　　　break;

　　　　case WM_RBUTTONDOWN:
　　　　hDC = GetDC(hWnd);
　　　　wsprintf(Buffer," ");
　　　　TextOut(hDC,20,120,Buffer,strlen(Buffer));
　　　　wsprintf(Buffer," WM_RBUTTONDOWN %04x %3d %3d", wParam,LOWORD(lParam),HIWORD(lParam));
　　　　TextOut(hDC,20,120,Buffer,strlen(Buffer));
　　　　ReleaseDC(hWnd,hDC);
　　　　break;

　　　　case WM_RBUTTONUP:
　　　　hDC = GetDC(hWnd);
　　　　wsprintf(Buffer," ");
　　　　TextOut(hDC,20,140,Buffer,strlen(Buffer));
　　　　wsprintf(Buffer," WM_RBUTTONUP %04x %3d %3d", wParam,LOWORD(lParam),HIWORD(lParam));
　　　　TextOut(hDC,20,140,Buffer,strlen(Buffer));
　　　　ReleaseDC(hWnd,hDC);
　　　　break;

　　　　case WM_RBUTTONDBLCLK:
　　　　hDC = GetDC(hWnd);
　　　　wsprintf(Buffer," ");
　　　　TextOut(hDC,20,160,Buffer,strlen(Buffer));
　　　　wsprintf(Buffer,"WM_RBUTTONDBLCLK %04x %3d %3d", wParam,LOWORD(lParam),HIWORD(lParam));
　　　　TextOut(hDC,20,160,Buffer,strlen(Buffer));
　　　　ReleaseDC(hWnd,hDC);
　　　　break;

　　　　case WM_PAINT:
　　　　hDC = BeginPaint(hWnd,&ps);
　　　　wsprintf(Buffer," ");
　　　　TextOut(hDC,20,20,Buffer,strlen(Buffer));
　　　　wsprintf(Buffer," Message wParam x y");
　　　　TextOut(hDC,20,20,Buffer,strlen(Buffer));
　　　　EndPaint(hWnd,&ps);
　　　　break;

　　　　case WM_DESTROY:
　　　　PostQuitMessage(0);
　　　　break;

　　　　default:
　　　　return DefWindowProc(hWnd,message,wParam,lParam);
　　}
　　return 0;
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/forzy/archive/2007/06/27/1668256.aspx

printf()格式转换的一般形式如下
%(flags)(width)(.prec)type
以中括号括起来的参数为选择性参数，而%与type则是必要的。底下先介绍type的几种形式

整数
%d 整数的参数会被转成一有符号的十进制数字
%u 整数的参数会被转成一无符号的十进制数字
%o 整数的参数会被转成一无符号的八进制数字
%x 整数的参数会被转成一无符号的十六进制数字，并以小写abcdef表示
%X 整数的参数会被转成一无符号的十六进制数字，并以大写ABCDEF表示浮点型数

%f double 型的参数会被转成十进制数字，并取到小数点以下六位，四舍五入。
%e double型的参数以指数形式打印，有一个数字会在小数点前，六位数字在小数点后，而在指数部分会以小写的e来表示。
%E 与%e作用相同，唯一区别是指数部分将以大写的E 来表示。
%g double 型的参数会自动选择以%f 或%e 的格式来打印，其标准是根据欲打印的数值及所设置的有效位数来决定。
%G 与%g 作用相同，唯一区别在以指数形态打印时会选择%E 格式。

字符及字符串
%c 整型数的参数会被转成unsigned char型打印出。
%s 指向字符串的参数会被逐字输出，直到出现NULL字符为止
%p 如果是参数是“void *”型指针则使用十六进制格式显示。

prec 有几种情况
1. 正整数的最小位数。
2. 在浮点型数中代表小数位数
3. 在%g 格式代表有效位数的最大值。
4. 在%s格式代表字符串的最大长度。
5. 若为×符号则代表下个参数值为最大长度。

width为参数的最小长度，若此栏并非数值，而是*符号，则表示以下一个参数当做参数长度。

flags 有下列几种情况
#NAME?
+ 一般在打印负数时，printf( )会加印一个负号，整数则不加任何负号。此旗标会使得在打印正数前多一个正号（+）。
# 此旗标会根据其后转换字符的不同而有不同含义。当在类型为o 之前（如%#o），则会在打印八进制数值前多印一个o。
而在类型为x 之前（%#x）则会在打印十六进制数前多印’0x’，在型态为e、E、f、g或G 之前则会强迫数值打印小数点。在类型为g 或G之前时则同时保留小数点及小数位数末尾的零。
0 当有指定参数时，无数字的参数将补上0。默认是关闭此旗标，所以一般会打印出空白字符。

下来之后，安装到某个目录，然后配置VC，把那个目录的include和lib两个目录放到VC的选项->目录里面。在project->settings->link->Object/library Modules下面添加“wpcap.lib Packet.lib”，用空格隔开；在project->settings->C/C++->Preprocessor difinitions下面添加“WPCAP,HAVE_REMOTE”，用逗号隔开。

WinPcap目录下有doc文档，里面的东西相当全面。

如果程序出现如下错误：
F:\学习\test.cpp(155) : error C2065: ’socklen_t’ : undeclared identifier
F:\学习\test.cpp(155) : error C2146: syntax error : missing ‘;’ before identifier ’sockaddrlen’
F:\学习\test.cpp(155) : error C2065: ’sockaddrlen’ : undeclared identifier
F:\学习\test.cpp(164) : error C2065: ‘getnameinfo’ : undeclared identifier
F:\学习\test.cpp(170) : error C2065: ‘NI_NUMERICHOST’ : undeclared identifier

错误根由是因为WinPcap支持ipv6,而VC的winsock2.h太老了，很多结构都没有被支持，所以产生错误。网上有人说可以用VS新版本调试，我电脑里面是VS2008，但是仍然产生错误。

既然VS也无法通过，我实在没能力去修改WinPcap的头文件，所以就用最后一个方案，使用VC6.0的最新的PlatForm SDK开发包，里面包含了新的头文件，就可以支持WinPcap了。

有人说PSDK只有Windows2003的版本，我在微软里面找到了WinXPSP2的PSDK。

网址如下

http://www.microsoft.com/msdownload/platformsdk/sdkupdate/XPSP2FULLInstall.htm

里面好几个Cab，网页里面有完整的安装说明。

下面是PlatFormSDK安装步骤

(1)安装过程:

CMD运行PSDK-FULL.bat，参数为一个目录，里面会被解压缩安装包，然后Setup，一路Next就可以了。

(2)配置过程

打开Visual C++6.0，在选项里面连接，把PSDK安装后的include和lib加入相应的位置。

特别注意，要把这些目录的顺序调高，我直接放到了最高层去了。

呵呵，编译一下，通过了，好Happy啊。

很多程序员下载了 winpcap 3.1 或更新的版本后，会发现原来自己运行得好好的程序突然不能使用了。而且其中涉及到一些相当重要的函数，比如 pcap_loop。 winpcap 对这些函数的修改使得很多基于它的应用程序（比如windump和snort）都将作出不小的改动。当然，还有你自己编写的代码……

以下是 windows 本身的 winsock 编程对此问题的影响。由于新版的 winpcap 完全使用了新的 winsock（支持ipv6），因此下列问题可能影响到每一个程序。

这是新旧两版的 packet32.h 之间的差异

//packet32.h
typedef struct npf_if_addr {
struct sockaddr ipaddress; ///< ip address.
struct sockaddr subnetmask; ///< netmask for that address.
struct sockaddr broadcast; ///< broadcast address.
//struct sockaddr_storage ipaddress; ///< ip address.
//struct sockaddr_storage subnetmask; ///< netmask for that address.
//struct sockaddr_storage broadcast; ///< broadcast address.
}npf_if_addr;

http://msdn.microsoft.com/library/default.html?url=/library/en-us/winsock/winsock/sockaddr_storage_2.html

很多程序员仍然使用 visual c++6 编译程序，不幸的是，vc++6中的 winsock2.h 太老了，它根本不认得 struct sockaddr_storage。因此，winpcap 自带的例程在 vc++6 下编译时会无情地抛出无数错误。事实上，该结构完全可以使用老的 sockaddr 代替。手工改动 packet32.h，将 sockaddr_storage 换成 sockaddr，编译将顺利通过。当然，这样的代码自然无法支持 ipv6 了。到目前为止，我没有找到在 vc++6 与windows 2003中成功编译 ipv6 的例程。windows 2000 的用户可以升级sdk，使自己的vc++6支持ipv6编程，但不幸的是这个sdk升级版检查操作系统的版本，不是2195就停止了安装，使我在 windows xp 和 win 2003 下无法安装。在作者写本文时，没有找到对 win xp 和 win 2003 的 ipv6 sdk。我没有安装那个巨达 106m 的 windows 2003 开发升级包，但估计那个包中可能有支持 ipv6 开发所需的库和头文件。我也不排除对 for 2000 的sdk包做做手脚，提取其中的文件后能够成功运行的可能。因为 microsoft visual studio.net 2002/2003 已经对此提供了很好的支持。

躲过了 sockaddr_storage 一劫的朋友可能很快会遇到 socklen_t 和 getnameinfo 函数的错误。这两个函数包含在头文件 ws2tcpip.h 中。很不幸，它也是一个 for ipv6 的函数，在vc++6中同样没有支持。编译时发生的错误如下：

--------------------configuration: iflist - win32 debug--------------------
compiling...
iflist.c
g:\security\ids\wpdpack\examples\iflist\iflist.c(151) : error c2065: socklen_t : undeclared identifier
g:\security\ids\wpdpack\examples\iflist\iflist.c(151) : error c2146: syntax error : missing ; before identifier sockaddrlen
g:\security\ids\wpdpack\examples\iflist\iflist.c(151) : error c2065: sockaddrlen : undeclared identifier
g:\security\ids\wpdpack\examples\iflist\iflist.c(160) : warning c4013: getnameinfo undefined; assuming extern returning int
g:\security\ids\wpdpack\examples\iflist\iflist.c(166) : error c2065: ni_numerichost : undeclared identifier
error executing cl.exe.

iflist.exe - 4 error(s), 1 warning(s)

关于该函数，可以参考微软msdn：

http://msdn.microsoft.com/library/default.html?url=/library/en-us/winsock/winsock/getnameinfo_2.html

同样，如果你不介意让程序仅能在 ipv4 上工作的话，可以用原来的函数 gethostbyname 代替。

原文地址：http://blog.chinaunix.net/u2/64540/showart_573227.html

关键字：UTC（世界标准时间），Calendar Time（日历时间），epoch（时间点），clock tick（时钟计时单元）

1．概念
在C/C++中，对字符串的操作有很多值得注意的问题，同样，C/C++对时间的操作也有许多值得大家注意的地方。最近，在技术群中有很多网友也多次问到过C++语言中对时间的操作、获取和显示等等的问题。下面，在这篇文章中，笔者将主要介绍在C/C++中时间和日期的使用方法.

通过学习许多C/C++库，你可以有很多操作、使用时间的方法。但在这之前你需要了解一些“时间”和“日期”的概念，主要有以下几个：

Coordinated Universal Time（UTC）：协调世界时，又称为世界标准时间，也就是大家所熟知的格林威治标准时间（Greenwich Mean Time，GMT）。比如，中国内地的时间与UTC的时差为+8，也就是UTC+8。美国是UTC-5。

Calendar Time：日历时间，是用“从一个标准时间点到此时的时间经过的秒数”来表示的时间。这个标准时间点对不同的编译器来说会有所不同，但对一个编译系统来说，这个标准时间点是不变的，该编译系统中的时间对应的日历时间都通过该标准时间点来衡量，所以可以说日历时间是“相对时间”，但是无论你在哪一个时区，在同一时刻对同一个标准时间点来说，日历时间都是一样的。

epoch：时间点。时间点在标准C/C++中是一个整数，它用此时的时间和标准时间点相差的秒数（即日历时间）来表示。

clock tick：时钟计时单元（而不把它叫做时钟滴答次数），一个时钟计时单元的时间长短是由CPU控制的。一个clock tick不是CPU的一个时钟周期，而是C/C++的一个基本计时单位。

我们可以使用ANSI标准库中的time.h头文件。这个头文件中定义的时间和日期所使用的方法，无论是在结构定义，还是命名，都具有明显的C语言风格。下面，我将说明在C/C++中怎样使用日期的时间功能。

2． 计时

C/C++中的计时函数是clock()，而与其相关的数据类型是clock_t。在MSDN中，查得对clock函数定义如下：

clock_t clock( void );

这个函数返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数，在MSDN中称之为挂钟时间（wall-clock）。其中clock_t是用来保存时间的数据类型，在time.h文件中，我们可以找到对它的定义：

#ifndef _CLOCK_T_DEFINED
typedef long clock_t;
#define _CLOCK_T_DEFINED
#endif

很明显，clock_t是一个长整形数。在time.h文件中，还定义了一个常量CLOCKS_PER_SEC，它用来表示一秒钟会有多少个时钟计时单元，其定义如下：

#define CLOCKS_PER_SEC ((clock_t)1000)

可以看到可以看到每过千分之一秒（1毫秒），调用clock（）函数返回的值就加1。下面举个例子，你可以使用公式clock()/CLOCKS_PER_SEC来计算一个进程自身的运行时间：

void elapsed_time()
{
printf("Elapsed time:%u secs.\n",clock()/CLOCKS_PER_SEC);
}

当然，你也可以用clock函数来计算你的机器运行一个循环或者处理其它事件到底花了多少时间：

＃i nclude “stdio.h”
＃i nclude “stdlib.h”
＃i nclude “time.h”

int main( void )
{
   long    i = 10000000L;
   clock_t start, finish;
   double duration;
   /* 测量一个事件持续的时间*/
   printf( "Time to do %ld empty loops is ", i );
   start = clock();
   while( i-- )      ;
   finish = clock();
   duration = (double)(finish - start) / CLOCKS_PER_SEC;
   printf( "%f seconds\n", duration );
   system("pause");
}

在笔者的机器上，运行结果如下：

Time to do 10000000 empty loops is 0.03000 seconds

上面我们看到时钟计时单元的长度为1毫秒，那么计时的精度也为1毫秒，那么我们可不可以通过改变CLOCKS_PER_SEC的定义，通过把它定义的大一些，从而使计时精度更高呢？通过尝试，你会发现这样是不行的。在标准C/C++中，最小的计时单位是一毫秒。

3．与日期和时间相关的数据结构

在标准C/C++中，我们可通过tm结构来获得日期和时间，tm结构在time.h中的定义如下：

#ifndef _TM_DEFINED
struct tm {
     int tm_sec;    /* 秒 – 取值区间为[0,59] */
     int tm_min;    /* 分 - 取值区间为[0,59] */
     int tm_hour;    /* 时 - 取值区间为[0,23] */
     int tm_mday;    /* 一个月中的日期 - 取值区间为[1,31] */
     int tm_mon;    /* 月份（从一月开始，0代表一月） - 取值区间为[0,11] */
     int tm_year;    /* 年份，其值等于实际年份减去1900 */
     int tm_wday;    /* 星期 – 取值区间为[0,6]，其中0代表星期天，1代表星期一，以此类推 */
     int tm_yday;    /* 从每年的1月1日开始的天数 – 取值区间为[0,365]，其中0代表1月1日，1代表1月2日，以此类推 */
     int tm_isdst;    /* 夏令时标识符，实行夏令时的时候，tm_isdst为正。不实行夏令时的进候，tm_isdst为0；不了解情况时，tm_isdst()为负。*/
     };
#define _TM_DEFINED
#endif

ANSI C标准称使用tm结构的这种时间表示为分解时间(broken-down time)。

而日历时间（Calendar Time）是通过time_t数据类型来表示的，用time_t表示的时间（日历时间）是从一个时间点（例如：1970年1月1日0时0分0秒）到此时的秒数。在time.h中，我们也可以看到time_t是一个长整型数：

#ifndef _TIME_T_DEFINED
typedef long time_t;        /* 时间值 */
#define _TIME_T_DEFINED    /* 避免重复定义 time_t */
#endif

大家可能会产生疑问：既然time_t实际上是长整型，到未来的某一天，从一个时间点（一般是1970年1月1日0时0分0秒）到那时的秒数（即日历时间）超出了长整形所能表示的数的范围怎么办？对time_t数据类型的值来说，它所表示的时间不能晚于2038年1月18日19时14分07秒。为了能够表示更久远的时间，一些编译器厂商引入了64位甚至更长的整形数来保存日历时间。比如微软在Visual C++中采用了__time64_t数据类型来保存日历时间，并通过_time64()函数来获得日历时间（而不是通过使用32位字的time()函数），这样就可以通过该数据类型保存3001年1月1日0时0分0秒（不包括该时间点）之前的时间。

在time.h头文件中，我们还可以看到一些函数，它们都是以time_t为参数类型或返回值类型的函数：

double difftime(time_t time1, time_t time0);
time_t mktime(struct tm * timeptr);
time_t time(time_t * timer);
char * asctime(const struct tm * timeptr);
char * ctime(const time_t *timer);

此外，time.h还提供了两种不同的函数将日历时间（一个用time_t表示的整数）转换为我们平时看到的把年月日时分秒分开显示的时间格式tm：

struct tm * gmtime(const time_t *timer);                            
struct tm * localtime(const time_t * timer);

通过查阅MSDN，我们可以知道Microsoft C/C++ 7.0中时间点的值（time_t对象的值）是从1899年12月31日0时0分0秒到该时间点所经过的秒数，而其它各种版本的Microsoft C/C++和所有不同版本的Visual C++都是计算的从1970年1月1日0时0分0秒到该时间点所经过的秒数。

4．与日期和时间相关的函数及应用
在本节，我将向大家展示怎样利用time.h中声明的函数对时间进行操作。这些操作包括取当前时间、算时间间隔、以不同的形式显示时间等内容。

4.1 获得日历时间

我们可以通过time()函数来获得日历时间（Calendar Time），其原型为：

time_t time(time_t * timer);

如果你已经声明了参数timer，你可以从参数timer返回现在的日历时间，同时也可以通过返回值返回现在的日历时间，即从一个时间点（例如：1970 年1月1日0时0分0秒）到现在此时的秒数。如果参数为空（NULL），函数将只通过返回值返回现在的日历时间，比如下面这个例子用来显示当前的日历时间：

＃i nclude "time.h"
＃i nclude "stdio.h"
int main(void)
{
struct tm *ptr;
time_t lt;
lt =time(NULL);
printf("The Calendar Time now is %d\n",lt);
return 0;
}

运行的结果与当时的时间有关，我当时运行的结果是：

The Calendar Time now is 1122707619

其中1122707619就是我运行程序时的日历时间。即从1970年1月1日0时0分0秒到此时的秒数。

4.2 获得日期和时间

这里说的日期和时间就是我们平时所说的年、月、日、时、分、秒等信息。从第2节我们已经知道这些信息都保存在一个名为tm的结构体中，那么如何将一个日历时间保存为一个tm结构的对象呢？

其中可以使用的函数是gmtime()和localtime()，这两个函数的原型为：

struct tm * gmtime(const time_t *timer);                            
struct tm * localtime(const time_t * timer);

其中gmtime()函数是将日历时间转化为世界标准时间（即格林尼治时间），并返回一个tm结构体来保存这个时间，而localtime()函数是将日历时间转化为本地时间。比如现在用gmtime()函数获得的世界标准时间是2005年7月30日7点18分20秒，那么我用localtime()函数在中国地区获得的本地时间会比时间标准时间晚8个小时，即2005年7月30日15点18分20秒。下面是个例子：

＃i nclude "time.h"
＃i nclude "stdio.h"
int main(void)
{
struct tm *local;
time_t t;
t=time(NULL);
local=localtime(&t);
printf("Local hour is: %d\n",local->tm_hour);
local=gmtime(&t);
printf("UTC hour is: %d\n",local->tm_hour);
return 0;
}

运行结果是：

Local hour is: 15
UTC hour is: 7

4.3 固定的时间格式

我们可以通过asctime()函数和ctime()函数将时间以固定的格式显示出来，两者的返回值都是char*型的字符串。返回的时间格式为：

星期几 月份 日期 时:分:秒 年\n\0
例如：Wed Jan 02 02:03:55 1980\n\0

其中\n是一个换行符，\0是一个空字符，表示字符串结束。下面是两个函数的原型：

char * asctime(const struct tm * timeptr);
char * ctime(const time_t *timer);

其中asctime()函数是通过tm结构来生成具有固定格式的保存时间信息的字符串，而ctime()是通过日历时间来生成时间字符串。这样的话， asctime（）函数只是把tm结构对象中的各个域填到时间字符串的相应位置就行了，而ctime（）函数需要先参照本地的时间设置，把日历时间转化为本地时间，然后再生成格式化后的字符串。在下面，如果lt是一个非空的time_t变量的话，那么：

printf(ctime(<));

等价于：

struct tm *ptr;
ptr=localtime(<);
printf(asctime(ptr));

那么，下面这个程序的两条printf语句输出的结果就是不同的了（除非你将本地时区设为世界标准时间所在的时区）：

＃i nclude "time.h"
＃i nclude "stdio.h"
int main(void)
{
struct tm *ptr;
time_t lt;
lt =time(NULL);
ptr=gmtime(<);
printf(asctime(ptr));
printf(ctime(<));
return 0;
}

运行结果：

Sat Jul 30 08:43:03 2005
Sat Jul 30 16:43:03 2005

4.4 自定义时间格式

我们可以使用strftime（）函数将时间格式化为我们想要的格式。它的原型如下：

size_t strftime(
   char *strDest,
   size_t maxsize,
   const char *format,
   const struct tm *timeptr
);

我们可以根据format指向字符串中格式命令把timeptr中保存的时间信息放在strDest指向的字符串中，最多向strDest中存放maxsize个字符。该函数返回向strDest指向的字符串中放置的字符数。

函数strftime()的操作有些类似于sprintf()：识别以百分号(%)开始的格式命令集合，格式化输出结果放在一个字符串中。格式化命令说明串strDest中各种日期和时间信息的确切表示方法。格式串中的其他字符原样放进串中。格式命令列在下面，它们是区分大小写的。

%a 星期几的简写
%A 星期几的全称
%b 月分的简写
%B 月份的全称
%c 标准的日期的时间串
%C 年份的后两位数字
%d 十进制表示的每月的第几天
%D 月/天/年
%e 在两字符域中，十进制表示的每月的第几天
%F 年-月-日
%g 年份的后两位数字，使用基于周的年
%G 年分，使用基于周的年
%h 简写的月份名
%H 24小时制的小时
%I 12小时制的小时
%j 十进制表示的每年的第几天
%m 十进制表示的月份
%M 十时制表示的分钟数
%n 新行符
%p 本地的AM或PM的等价显示
%r 12小时的时间
%R 显示小时和分钟：hh:mm
%S 十进制的秒数
%t 水平制表符
%T 显示时分秒：hh:mm:ss
%u 每周的第几天，星期一为第一天 （值从0到6，星期一为0）
%U 第年的第几周，把星期日做为第一天（值从0到53）
%V 每年的第几周，使用基于周的年
%w 十进制表示的星期几（值从0到6，星期天为0）
%W 每年的第几周，把星期一做为第一天（值从0到53）
%x 标准的日期串
%X 标准的时间串
%y 不带世纪的十进制年份（值从0到99）
%Y 带世纪部分的十制年份
%z，%Z 时区名称，如果不能得到时区名称则返回空字符。
%% 百分号

如果想显示现在是几点了，并以12小时制显示，就象下面这段程序：

＃i nclude “time.h”
＃i nclude “stdio.h”
int main(void)
{
struct tm *ptr;
time_t lt;
char str[80];
lt=time(NULL);
ptr=localtime(<);
strftime(str,100,"It is now %I %p",ptr);
printf(str);
return 0;
}

其运行结果为：
It is now 4PM

而下面的程序则显示当前的完整日期：

＃i nclude
＃i nclude

void main( void )
{
     struct tm *newtime;
     char tmpbuf[128];
     time_t lt1;
     time( <1 );
     newtime=localtime(<1);
     strftime( tmpbuf, 128, "Today is %A, day %d of %B in the year %Y.\n", newtime);
     printf(tmpbuf);
}

运行结果：

Today is Saturday, day 30 of July in the year 2005.

4.5 计算持续的时间长度

有时候在实际应用中要计算一个事件持续的时间长度，比如计算打字速度。在第1节计时部分中，我已经用clock函数举了一个例子。Clock()函数可以精确到毫秒级。同时，我们也可以使用difftime()函数，但它只能精确到秒。该函数的定义如下：

double difftime(time_t time1, time_t time0);

虽然该函数返回的以秒计算的时间间隔是double类型的，但这并不说明该时间具有同double一样的精确度，这是由它的参数觉得的（time_t是以秒为单位计算的）。比如下面一段程序：

＃i nclude “time.h”
＃i nclude “stdio.h”
＃i nclude “stdlib.h”
int main(void)
{
time_t start,end;
start = time(NULL);
system("pause");
end = time(NULL);
printf("The pause used %f seconds.\n",difftime(end,start));//<-
system("pause");
return 0;
}

运行结果为：
请按任意键继续. . .
The pause used 2.000000 seconds.
请按任意键继续. . .

可以想像，暂停的时间并不那么巧是整整2秒钟。其实，你将上面程序的带有“//<-”注释的一行用下面的一行代码替换：

printf("The pause used %f seconds.\n",end-start);

其运行结果是一样的。

4.6 分解时间转化为日历时间

这里说的分解时间就是以年、月、日、时、分、秒等分量保存的时间结构，在C/C++中是tm结构。我们可以使用mktime（）函数将用tm结构表示的时间转化为日历时间。其函数原型如下：

time_t mktime(struct tm * timeptr);

其返回值就是转化后的日历时间。这样我们就可以先制定一个分解时间，然后对这个时间进行操作了，下面的例子可以计算出1997年7月1日是星期几：

＃i nclude "time.h"
＃i nclude "stdio.h"
＃i nclude "stdlib.h"
int main(void)
{
struct tm t;
time_t t_of_day;
t.tm_year=1997-1900;
t.tm_mon=6;
t.tm_mday=1;
t.tm_hour=0;
t.tm_min=0;
t.tm_sec=1;
t.tm_isdst=0;
t_of_day=mktime(&t);
printf(ctime(&t_of_day));
return 0;
}

运行结果：

Tue Jul 01 00:00:01 1997

现在注意了，有了mktime()函数，是不是我们可以操作现在之前的任何时间呢？你可以通过这种办法算出1945年8月15号是星期几吗？答案是否定的。因为这个时间在1970年1月1日之前，所以在大多数编译器中，这样的程序虽然可以编译通过，但运行时会异常终止。

以.pch为扩展名的)，这个文件就称为预编译头文件这些预先编译好的代码可以是任何的

C/C++代码--------甚至是inline的函数，但是必须是稳定的，在工程开发的过程中不会

被经常改变。如果这些代码被修改，则需要重新编译生成预编译头文件。注意生成预编

译头文件是很耗时间的。同时你得注意预编译头文件通常很大，通常有6-7M大。注意及

时清理那些没有用的预编译头文件。

也许你会问：现在的编译器都有Time stamp的功能，编译器在编译整个工程的时候，它

只会编译那些经过修改的文件，而不会去编译那些从上次编译过，到现在没有被修改过

的文件。那么为什么还要预编译头文件呢？答案在这里，我们知道编译器是以文件为单

位编译的，一个文件经过修改后，会重新编译整个文件，当然在这个文件里包含的所有

头文件中的东西（.eg Macro, Preprocesser ）都要重新处理一遍。VC的预编译头文件

保存的正是这部分信息。以避免每次都要重新处理这些头文件。

预编译头的作用：

根据上文介绍，预编译头文件的作用当然就是提高便宜速度了，有了它你没有必要每次

都编译那些不需要经常改变的代码。编译性能当然就提高了。

预编译头的使用：

要使用预编译头，我们必须指定一个头文件，这个头文件包含我们不会经常改变的

代码和其他的头文件，然后我们用这个头文件来生成一个预编译头文件（.pch文件）

想必大家都知道 StdAfx.h这个文件。很多人都认为这是VC提供的一个“系统级别”的

，编译器带的一个头文件。其实不是的，这个文件可以是任何名字的。我们来考察一个

典型的由AppWizard生成的MFC Dialog Based　程序的预编译头文件。（因为AppWizard

会为我们指定好如何使用预编译头文件，默认的是StdAfx.h，这是VC起的名字）。我们

会发现这个头文件里包含了以下的头文件：

#include <afxwin.h> // MFC core and standard components

#include <afxext.h> // MFC extensions

#include <afxdisp.h> // MFC Automation classes

#include <afxdtctl.h> // MFC support for Internet Explorer 4

Common Controls

#include <afxcmn.h>

这些正是使用MFC的必须包含的头文件，当然我们不太可能在我们的工程中修改这些头文

件的，所以说他们是稳定的。

那么我们如何指定它来生成预编译头文件。我们知道一个头文件是不能编译的。所以我

们还需要一个cpp文件来生成.pch 文件。这个文件默认的就是StdAfx.cpp。在这个文件

里只有一句代码就是：#include “Stdafx.h”。原因是理所当然的，我们仅仅是要它能

够编译而已?D?D?D也就是说，要的只是它的.cpp的扩展名。我们可以用/Yc编译开关来指

定StdAfx.cpp来生成一个.pch文件，通过/Fp编译开关来指定生成的pch文件的名字。打

开project ->Setting->C/C++ 对话框。把Category指向Precompiled Header。在左边的

树形视图里选择整个工程　

Project Options(右下角的那个白的地方)可以看到 /Fp “debug/PCH.pch”，这就是指

定生成的.pch文件的名字，默认的通常是　<工程名>.pch（我的示例工程名就是PCH）。

然后，在左边的树形视图里选择StdAfx.cpp.//这时只能选一个cpp文件！

这时原来的Project Option变成了 Source File Option（原来是工程，现在是一个文件

，当然变了）。在这里我们可以看到 /Yc开关，/Yc的作用就是指定这个文件来创建一个

Pch文件。/Yc后面的文件名是那个包含了稳定代码的头文件，一个工程里只能有一个文

件的可以有YC开关。VC就根据这个选项把 StdAfx.cpp编译成一个Obj文件和一个PCH文件

。

然后我们再选择一个其它的文件来看看，//其他cpp文件

在这里，Precomplier 选择了 Use ⋯⋯⋯一项，头文件是我们指定创建PCH 文件的stda

fx.h

文件。事实上，这里是使用工程里的设置，（如图1）/Yu”stdafx.h”。

这样，我们就设置好了预编译头文件。也就是说，我们可以使用预编译头功能了。以

下是注意事项：

1):如果使用了/Yu，就是说使用了预编译，我们在每个.cpp文件的最开头，我强调一遍

是最开头，包含 你指定产生pch文件的.h文件（默认是stdafx.h）不然就会有问题。如

果你没有包含这个文件，就告诉你Unexpected file end. 如果你不是在最开头包含的，

你自己试以下就知道了，绝对有很惊人的效果⋯..

fatal error C1010: unexpected end of file while looking for precompiled

header directive

Generating Code...

2）如果你把pch文件不小心丢了，编译的时候就会产生很多的不正常的行为。根据以上

的分析，你只要让编译器生成一个pch文件。也就是说把 stdafx.cpp（即指定/Yc的那个

cpp文件）从新编译一遍。当然你可以傻傻的 Rebuild All。简单一点就是选择那个cpp

文件，按一下Ctrl + F7就可以了。不然可是很浪费时间的哦。

本文讨论的是五种常用的C/C++编译器对64位整型的支持，这五种编译器分别是gcc(mingw32)，g++(mingw32)，gcc(linux i386)，g++(linux i386)，Microsoft Visual C++ 6.0。可惜的是，没有一种定义和输出方式组合，同时兼容这五种编译器。为彻底弄清不同编译器对64位整型，我写了程序对它们进行了评测，结果如下表。

上表中，正确指编译通过，运行完全正确；错误指编译虽然通过，但运行结果有误；无法编译指编译器根本不能编译完成。观察上表，我们可以发现以下几点：

1. long long定义方式可以用于gcc/g++，不受平台限制，但不能用于VC6.0。
2. __int64是Win32平台编译器64位长整型的定义方式，不能用于Linux。
3. “%lld”用于Linux i386平台编译器，”%I64d”用于Win32平台编译器。
4. cout只能用于C++编译，在VC6.0中，cout不支持64位长整型。

表中最后一行输出方式中的printint64()是我自己写的一个函数，可以看出，它的兼容性要好于其他所有的输出方式，它是一段这样的代码：

void printint64(long long a)
            {
            if (a<=100000000)
            printf("%d\n",a);
            else
            {
            printf("%d",a/100000000);
            printf("%08d\n",a%100000000);
            }
            }

这种写法的本质是把较大的64位整型拆分为两个32位整型，然后依次输出，低位的部分要补0。看似很笨的写法，效果如何？我把它和cout输出方式做了比较，因为它和cout都是C++支持跨平台的。首先printint64()和cout(不清空缓冲区)的运行结果是完全相同的，不会出现错误。我的试验是分别用两者输出1000000个随机数，实际结果是，printint64()在1.5s内跑完了程序，而cout需要2s。cout要稍慢一些，所以在输出大量数据时，要尽量避免使用。

在网上找到了解决方法：