c语言键盘钩子

mfc 键盘hook例子MFC键盘钩子示例本示例展示了如何在 MFC 应用程序中使用键盘钩子来监视键盘输入。

创建键盘钩子1. 在 MFC 应用程序中添加一个新类，例如 `CKeyboardHook`。

2. 在 `CKeyboardHook` 类中，实现 `SetWindowsHookEx` 函数来设置键盘钩子。

此函数接收以下参数：- WH_KEYBOARD：指定要安装的钩子类型（键盘钩子）- `CKeyboardHook::HookProc`：指向钩子回调函数的指针- `GetCurrentThreadId()`：当前线程的标识符- 0：表示钩子应安装在所有线程中以下是 `SetWindowsHookEx` 函数的示例代码：```cppbool CKeyboardHook::InstallHook(){m_hHook = SetWindowsHookEx(WH_KEYBOARD, HookProc, GetCurrentThreadId(), 0);return m_hHook != NULL;}```钩子回调函数3. 实现钩子回调函数 `CKeyboardHook::HookProc`。

此函数将在每次按下或松开键盘键时调用。

4. 回调函数应接收以下参数：- `int nCode`：指定钩子代码（例如 HC_ACTION）- `WPARAM wParam`：与此钩子关联的其他信息- `LPARAM lParam`：指向包含按键信息的`KBDLLHOOKSTRUCT` 结构的指针以下是 `CKeyboardHook::HookProc` 函数的示例代码：```cppLRESULT CALLBACK CKeyboardHook::HookProc(int nCode, WPARAM wParam, LPARAM lParam){if (nCode == HC_ACTION){KBDLLHOOKSTRUCT pKeyboardInfo = (KBDLLHOOKSTRUCT)lParam;// 处理键盘输入}return CallNextHookEx(NULL, nCode, wParam, lParam);}```处理键盘输入5. 在 `CKeyboardHook::HookProc` 回调函数中，可以处理键盘输入。

系统钩子和DLL钩子的本质是一段用以处理系统消息的程序，通过系统调用，将其挂入系统。

钩子的种类有很多，每种钩子可以截获并处理相应的消息，每当特定的消息发出，在到达目的窗口之前，钩子程序先行截获该消息、得到对此消息的控制权。

此时在钩子函数中就可以对截获的消息进行加工处理，甚至可以强制结束消息的传递。

在本程序中我们需要捕获在任意窗口上的键盘输入，这就需要采用全局钩子以便拦截整个系统的消息，而全局钩子函数必须以DLL（动态连接库）为载体进行封装，VC6中有三种形式的MFC DLL可供选择，即Regular statically linked to MFC DLL（标准静态链接MFC DLL）、Regular using the shared MFC DLL（标准动态链接MFC DLL）以及Extension MFC DLL（扩展MFC DLL）。

在本程序中为方便起见采用了标准静态连接MFC DLL。

键盘钩子程序示例本示例程序用到全局钩子函数，程序分两部分：可执行程序KeyKook和动态连接库LaunchDLL。

首先创建一个MFC AppWizard(DLL)工程，并选择Regular statically linked to MFC DLL （标准静态链接MFC DLL）选项，以建立MFC扩展动态连接库LaunchDLL.dll。

之后，在相应的头文件中添加宏定义和待导出函数的声明：#define DllExport __declspec(dllexport)……DllExport void WINAPI InstallLaunchEv();……class CLaunchDLLApp : public CWinApp{public:CLaunchDLLApp();//{{AFX_VIRTUAL(CLaunchDLLApp)//}}AFX_VIRTUAL//{{AFX_MSG(CLaunchDLLApp)// NOTE - the ClassWizard will add and remove member functions here.// DO NOT EDIT what you see in these blocks of generated code !//}}AFX_MSGDECLARE_MESSAGE_MAP()};同时在实现文件中添加全局变量Hook和全局函数LauncherHook（）、SaveLog（）：HHOOK Hook;LRESULT CALLBACK LauncherHook(int nCode,WPARAM wParam,LPARAM lParam);void SaveLog(char* c);最后，完成以上提到的这几个函数的具体编码实现：CLaunchDLLApp theApp;……DllExport void WINAPI InstallLaunchEv(){Hook=(HHOOK)SetWindowsHookEx(WH_KEYBOARD,(HOOKPROC)LauncherHook,theApp.m_hInst ance,0);}在此我们实现了Windows的系统钩子的安装，首先要调用SDK中的API函数SetWindowsHookEx（）来安装这个钩子函数，其原型是：HHOOK SetWindowsHookEx(int idHook,HOOKPROC lpfn,HINSTANCE hMod,DWORD dwThreadId);其中，第一个参数指定钩子的类型，常用的有WH_MOUSE、WH_KEYBOARD、WH_GETMESSAGE等，在此我们只关心键盘操作所以设定为WH_KEYBOARD；第二个参数标识钩子函数的入口地址，当钩子钩到任何消息后便调用这个函数,即当不管系统的哪个窗口有键盘输入马上会引起LauncherHook的动作；第三个参数是钩子函数所在模块的句柄，我们可以很简单的设定其为本应用程序的实例句柄；最后一个参数是钩子相关函数的ID用以指定想让钩子去钩哪个线程，为0时则拦截整个系统的消息，在本程序中钩子需要为全局钩子，故设定为0。

C语言中钩子函数和回调函数的区别一、定义1. 钩子函数：钩子函数是在特定事件发生时自动调用的函数，用于拦截和处理这些事件。

在C语言中，钩子函数通常用于实现操作系统的消息处理机制，比如监控键盘、鼠标等输入设备的输入事件。

2. 回调函数：回调函数是作为参数传递给其他函数的函数，用于在特定事件发生时被调用。

在C语言中，回调函数通常用于实现异步操作，比如在网络通信中接收到数据时的处理。

二、调用方式1. 钩子函数：钩子函数是由操作系统或特定的库自动调用的，程序员无法直接调用钩子函数。

2. 回调函数：回调函数是作为参数传递给其他函数的，程序员需要在调用该函数时指定回调函数的名称或指针。

三、作用范围1. 钩子函数：钩子函数对系统的事件进行拦截和处理，可以改变系统的行为。

比如在Windows操作系统中，可以使用钩子函数来拦截键盘输入，实现快捷键功能。

2. 回调函数：回调函数用于在特定事件发生时被调用，通常用于实现异步操作或事件通知。

比如在网络通信中，可以使用回调函数来处理接收到的数据。

四、编程实现1. 钩子函数：在C语言中实现钩子函数通常需要调用操作系统或特定库提供的函数，并注册钩子函数。

钩子函数的实现方式因操作系统和应用场景的不同而异。

2. 回调函数：在C语言中实现回调函数通常需要定义一个函数指针类型，并将回调函数作为参数传递给其他函数。

在特定事件发生时，其他函数会调用指定的回调函数。

以上是C语言中钩子函数和回调函数的区别，虽然它们都涉及到在特定事件发生时调用函数，但是它们的定义、调用方式、作用范围和编程实现方式都有所不同。

深入理解这两种函数的区别对于提高程序员的编程技能和理解系统底层原理是非常有帮助的。

C语言中钩子函数和回调函数的区别继续扩写：五、应用场景1. 钩子函数：钩子函数通常用于监控、拦截和处理系统事件，比如键盘输入、鼠标点击等。

在图形用户界面（GUI）编程中，钩子函数常用于实现快捷键功能、鼠标事件处理等。

【转】C#.Net鼠标和键盘全局监控勾子（hook）【转】C#.Net 鼠标和键盘全局监控勾子(hook )//C#鼠标和键盘全局监控hookusing System;using System.Runtime.InteropServices;using System.Reflection;using System.Threading;using System.Windows.Forms;using ponentModel;namespace ScreenCapyure2{public class UserActivityHook{#region Windows structure definitions[StructLayout(LayoutKind.Sequential)]private class POINT{public int x;public int y;}[StructLayout(LayoutKind.Sequential)]private class MouseHookStruct{public POINT pt;public int hwnd;public int wHitTestCode;public int dwExtraInfo;}[StructLayout(LayoutKind.Sequential)]private class MouseLLHookStruct{public POINT pt;public int mouseData;public int flags;public int time;public int dwExtraInfo;}[StructLayout(LayoutKind.Sequential)]private class KeyboardHookStruct{public int vkCode;public int scanCode;public int flags;public int time;public int dwExtraInfo;}#endregion#region Windows function imports[DllImport("user32.dll", CharSet = CharSet.Auto,CallingConvention = CallingConvention.StdCall, SetLastError = true)]private static extern int SetWindowsHookEx(int idHook,HookProc lpfn,IntPtr hMod,int dwThreadId);[DllImport("user32.dll", CharSet = CharSet.Auto,CallingConvention = CallingConvention.StdCall, SetLastError = true)]private static extern int UnhookWindowsHookEx(int idHook);[DllImport("user32.dll", CharSet = CharSet.Auto,CallingConvention = CallingConvention.StdCall)]private static extern int CallNextHookEx(int idHook,int nCode,int wParam,IntPtr lParam);private delegate int HookProc(int nCode, int wParam, IntPtr lParam);[DllImport("user32")]private static extern int ToAscii(int uVirtKey,int uScanCode,byte[] lpbKeyState,byte[] lpwTransKey,int fuState);[DllImport("user32")]private static extern int GetKeyboardState(byte[] pbKeyState);[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]private static extern short GetKeyState(int vKey);#endregion#region Windows constantsprivate const int WH_MOUSE_LL = 14;private const int WH_KEYBOARD_LL = 13;private const int WH_MOUSE = 7;private const int WH_KEYBOARD = 2;private const int WM_MOUSEMOVE = 0x200;private const int WM_LBUTTONDOWN = 0x201;private const int WM_RBUTTONDOWN = 0x204;private const int WM_MBUTTONDOWN = 0x207;private const int WM_LBUTTONUP = 0x202;private const int WM_RBUTTONUP = 0x205;private const int WM_MBUTTONUP = 0x208;private const int WM_LBUTTONDBLCLK = 0x203;private const int WM_RBUTTONDBLCLK = 0x206;private const int WM_MBUTTONDBLCLK = 0x209;private const int WM_MOUSEWHEEL = 0x020A;private const int WM_KEYDOWN = 0x100;private const int WM_KEYUP = 0x101;private const int WM_SYSKEYDOWN = 0x104;private const int WM_SYSKEYUP = 0x105;private const byte VK_SHIFT = 0x10;private const byte VK_CAPITAL = 0x14;private const byte VK_NUMLOCK = 0x90;#endregionpublic UserActivityHook(){Start();}public UserActivityHook(bool InstallMouseHook, bool InstallKeyboardHook){Start(InstallMouseHook, InstallKeyboardHook);}~UserActivityHook(){Stop(true, true, false);}public event MouseEventHandler OnMouseActivity;public event KeyEventHandler KeyDown;public event KeyPressEventHandler KeyPress;public event KeyEventHandler KeyUp;private int hMouseHook = 0;private int hKeyboardHook = 0;private static HookProc MouseHookProcedure;private static HookProc KeyboardHookProcedure;public void Start(){this.Start(true, true);}public void Start(bool InstallMouseHook, bool InstallKeyboardHook){if (hMouseHook == 0 && InstallMouseHook){MouseHookProcedure = new HookProc(MouseHookProc);hMouseHook = SetWindowsHookEx(WH_MOUSE_LL,MouseHookProcedure,Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]),0);if (hMouseHook == 0){int errorCode = Marshal.GetLastWin32Error();Stop(true, false, false);try{ throw new Win32Exception(errorCode); }catch{ }}}if (hKeyboardHook == 0 && InstallKeyboardHook){KeyboardHookProcedure = new HookProc(KeyboardHookProc);hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL,KeyboardHookProcedure,Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]),0);if (hKeyboardHook == 0){int errorCode = Marshal.GetLastWin32Error();Stop(false, true, false);try{throw new Win32Exception(errorCode);}catch { }}}}public void Stop(){this.Stop(true, true, true);}public void Stop(bool UninstallMouseHook, bool UninstallKeyboardHook, bool ThrowExceptions){if (hMouseHook != 0 && UninstallMouseHook){int retMouse = UnhookWindowsHookEx(hMouseHook);hMouseHook = 0;if (retMouse == 0 && ThrowExceptions){int errorCode = Marshal.GetLastWin32Error();throw new Win32Exception(errorCode);}}if (hKeyboardHook != 0 && UninstallKeyboardHook){int retKeyboard = UnhookWindowsHookEx(hKeyboardHook);hKeyboardHook = 0;if (retKeyboard == 0 && ThrowExceptions){int errorCode = Marshal.GetLastWin32Error();throw new Win32Exception(errorCode);}}}private int MouseHookProc(int nCode, int wParam, IntPtr lParam){if ((nCode >= 0) && (OnMouseActivity != null)){MouseLLHookStruct mouseHookStruct = (MouseLLHookStruct)Marshal.PtrToStructure(lParam,typeof(MouseLLHookStruct));MouseButtons button = MouseButtons.None;short mouseDelta = 0;switch (wParam){case WM_LBUTTONDOWN:button = MouseButtons.Left;break;case WM_RBUTTONDOWN:button = MouseButtons.Right;break;case WM_MOUSEWHEEL:mouseDelta = (short)((mouseHookStruct.mouseData >> 16) & 0xffff);break;}int clickCount = 0;if (button != MouseButtons.None)if (wParam == WM_LBUTTONDBLCLK || wParam == WM_RBUTTONDBLCLK) clickCount = 2;else clickCount = 1;MouseEventArgs e = new MouseEventArgs(button,clickCount,mouseHookStruct.pt.x,mouseHookStruct.pt.y,mouseDelta);OnMouseActivity(this, e);}return CallNextHookEx(hMouseHook, nCode, wParam, lParam);}private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam){bool handled = false;if ((nCode >= 0) && (KeyDown != null || KeyUp != null || KeyPress != null)){KeyboardHookStruct MyKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam,typeof(KeyboardHookStruct));if (KeyDown != null && (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN)){Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;KeyEventArgs e = new KeyEventArgs(keyData);KeyDown(this, e);handled = handled || e.Handled;}if (KeyPress != null && wParam == WM_KEYDOWN){bool isDownShift = ((GetKeyState(VK_SHIFT) & 0x80) == 0x80 ? true : false);bool isDownCapslock = (GetKeyState(VK_CAPITAL) != 0 ? true : false);byte[] keyState = new byte[256];GetKeyboardState(keyState);byte[] inBuffer = new byte[2];if (ToAscii(MyKeyboardHookStruct.vkCode,MyKeyboardHookStruct.scanCode,keyState,inBuffer,MyKeyboardHookStruct.flags) == 1){char key = (char)inBuffer[0];if ((isDownCapslock ^ isDownShift) && Char.IsLetter(key)) key = Char.T oUpper(key);KeyPressEventArgs e = new KeyPressEventArgs(key);KeyPress(this, e);handled = handled || e.Handled;}}if (KeyUp != null && (wParam == WM_KEYUP || wParam == WM_SYSKEYUP)){Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;KeyEventArgs e = new KeyEventArgs(keyData);KeyUp(this, e);handled = handled || e.Handled;}}if (handled)return 1;elsereturn CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);}}}//////////////////////可以把以上程序单独存为一个文件如：SC.CS;然后在项目里“添加现有项”找到该文件记住引用using ScreenCapyure2;//以下为在窗体中监视事件//本程序调试不起作用，运行时才起作用UserActivityHook choosesc;choosesc = new UserActivityHook();choosesc.OnMouseActivity += new MouseEventHandler(choose_OnMouseActivity);choosesc.KeyDown += new KeyEventHandler(MyKeyDown);choosesc.KeyPress += new KeyPressEventHandler(MyKeyPress);choosesc.KeyUp += new KeyEventHandler(MyKeyUp);//上面部分写到 InitializeComponent()后面public void MyKeyDown(object sender, KeyEventArgs e){}public void MyKeyPress(object sender, KeyPressEventArgs e) {}public void MyKeyUp(object sender, KeyEventArgs e){}private void choose_OnMouseActivity(object sender, MouseEventArgs e){if (e.Clicks > 0){if ((MouseButtons)(e.Button) == MouseButtons.Left){point[0] = e.Location;}if ((MouseButtons)(e.Button) == MouseButtons.Right){point[1] = e.Location;}}//throw new Exception("The method or operation is not implemented.");}。

[转]钩子原理钩子原理Windows系统是建立在事件驱动的机制上的，说穿了就是整个系统都是通过消息的传递来实现的。

而钩子是Windows系统中非常重要的系统接口，用它可以截获并处理送给其他应用程序的消息，来完成普通应用程序难以实现的功能。

钩子可以监视系统或进程中的各种事件消息，截获发往目标窗口的消息并进行处理。

这样，我们就可以在系统中安装自定义的钩子，监视系统中特定事件的发生，完成特定的功能，比如截获键盘、鼠标的输入，屏幕取词，日志监视等等。

可见，利用钩子可以实现许多特殊而有用的功能。

因此，对于高级编程人员来说，掌握钩子的编程方法是很有必要的。

钩子的本质是一段用以处理系统消息的程序，通过系统调用，将其挂入系统。

钩子的种类有很多，每种钩子可以截获并处理相应的消息，每当特定的消息发出，在到达目的窗口之前，钩子程序先行截获该消息、得到对此消息的控制权。

此时在钩子函数中就可以对截获的消息进行加工处理，甚至可以强制结束消息的传递。

在本程序中我们需要捕获在任意窗口上的键盘输入，这就需要采用全局钩子以便拦截整个系统的消息，而全局钩子函数必须以DLL（动态连接库）为载体进行封装，VC6中有三种形式的MFC DLL可供选择，即Regular statically linked to MFC DLL（标准静态链接MFC DLL）、Regular using the shared MFC DLL（标准动态链接MFC DLL）以及Extension MFC DLL（扩展MFC DLL）。

在本程序中为方便起见采用了标准静态连接MFC DLL。

钩子的类型一．按事件分类，有如下的几种常用类型（1）键盘钩子和低级键盘钩子可以监视各种键盘消息。

（2）鼠标钩子和低级鼠标钩子可以监视各种鼠标消息。

（3）外壳钩子可以监视各种Shell事件消息。

比如启动和关闭应用程序。

（4）日志钩子可以记录从系统消息队列中取出的各种事件消息。

（5）窗口过程钩子监视所有从系统消息队列发往目标窗口的消息。

钩子函数大全DelHookProc :该函数已过时,它仅仅是用来与Windows的16位版本兼容.在32位Windows系统中应当使用函数CallNextHookEx. SetWindowsHook :该函数已过时,它仅仅是用来与Windows的16位版本兼容.在32位Windows系统中应当使用函数SetWindowsHookEx. UnhookWindowsHook :该函数已过时,它仅仅是用来与Windows的16位版本兼容.在32位Windows系统中应当使用函数UnhookWindowsHookEx.KBDLLHOOKSTRUCT结构DWORD vkCode; //键盘消息的虚拟键信息,值的范围从1至254DWORD scanCode; //键盘的扫描码信息DWORD flags; //键盘的扩展信息DWORD time; //消息的产生时间,可以用 GetMessageTime 函数取得ULONG_PTR dwExtraInfo; //消息的扩展信息DEBUGHOOKINFO结构DWORD idThread; //filter 线程的IDDWORD idThreadInstaller; //debugging filter 线程的IDLPARAM lParam; //描述跳过此钩子程序要传递给Debug程序的 lParamWPARAM wParam; //描述跳过此钩子程序要传递给Debug程序的 wParamint code; //描述跳过此钩子程序要传遵给Debug程序的 nCodeMOUSEHOOKSTRUCT结构POINT pt; //发送鼠标消息时候的鼠标坐标HWND hwnd; //接收鼠标消息的窗口句柄UINT wHitTestCode; //测试码ULONG_PTR dwExtraInfo; //鼠标消息的扩展信息EVENTMSG结构UINT message;//描述消息UINT paramL;//消息的扩展信息UINT paramH;//消息的扩展信息DWORD time; //寄送消息的时间HWND hwnd;//接受消息的窗口句柄CWPSTRUCT 结构LPARAM lParam; //消息的扩展信息WPARAM wParam; //消息的扩展信息UINT message; //消息HWND hwnd; //接受消息的窗口MSLLHOOKSTRUCT结构POINT pt; //发送鼠标消息时候的鼠标坐标DWORD mouseData; //如果这个消息是 WM_MOUSEWHEEL 则高位为滚轮的滚动数目,低位保留.如果这个消息是 WM_XBUTTONDOWN, WM_XBUTTONUP, WM_XBUTTONDBLCLK,WM_NCXBUTTONDOWN, WM_NCXBUTTONUP, 或 WM_NCXBUTTONDBLCLK.则高位描述的是X按钮是按下还是释放,低位保留DWORD flags; //描述消息的注入事件DWORD time; //描述寄送消息的时候ULONG_PTR dwExtraInfo;//描述消息的扩展信息CREATESTRUCT结构LPVOID lpCreateParams 将被用于创建窗口的数据的指针。

1、局部变量能否和全局变量重名？答：能，局部会屏蔽全局。

要用全局变量，需要使用”::” ;局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。

对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内。

2、如何引用一个已经定义过的全局变量？答：extern 可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个编写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错。

3、全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？答：可以，在不同的C文件中以static形式来声明同名全局变量。

可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错.4、请写出下列代码的输出内容#includeint main(void){int a,b,c,d;a=10;b=a++;c=++a;d=10*a++;printf(“b，c，d：%d，%d，%d”，b，c，d）;return 0;}答：10，12，1205、static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？答: 1) 全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。

全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。

这两者在存储方式上并无不同。

这两者的区别在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。

而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。

HOOKBy Y-Z-FQQ:9766911411-WH_KEYBOARDKeyboardProc 钩子程序是一个线程钩子或系统钩子被SetWindowsHookEx函数调用.一个一个用程序无论何时调用GetMessage或PeekMessage函数之前，并且是键盘消息（WM_KEYUP 或WM_KEYDOWN )。

格式：LRESULT CALLBACK KeyboardProc(int code,WPARAM wParam,LPARAM lParam);参数：code指定一个标示让钩子程序用于确定如何处理消息，如果标示小于0，钩子过程必须通过CallNextHookEx函数，并且必须返回CallNextHookEx 函数返回的参数。

此参数可以被设置为下参数之一：HC_ACTIONwParam 和lParam 参数包含击键消息的信息。

HC_NOREMOVEwParam 和lParam 参数包含击键消息的信息，并且击键消息没有从消息队列中移除。

（一个应用程序调用PeekMessage函数，指定PM_NOREMOVE 标志)wPram指定产生击键消息的那个按键的虚拟键标示lParam指定重复次数，扫描码，扩充标记，环境代码，早先的关键标记，和过渡状态标记。

需要查看更多关于lParam参数的消息请查看Keystroke Message Flags,这个参数可以被设置为一个或多个以下值.0~15指定重复次数。

它的值是用户按住键的击键次数的重复结果。

16~23指定扫描码，这个值依赖于OEM.24指定这个键是否为一个扩充键,比如一个函数键或一个键在数字小键盘.这个值为1当这个键是一个扩充键，否则为0.25~28保留29指定环境代码.如果ALT键按下这个值为1;否则为0.30指定早先的关键标记.如果键被按下在消息发送前，则值为1。

如果键弹起则为0.31指定过渡状态标记.如果键被安下，则值为0,如果释放则为1.2-WH_CALLWNDPROC系统调用这个函数在消息到达线程之前.样式LRESULT CALLBACK CallWndProc(int nCode,WPARAM wParam,LPARAM lParam);参数：nCode指定是否钩子函数必须处理消息.如果nCode 为HC_ACTION，钩子程序必须处理消息.如果nCode小于0,钩子程序必须使用CallNextHookEx函数，并且必须返回CallNextHookEx的返回值.wParam指定消息是否为当前线程发送.如果消息为当前线程发送,并且为非0；否则为0.lParam指向一个CWPSTRUCT 结构体包含消息的细节.返回值如果nCode 小于0，钩子程序必须返回CallNextHookEx的返回.如果nCode 大于等于0,建议使用CallNextHookEx,并且返回其返回的值;另外,其他程序使用了WH_CALLWNDPROC 钩子将不会收到钩子通知和行为可能造成错误的结果。

c#使⽤hook来监控⿏标键盘事件的⽰例代码如果这个程序在10⼏年前,QQ刚刚兴起的时候,有了这个代码,就可实现盗号了.当然使⽤钩⼦我们更多的是实现"全局快捷键"的需求.⽐如程序最⼩化隐藏后要"某快捷键"来启动它.钩⼦(hook),通俗的讲,她可以捕获到你的键盘和⿏标的相关操作消息.关于hook的相关代码⽹上⼀搜⼀箩筐,这是整理起来⽐较完善和使⽤最⽅便的.//Declare wrapper managed POINT class.[StructLayout(LayoutKind.Sequential)]public class POINT{public int x;public int y;}//Declare wrapper managed MouseHookStruct class.[StructLayout(LayoutKind.Sequential)]public class MouseHookStruct{public POINT pt;public int hwnd;public int wHitTestCode;public int dwExtraInfo;}//Declare wrapper managed KeyboardHookStruct class.[StructLayout(LayoutKind.Sequential)]public class KeyboardHookStruct{public int vkCode; //Specifies a virtual-key code. The code must be a value in the range 1 to 254.public int scanCode; // Specifies a hardware scan code for the key.public int flags; // Specifies the extended-key flag, event-injected flag, context code, and transition-state flag.public int time; // Specifies the time stamp for this message.public int dwExtraInfo; // Specifies extra information associated with the message.}public class GlobalHook{public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam);public delegate int GlobalHookProc(int nCode, Int32 wParam, IntPtr lParam);public GlobalHook(){//Start();}~GlobalHook(){Stop();}public event MouseEventHandler OnMouseActivity;public event KeyEventHandler KeyDown;public event KeyPressEventHandler KeyPress;public event KeyEventHandler KeyUp;/// <summary>/// 定义⿏标钩⼦句柄./// </summary>static int _hMouseHook = 0;/// <summary>/// 定义键盘钩⼦句柄/// </summary>static int _hKeyboardHook = 0;public int HMouseHook{get { return _hMouseHook; }}public int HKeyboardHook{get { return _hKeyboardHook; }}/// <summary>/// ⿏标钩⼦常量(from Microsoft SDK Winuser.h )/// </summary>public const int WH_MOUSE_LL = 14;/// <summary>/// 键盘钩⼦常量(from Microsoft SDK Winuser.h )/// </summary>public const int WH_KEYBOARD_LL = 13;/// <summary>/// 定义⿏标处理过程的委托对象/// </summary>GlobalHookProc MouseHookProcedure;/// <summary>/// 键盘处理过程的委托对象/// </summary>GlobalHookProc KeyboardHookProcedure;//导⼊window 钩⼦扩展⽅法导⼊/// <summary>/// 安装钩⼦⽅法/// </summary>[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]public static extern int SetWindowsHookEx(int idHook, GlobalHookProc lpfn,IntPtr hInstance, int threadId);/// <summary>/// 卸载钩⼦⽅法/// </summary>[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]public static extern bool UnhookWindowsHookEx(int idHook);//Import for CallNextHookEx./// <summary>/// 使⽤这个函数钩信息传递给链中的下⼀个钩⼦过程。

C语言面试题大汇总之华为面试题1、局部变量能否和全局变量重名？答：能，局部会屏蔽全局。

要用全局变量，需要使用"::";局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。

对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内。

2、如何引用一个已经定义过的全局变量？答：extern可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个编写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错。

3、全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？答：可以，在不同的C文件中以static形式来声明同名全局变量。

可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错.4、请写出下列代码的输出内容#include <stdio.h>int main(void){int a,b,c,d;a=10;b=a++;c=++a;d=10*a++;printf("b，c，d：%d，%d，%d"，b，c，d）;return 0;}答：10，12，1205、static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？答: 1) 全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。

全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。

这两者在存储方式上并无不同。

这两者的区别在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。

c语言初始化 malloc 钩子函数一、引言在C语言中，内存管理是程序的重要组成部分。

Malloc函数是用于动态内存分配的主要工具，它在堆上分配指定字节数的内存空间。

然而，有时我们需要扩展或定制Malloc的行为，这时就可以使用Malloc的钩子函数。

钩子函数是一种允许我们在某个函数执行前后插入自定义代码的机制。

二、Malloc钩子函数简介Malloc钩子函数是在Malloc、Free等内存管理函数执行前后被调用的自定义函数。

通过设置这些钩子函数，我们可以插入自定义的内存管理逻辑，例如在Malloc前后记录日志、性能监控等。

三、初始化Malloc钩子函数的步骤1.定义钩子函数：首先，你需要定义自己的钩子函数。

这些函数通常具有特定的名称，以便malloc库可以识别它们。

例如，你可以定义一个malloc_hook函数。

2.设置hook指针：使用malloc_hooks结构来设置或修改钩子函数。

这个结构包含了多个指向不同钩子函数的指针，包括初始化、分配和回收钩子。

3.注册自定义钩子：通过修改malloc_hooks结构中的相应字段，将你的自定义钩子函数注册到相应的位置。

例如，你可以设置malloc_hook字段为你的malloc_hook函数。

4.调用原始Malloc函数：在你的钩子函数中，确保在执行自定义逻辑之后，仍然调用原始的Malloc函数。

这样可以确保内存的正确分配。

5.初始化环境：在程序启动时，确保初始化你的钩子函数环境。

这通常涉及到设置malloc_hooks结构和其他相关环境变量。

6.使用Malloc：现在，每当你使用Malloc函数时，你的钩子函数就会被调用。

你可以在钩子函数中添加任何你需要的逻辑，例如记录日志、性能监控等。

7.清理资源：在程序结束时，确保清理所有与钩子函数相关的资源。

这可能涉及到恢复malloc_hooks结构和其他相关环境变量的默认值。

四、示例代码五、注意事项使用Malloc钩子函数时，请注意以下几点：1.确保你的钩子函数是线程安全的，特别是如果你在多线程环境中使用它。

Hook_键盘鼠标连按连点by Meteor当初是为了我玩的游戏做的一个自动采集功能，功能是实现鼠标和键盘自动操作根据动作，设置的时间隔保存后自动运行直接上图Form1主窗体Loading只是一个等待提示效果UserActivityHook 类代码using System;using System.Runtime.InteropServices;using System.Reflection;using System.Windows.Forms;namespace Patcher_采集{public class UserActivityHook : object {public UserActivityHook(){try{Start();}catch { }}~UserActivityHook() {Stop();}public event MouseEventHandler OnMouseActivity;public event KeyEventHandler KeyDown;public event KeyPressEventHandler KeyPress;public event KeyEventHandler KeyUp;public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam);static int hMouseHook = 0;static int hKeyboardHook = 0;public const int WH_MOUSE_LL = 14;public const int WH_KEYBOARD_LL = 13;HookProc MouseHookProcedure;HookProc KeyboardHookProcedure;[StructLayout(LayoutKind.Sequential)]public class POINT{public int x;public int y;}[StructLayout(LayoutKind.Sequential)]public class MouseHookStruct{public POINT pt;public int hwnd;public int wHitTestCode;public int dwExtraInfo;}[StructLayout(LayoutKind.Sequential)]public class KeyboardHookStruct{public int vkCode;public int scanCode;public int flags;public int time;public int dwExtraInfo;}[DllImport("user32.dll",CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);[DllImport("user32.dll",CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]public static extern bool UnhookWindowsHookEx(int idHook);[DllImport("user32.dll",CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]public static extern int CallNextHookEx(int idHook, int nCode, Int32 wParam, IntPtr lParam);public void Start(){if(hMouseHook == 0){MouseHookProcedure = new HookProc(MouseHookProc);hMouseHook = SetWindowsHookEx( WH_MOUSE_LL,MouseHookProcedure,Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]),0);if(hMouseHook == 0 ) {Stop();throw new Exception("SetWindowsHookEx failed.");}}if(hKeyboardHook == 0){KeyboardHookProcedure = new HookProc(KeyboardHookProc);hKeyboardHook = SetWindowsHookEx( WH_KEYBOARD_LL,KeyboardHookProcedure,Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]),0);if(hKeyboardHook == 0 ) {Stop();throw new Exception("SetWindowsHookEx ist failed.");}}}public void Stop(){bool retMouse =true;bool retKeyboard = true;if(hMouseHook != 0){retMouse = UnhookWindowsHookEx(hMouseHook);hMouseHook = 0;}if(hKeyboardHook != 0){retKeyboard = UnhookWindowsHookEx(hKeyboardHook);hKeyboardHook = 0;}if (!(retMouse && retKeyboard)) throw new Exception("UnhookWindowsHookEx failed."); }private const int WM_MOUSEMOVE = 0x200;private const int WM_LBUTTONDOWN = 0x201;private const int WM_RBUTTONDOWN = 0x204;private const int WM_MBUTTONDOWN = 0x207;private const int WM_LBUTTONUP = 0x202;private const int WM_RBUTTONUP = 0x205;private const int WM_MBUTTONUP = 0x208;private const int WM_LBUTTONDBLCLK = 0x203;private const int WM_RBUTTONDBLCLK = 0x206;private const int WM_MBUTTONDBLCLK = 0x209;private int MouseHookProc(int nCode, Int32 wParam, IntPtr lParam){if ((nCode >= 0) && (OnMouseActivity!=null)) {MouseButtons button=MouseButtons.None;switch (wParam){case WM_LBUTTONDOWN:button=MouseButtons.Left;break;case WM_RBUTTONDOWN:button=MouseButtons.Right;break;}int clickCount=0;if (button!=MouseButtons.None)if (wParam==WM_LBUTTONDBLCLK ||wParam==WM_RBUTTONDBLCLK) clickCount=2;else clickCount=1;MouseHookStruct MyMouseHookStruct = (MouseHookStruct) Marshal.PtrToStructure(lParam, typeof(MouseHookStruct));MouseEventArgs e=new MouseEventArgs(button,clickCount,MyMouseHookStruct.pt.x,MyMouseHookStruct.pt.y,0 );OnMouseActivity(this, e);}return CallNextHookEx(hMouseHook, nCode, wParam, lParam);}[DllImport("user32")]public static extern int ToAscii(int uVirtKey,int uScanCode,byte[] lpbKeyState,byte[] lpwTransKey,int fuState);[DllImport("user32")]public static extern int GetKeyboardState(byte[] pbKeyState);private const int WM_KEYDOWN = 0x100;private const int WM_KEYUP = 0x101;private const int WM_SYSKEYDOWN = 0x104;private const int WM_SYSKEYUP = 0x105;private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam){if ((nCode >= 0) && (KeyDown!=null || KeyUp!=null || KeyPress!=null)){KeyboardHookStruct MyKeyboardHookStruct = (KeyboardHookStruct) Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));if ( KeyDown!=null && ( wParam ==WM_KEYDOWN ||wParam==WM_SYSKEYDOWN )){Keys keyData=(Keys)MyKeyboardHookStruct.vkCode;KeyEventArgs e = new KeyEventArgs(keyData);KeyDown(this, e);}if ( KeyPress!=null && wParam ==WM_KEYDOWN ){byte[] keyState = new byte[256];GetKeyboardState(keyState);byte[] inBuffer= new byte[2];if (ToAscii(MyKeyboardHookStruct.vkCode,MyKeyboardHookStruct.scanCode,keyState,inBuffer,MyKeyboardHookStruct.flags)==1){KeyPressEventArgs e = new KeyPressEventArgs((char)inBuffer[0]);KeyPress(this, e);}}if ( KeyUp!=null && ( wParam ==WM_KEYUP || wParam==WM_SYSKEYUP )){Keys keyData=(Keys)MyKeyboardHookStruct.vkCode;KeyEventArgs e = new KeyEventArgs(keyData);KeyUp(this, e);}}return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);}}}Form1代码using System;using System.Drawing;using System.Windows.Forms;using System.Drawing.Drawing2D;namespace Patcher_采集{public partial class Form1 : Form{[System.Runtime.InteropServices.DllImport("user32")]private static extern int mouse_event(int dwFlags, int dx, int dy, int cButtons, int dwExtraInfo);const int MOUSEEVENTF_LEFTDOWN = 0x0002;const int MOUSEEVENTF_LEFTUP = 0x0004;///<summary>///安装钩子///</summary>///<param name="idHook"></param>///<param name="hProc"></param>///<param name="hMod"></param>///<param name="dwThreadId"></param>///<returns></returns>[DllImport("user32.dll")]public static extern int SetWindowsHookEx(int idHook, HookProc hProc, IntPtr hMod, int dwThreadId);///<summary>///将hook信息传递到链表中下一个hook处理过程///</summary>///<param name="hHook"></param>///<param name="nCode"></param>///<param name="wParam"></param>///<param name="lParam"></param>///<returns></returns>[DllImport("user32.dll")]public static extern int CallNextHookEx(int hHook, int nCode, IntPtr wParam, IntPtr lParam);///<summary>///</summary>///<param name="hHook"></param>///<returns></returns>[DllImport("user32.dll")]public static extern bool UnhookWindowsHookEx(int hHook);///<summary>///获取模块句柄///</summary>///<param name="lpModuleName"></param>///<returns></returns>[DllImport("kernel32.dll")]public static extern IntPtr GetModuleHandle(string lpModuleName); public struct KeyInfoStruct{public int vkCode; //按键键码public int scanCode;public int flags; //键盘是否按下的标志public int time;public int dwExtraInfo;}[DllImport("User32.dll")]public static extern void keybd_event(Byte bVk, Byte bScan, Int32 dwFlags, Int32 dwExtraInfo);private const int WH_KEYBOARD_LL = 13; //钩子类型全局钩子private const int WM_KEYUP = 0x101; //按键抬起private const int WM_KEYDOWN = 0x100; //按键按下private const int KEYEVENTF_KEYUP = 2;byte VK_Q = 0;///<summary>///坐标///</summary>private Point[] points;///<summary>///坐标个数索引///</summary>int pointIndex = 1;int nowPointIndex = 0;///<summary>///按键索引///</summary>int KeyIndex = 0;///<summary>///坐标Label lb;///<summary>///输入框///</summary>TextBox txt;///<summary>/// LinkLabel///</summary>//LinkLabel link;///<summary>///执行的动作顺序,保存的控件名称///</summary>string dongzuo = "txtP1";int dongzuoIndex = 0;public delegate int HookProc(int nCode, IntPtr wParam, IntPtr lParam);bool bStopMsg = false;int hHook = 0;GCHandle gc;string b = "F2";int index = 0;private UserActivityHook hook;Icon icon1 = new Icon(Application.StartupPath+@"\..\emoticon-1.ico");Icon icon2 = new Icon(Application.StartupPath+@"\..\emoticon-2.ico");public int MethodHookProc(int nCode, IntPtr wParam, IntPtr lParam){if (nCode >= 0){KeyInfoStruct inputInfo = (KeyInfoStruct)Marshal.PtrToStructure(lParam, typeof(KeyInfoStruct));if (wParam == (IntPtr)WM_KEYDOWN){//如果按键按下if (((Keys)inputInfo.vkCode).ToString() == b){if (timer1.Enabled == true){notifyIcon1.Icon = icon1;timer1.Enabled = false;}else{notifyIcon1.Icon = icon2;timer1.Enabled = true;}}}if (bStopMsg)return 1;}return CallNextHookEx(hHook, nCode, wParam, lParam);//继续传递消息}public Form1(){InitializeComponent();boBox1.SelectedIndex = 1;//默认索引值boBox1.DropDownStyle = ComboBoxStyle.DropDownList;//仅在列表中选择}private void Form1_Load(object sender, EventArgs e){if (0 == hHook){HookProc KeyCallBack = new HookProc(MethodHookProc);hHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyCallBack,GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName), 0);if (hHook == 0){MessageBox.Show("设置Hook失败");}else{gc = GCHandle.Alloc(KeyCallBack); //保持活动避免回调过程被垃圾回收}}else{if (UnhookWindowsHookEx(hHook)){hHook = 0;gc.Free();}else{MessageBox.Show("卸载失败");}}cmbDW.Text = "秒";}private void btnGetPoint_Click(object sender, EventArgs e){lbNowPoint.ForeColor = Color.Red;points = new Point[pointIndex];hook = new UserActivityHook();hook.OnMouseActivity += new MouseEventHandler(hook_OnMouseActivity);hook.KeyDown += new KeyEventHandler(hook_KeyDown);}private void timer1_Tick(object sender, EventArgs e){if (string.IsNullOrEmpty(dongzuo)){MessageBox.Show("动作不能为空，请重新设置", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);timer1.Enabled = false;return;}if (dongzuoIndex > (pointIndex + KeyIndex - 1)){dongzuoIndex = 0;}try{if (dongzuo.Split(',')[dongzuoIndex].Contains("txtP")){OnClick();}else{OnKey();}}catch { }dongzuoIndex++;}private void button1_Click(object sender, EventArgs e){try{for (int i = 0; i < pointIndex; i++){txt = (TextBox)groupBox1.Controls.Find("txtP" + (i + 1), false)[0];if (string.IsNullOrEmpty(txt.Text)){MessageBox.Show("坐标不能为空");return;}try{points[i].X = Int32.Parse(txt.Text.Split(',')[0]);points[i].Y = Int32.Parse(txt.Text.Split(',')[1]);}catch{MessageBox.Show("坐标有误，请勿随意修改坐标");return;}}b = comboBox1.Text;MessageBox.Show("保存成功");this.Hide();this.ShowInTaskbar = false;}catch(Exception ex){MessageBox.Show("保存出错\r\n"+ex.Message);}}[DllImport("User32")]public extern static void mouse_event(int dwFlags, int dx, int dy, int dwData, IntPtr dwExtraInfo); [DllImport("user32.dll")]static extern bool SetCursorPos(int X, int Y);public enum MouseEventFlags{Move = 0x0001,LeftDown = 0x0002,LeftUp = 0x0004,RightDown = 0x0008,RightUp = 0x0010,MiddleDown = 0x0020,MiddleUp = 0x0040,Wheel = 0x0800,Absolute = 0x8000}private void OnClick(){txt = (TextBox)groupBox1.Controls.Find(dongzuo.Split(',')[dongzuoIndex], false)[0];index=Int32.Parse(.Split('P')[1])-1;if (points[index].X == 0 && points[index].Y == 0)return;SetCursorPos(points[index].X, points[index].Y);//用屏幕取点工具可以得到坐标mouse_event((int)(MouseEventFlags.LeftDown | MouseEventFlags.Absolute), 607, 385, 0, IntPtr.Zero);mouse_event((int)(MouseEventFlags.LeftUp | MouseEventFlags.Absolute), 607, 385, 0, IntPtr.Zero);}private void OnKey(){try{txt = (TextBox)groupBox1.Controls.Find(dongzuo.Split(',')[dongzuoIndex], false)[0];VK_Q = System.Text.Encoding.ASCII.GetBytes(txt.Text)[0];keybd_event(VK_Q, 0, 0, 0);//按下键盘keybd_event(VK_Q, 0, KEYEVENTF_KEYUP, 0); //松开}catch { }}private void hook_OnMouseActivity(object sender, MouseEventArgs e){lbNowPoint.Text = e.X.ToString() + "," + e.Y.ToString();}///<summary>///统计各个按键按下的次数每一个keydown事件作为按键一次的判断///</summary>///<param name="sender"></param>///<param name="e"></param>private void hook_KeyDown(object sender, KeyEventArgs e){if (e.KeyData == Keys.Enter){txt = (TextBox)groupBox1.Controls.Find("txtP" + (nowPointIndex + 1), false)[0];txt.Text = lbNowPoint.Text;if (nowPointIndex >= pointIndex - 1){lbNowPoint.ForeColor = Color.Black;hook.Stop();Loading frmloading = new Loading("坐标保存中...");frmloading.ShowDialog();nowPointIndex = 0;}else{nowPointIndex++;}}}private void numericUpDown1_ValueChanged(object sender, EventArgs e) {if (cmbDW.Text == "毫秒"){timer1.Interval = (int)numericUpDown1.Value;}else if (cmbDW.Text == "秒"){timer1.Interval = (int)numericUpDown1.Value * 1000;}else if (cmbDW.Text == "分"){timer1.Interval = (int)numericUpDown1.Value * 1000*60;}else if (cmbDW.Text == "时"){timer1.Interval = (int)numericUpDown1.Value * 1000*3600;}}private void btnAddPoint_Click(object sender, EventArgs e){lb = new Label();lb.Text = "动作" + (pointIndex + 1 + KeyIndex) + ":"; = "lbzb" + (pointIndex + 1);lb.AutoSize = true;lb.Location = new Point(7, 15 + (pointIndex + KeyIndex) * 22);groupBox1.Controls.Add(lb);lb = new Label();lb.Text = "坐标"; = "lbflag" + (pointIndex + 1 + KeyIndex);lb.ForeColor = Color.Silver;lb.AutoSize = true;lb.Location = new Point(143, 15 + (pointIndex + KeyIndex) * 22);txt = new TextBox(); = "txtP" + (pointIndex + 1);txt.Size = new System.Drawing.Size(81, 21);txt.Location = new Point(58, 12 + (pointIndex + KeyIndex) * 22);groupBox1.Controls.Add(lb);groupBox1.Controls.Add(txt);pointIndex++;if (string.IsNullOrEmpty(dongzuo)){dongzuo = ;}else{dongzuo += "," + ;}}private void btnAddKey_Click(object sender, EventArgs e){lb = new Label();lb.Text = "动作" + (KeyIndex + 1 + pointIndex) + ":"; = "lbaj" + (KeyIndex + 1);lb.AutoSize = true;lb.Location = new Point(7, 15 + (pointIndex + KeyIndex) * 22);groupBox1.Controls.Add(lb);lb = new Label();lb.Text = "按键"; = "lbflag" + (pointIndex + 1 + KeyIndex);lb.ForeColor = Color.SkyBlue;lb.AutoSize = true;lb.Location = new Point(143, 15 + (pointIndex + KeyIndex) * 22);txt = new TextBox(); = "txtK" + (KeyIndex + 1);txt.Size = new System.Drawing.Size(81, 21);txt.MaxLength = 1;txt.Location = new Point(58, 12 + (pointIndex + KeyIndex) * 22);groupBox1.Controls.Add(lb);groupBox1.Controls.Add(txt);KeyIndex++;if (string.IsNullOrEmpty(dongzuo)){dongzuo = ;}else{dongzuo += "," + ;}}private void notifyIcon1_MouseClick(object sender, MouseEventArgs e) {if (this.ShowInTaskbar){this.Hide();this.ShowInTaskbar = false;}else{this.Show();this.ShowInTaskbar = true;}}private void cmbDW_SelectedIndexChanged(object sender, EventArgs e) {if (cmbDW.Text == "毫秒"){timer1.Interval = (int)numericUpDown1.Value;}else if (cmbDW.Text == "秒"){timer1.Interval = (int)numericUpDown1.Value * 1000;}else if (cmbDW.Text == "分"){timer1.Interval = (int)numericUpDown1.Value * 1000 * 60;}else if (cmbDW.Text == "时"){timer1.Interval = (int)numericUpDown1.Value * 1000 * 3600;}}private void btnClear_Click(object sender, EventArgs e){timer1.Enabled = false;notifyIcon1.Icon = icon1;groupBox1.Controls.Clear();pointIndex = 0;KeyIndex = 0;points=new Point[0];dongzuo = "";dongzuoIndex = 0;nowPointIndex = 0;}}}Loading和本文关系不大，只是一个弹出提示窗体，代码就略了下面是Form1自动生成窗体的代码，辅助查看事件绑定属性等Form1.Designer.csnamespace Patcher_采集{partial class Form1{///<summary>///必需的设计器变量。

浅谈c++hook钩⼦的使⽤介绍⼀、基本概念：钩⼦(Hook)，是Windows消息处理机制的⼀个平台,应⽤程序可以在上⾯设置⼦程以监视指定窗⼝的某种消息，⽽且所监视的窗⼝可以是其他进程所创建的。

当消息到达后，在⽬标窗⼝处理函数之前处理它。

钩⼦机制允许应⽤程序截获处理window消息或特定事件。

钩⼦实际上是⼀个处理消息的程序段，通过系统调⽤，把它挂⼊系统。

每当特定的消息发出，在没有到达⽬的窗⼝前，钩⼦程序就先捕获该消息，亦即钩⼦函数先得到控制权。

这时钩⼦函数即可以加⼯处理（改变）该消息，也可以不作处理⽽继续传递该消息，还可以强制结束消息的传递。

⼆、运⾏机制：1、钩⼦链表和钩⼦⼦程：每⼀个Hook都有⼀个与之相关联的指针列表，称之为钩⼦链表，由系统来维护。

这个列表的指针指向指定的，应⽤程序定义的，被Hook⼦程调⽤的回调函数，也就是该钩⼦的各个处理⼦程。

当与指定的Hook类型关联的消息发⽣时，系统就把这个消息传递到Hook⼦程。

⼀些Hook⼦程可以只监视消息，或者修改消息，或者停⽌消息的前进，避免这些消息传递到下⼀个Hook⼦程或者⽬的窗⼝。

最近安装的钩⼦放在链的开始，⽽最早安装的钩⼦放在最后，也就是后加⼊的先获得控制权。

Windows 并不要求钩⼦⼦程的卸载顺序⼀定得和安装顺序相反。

每当有⼀个钩⼦被卸载，Windows 便释放其占⽤的内存，并更新整个Hook链表。

如果程序安装了钩⼦，但是在尚未卸载钩⼦之前就结束了，那么系统会⾃动为它做卸载钩⼦的操作。

钩⼦⼦程是⼀个应⽤程序定义的回调函数(CALLBACK Function),不能定义成某个类的成员函数，只能定义为普通的C函数。

⽤以监视系统或某⼀特定类型的事件，这些事件可以是与某⼀特定线程关联的，也可以是系统中所有线程的事件。

钩⼦⼦程必须按照以下的语法：LRESULT CALLBACK HookProcint nCode,WPARAM wParam,LPARAM lParam);HookProc是应⽤程序定义的名字。

c 钩子函数
在C语言中，钩子函数（hook function）通常是指可以被其他程序或系统调用的回调函数。

它通常会注册到某个框架或库中，当特定事件发生时会被调用。

例如，在Windows操作系统中，可以使用钩子函数来拦截特定的消息、键盘输入、鼠标事件等，实现一些特殊的功能，比如监控用户行为、加强系统安全等。

在这种情况下，钩子函数需要注册到操作系统的钩子链中，等待事件发生时被调用。

在编写C语言程序时，可以自己实现钩子函数，将其注册到自己的程序某个模块中，等待触发特定事件时被调用。

例如，在一个计算器程序中，可以注册一个钩子函数在用户按下某个快捷键时自动执行某些计算操作。

总之，钩子函数是一种非常灵活的编程技术，可以让程序更加智能化、自适应化。

用C++写很简单，用C#写，则实际是调用windows API 类似钩子程序。

下载源程序和运行程序
/2008_11/1225788644_ddvip_7698.rar
运行界面如下：
二说明：
在C++中实现该功能十分简单，也有很多经典例子可以实现，在C#中确有很多问题会出现。

对于钩子知识不太熟悉可以参考我转载的另一篇文章：/hocyl an/articles/1033895.html[微软HOOK技术专题]
三大概步骤
其实主要就是调用windows API
第一步：安装钩子：SetWindowsHookEx(WH_Codes idHook, HookProc lpfn,IntPtr pInstance, int threadId);
第二步：回调和处理CallNextHookEx(IntPtr pHookHandle, int nCode,Int32 wParam, IntPtr lParam);
第三步：完成普通的业务处理其它流程
将封装的钩子应用到系统中…….
第四步：拆卸钩子UnhookWindowsHookEx(IntPtr pHookHandle);
四重要代码和解释：
*封装的hook类：。