C++ x86 x64 类内类外子类化

百鬼夜行天

C++ x86 x64 类内类外子类化

下面这里是调用例子，例子演示了类内和类外的调用。

1. class test
   
2. {
   
3. public:
   
4.         LRESULT WINAPI testProc(LPSUBCLASSSTRUCT pData, UINT message, WPARAM wParam, LPARAM lParam)
   
5.         {
   
6.                 // 跟正常的子类化差不多, 只不过第一个参数不是窗口句柄, 而是一个结构指针
   
7.                 return CallWindowProcW(pData->oldProc, pData->hWnd, message, wParam, lParam);
   
8.         }
   
9.         LRESULT WINAPI RegisterClassWndProc(LPSUBCLASSSTRUCT pData, UINT message, WPARAM wParam, LPARAM lParam)
   
10.         {
    
11.                 // 跟正常的子类化差不多, 只不过第一个参数不是窗口句柄, 而是一个结构指针
    
12.                 return DefWindowProcW(pData->hWnd, message, wParam, lParam);
    
13.         }
    
14. };
    
15. 
    
16. LRESULT CALLBACK testProc(LPSUBCLASSSTRUCT pData, UINT message, WPARAM wParam, LPARAM lParam)
    
17. {
    
18.         // 跟正常的子类化差不多, 只不过第一个参数不是窗口句柄, 而是一个结构指针
    
19.         return CallWindowProcW(pData->oldProc, pData->hWnd, message, wParam, lParam);
    
20. }
    
21. 
    
22. LRESULT CALLBACK RegisterClassWndProc(LPSUBCLASSSTRUCT pData, UINT message, WPARAM wParam, LPARAM lParam)
    
23. {
    
24.         // 跟正常的子类化差不多, 只不过第一个参数不是窗口句柄, 而是一个结构指针
    
25.         return DefWindowProcW(pData->hWnd, message, wParam, lParam);
    
26. }
    
27. 
    
28. void test1(HWND hWnd)
    
29. {
    
30. 
    
31.         test a;
    
32.         SubClassWindow(hWnd, &a, &test::testProc, 0);
    
33.         SubClassWindow(hWnd, testProc, 0);
    
34. 
    
35.         WNDCLASSEX wcex;
    
36.         wcex.lpfnWndProc = (WNDPROC)MakeProc(RegisterClassWndProc, 0);                                // 可以这样赋值
    
37.         wcex.lpfnWndProc = (WNDPROC)MakeProc(&a, &test::RegisterClassWndProc, 0);        // 也可以这样赋值
    
38. 
    
39. }

复制代码

源码：

1. 
   
2. #pragma once
   
3. 
   
4. // 命名空间内的不建议外部使用
   
5. // 使用前需要 #include<windows.h>
   
6. namespace __subclass
   
7. {
   
8.     typedef struct tagMAKEPROCDATA
   
9.     {
   
10.         BYTE data[80];      // 为了通用, 指令都写到这个数组里, 也不需要1字节对齐
    
11.     }MAKEPROCDATA, * LPMAKEPROCDATA;
    
12. }
    
13. typedef struct tagSUBCLASSSTRUCT : private __subclass::tagMAKEPROCDATA  
    
14. {
    
15.     // 私有继承
    
16.     HWND hWnd;              // 子类化的窗口句柄
    
17.     WNDPROC oldProc;        // 旧窗口过程
    
18.     void* param;            // 用户数据
    
19. }SUBCLASSSTRUCT, * LPSUBCLASSSTRUCT;
    
20. 
    
21. namespace __subclass
    
22. {
    
23.     // 由于VirtualAlloc() 申请的字节数是一页, 一般一页是4096个字节
    
24.     // 每次申请那么多, 只用几十个字节, 剩下的4000个字节都浪费了
    
25.     // 所以做个简单的内存池
    
26.     class simpleMempool
    
27.     {
    
28.     private:
    
29.         struct _list
    
30.         {
    
31.             struct _list* next;
    
32.         };
    
33.         _list* ptr;
    
34.         void* root;
    
35.         bool init()
    
36.         {
    
37.             if (ptr)return false;
    
38.             // 8k 个字节足够了, 最多支持 8192/sizeof(SUBCLASSSTRUCT) 次子类化操作, 在不释放的前提下
    
39.             size_t size = 0x2000;   // 4k对齐
    
40. #ifdef _M_X64
    
41.             // x64需要自己指定申请的地址, 如果让系统自动分配, 有可能函数地址减去申请的地址会大于4个字节
    
42.             INT_PTR base = 0x100000000;
    
43.             for (INT_PTR i = 0; i < 50; i++)
    
44.             {
    
45.                 ptr = (_list*)VirtualAlloc((LPVOID)base, size,
    
46.                     MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    
47.                 if (ptr)break;
    
48.                 base += 0x100000000;
    
49.             }
    
50. #else
    
51.             // x86没那么多讲究, 让系统自己分配地址
    
52.             ptr = (_list*)VirtualAlloc(0, size,
    
53.                 MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    
54. #endif
    
55.             if (!ptr)return false;
    
56. 
    
57.             root = ptr; // 首地址, 首节点
    
58.             LPBYTE p = (LPBYTE)ptr;
    
59.             size_t len = size / sizeof(SUBCLASSSTRUCT) - 1;
    
60.             for (size_t i = 0; i < len; i++)
    
61.             {
    
62.                 // 用一个单向链表记录可用内存地址
    
63.                 // 每个地址记录的大小为 SUBCLASSSTRUCT 结构大小
    
64.                 p += sizeof(SUBCLASSSTRUCT);
    
65.                 ptr->next = (_list*)p;
    
66.                 ptr = (_list*)p;    // 指向下一个节点
    
67.             }
    
68.             ptr->next = 0;
    
69.             ptr = (_list*)root;
    
70.             return true;
    
71.         }
    
72.     public:
    
73.         simpleMempool() :ptr(0), root(0) { ; }
    
74.         ~simpleMempool() { VirtualFree(root, 0, MEM_RELEASE); ptr = 0; root = 0; }
    
75. 
    
76.         // 申请失败则抛出int类型异常
    
77.         // 异常值 1=初始化失败, 2=空间不足,需要释放一些内存
    
78.         LPMAKEPROCDATA alloc()
    
79.         {
    
80.             size_t size = sizeof(SUBCLASSSTRUCT);
    
81.             if (!ptr)init();
    
82.             if (!ptr)throw int(1);
    
83.             void* p = ptr;      // 每次申请都从当前节点开始取, 释放则还原到首节点
    
84.             if (ptr->next == 0)throw int(2); // 没有内存了, 抛出异常
    
85. 
    
86.             ptr = ptr->next; // 当前节点指向下一块内存
    
87.             return (LPMAKEPROCDATA)p;
    
88.         }
    
89.         bool free(LPMAKEPROCDATA& p)
    
90.         {
    
91.             if (!ptr || !p)return false;
    
92.             // 释放就简单的加入链表中
    
93.             memset(p, 0, sizeof(SUBCLASSSTRUCT));
    
94.             ((_list*)p)->next = ptr; // 放到链表头部
    
95.             ptr = (_list*)p;
    
96.             p = 0;
    
97.             return true;
    
98.         }
    
99.     };
    
100.     static simpleMempool mempool;
     
101.     inline LPMAKEPROCDATA subclassAlloc()
     
102.     {
     
103.         LPMAKEPROCDATA pData = 0;
     
104.         try
     
105.         {
     
106.             pData = mempool.alloc();
     
107.         }
     
108.         catch (int e)
     
109.         {
     
110.             switch (e)
     
111.             {
     
112.             case 1:
     
113.                 MessageBoxW(0, L"调用SubClassWindow() 失败\n失败原因为:VirtualAlloc() 申请内存失败", L"错误", MB_OK);
     
114.                 break;
     
115.             case 2:
     
116.                 MessageBoxW(0, L"调用SubClassWindow() 失败\n失败原因为:为SubClassWindow() 提供的内存不足", L"错误", MB_OK);
     
117.                 break;
     
118.             default:
     
119.                 MessageBoxW(0, L"调用SubClassWindow() 失败\n失败原因为:其他未知错误", L"错误", MB_OK);
     
120.                 break;
     
121.             }
     
122.             return 0;
     
123.         }
     
124.         return pData;
     
125.     }
     
126. }
     
127. 
     
128. typedef LRESULT(__stdcall* SUBWNDPROC)(LPSUBCLASSSTRUCT, UINT, WPARAM, LPARAM);
     
129. 
     
130. // 返回值强转成 WNDPROC 就可以在注册类时赋值, 窗口过程的第一个参数就是这个返回值
     
131. // proc = 子类化回调函数
     
132. // param = 用户数据
     
133. inline LPSUBCLASSSTRUCT MakeProc(SUBWNDPROC proc, void* param)
     
134. {
     
135.     __subclass::LPMAKEPROCDATA pData = __subclass::subclassAlloc();
     
136.     if (!pData)return 0;
     
137. #ifdef _M_X64
     
138.     // 这里执行的指令有45个字节, 函数地址 - 指令地址 - 指令字节数
     
139.     const INT_PTR pFun = (INT_PTR)proc - INT_PTR(pData) - 45;
     
140. 
     
141.     const unsigned char bin[] = {
     
142.         0x50,                               // push rax 保存原始rax寄存器
     
143.         0x48, 0xB8,0,0,0,0,0,0,0,0,         // mov rax, pData(+3) 把地址放入到eax
     
144.         0x50,                               // push rax 保存地址
     
145.         0x48, 0x8B, 0x40, 0x50,             // mov rax,[rax+50h] 把地址偏移0x50的值存到rax, 指向hWnd
     
146.         0x48, 0xA9, 00, 00, 00, 00,         // test rax, 0   判断rax是否为0
     
147.         0x58,                               // pop rax  把地址取出来放到rax
     
148.         0x75, 0x04,                         // jnz 跳转4个字节
     
149.         0x48, 0x89, 0x48, 0x50,             // mov [rax+50h],rcx 把原来的第一个参数存到地址+0x50的位置
     
150.         0x58,                               // pop rax 还原原始rax数据
     
151.         0x48, 0xb9, 0,0,0,0,0,0,0,0,        // mov rcx, pData(+32)
     
152.         0xe9, 0,0,0,0                       // jmp pFun(+41)
     
153.     };
     
154.     memcpy(pData->data, bin, sizeof(bin));
     
155.     memcpy(pData->data + 3, &pData, 8);
     
156.     memcpy(pData->data + 32, &pData, 8);
     
157.     memcpy(pData->data + 41, &pFun, 4);
     
158. 
     
159. #else
     
160.     // 这里执行的指令有39个字节
     
161.     const int pFun = (int)proc - int(pData) - 39;
     
162.     const unsigned char bin[] = {
     
163.         0x50 ,                              // push eax
     
164.         0xB8, 0,0,0,0,                      // mov eax, pData(+2)
     
165.         0x50,                               // push eax
     
166.         0x8B, 0x40, 0x50,                   // mov eax, [eax+50h]
     
167.         0xA9, 0x00, 0x00, 0x00, 0x00,       // test eax,0
     
168.         0x58,                               // pop eax
     
169.         0x75, 0x08,                         // jne 4个字节
     
170.         0xFF, 0x74, 0x24, 0x08,             // push [esp+8h]
     
171.         0x8F, 0x40, 0x50,                   // pop [eax+50h]
     
172.         0x58,                               // pop eax
     
173.         0xc7, 0x44, 0x24, 0x04, 0,0,0,0,    // mov [esp+4], pData(+30)
     
174.         0xe9, 0,0,0,0                       // jmp pFun(+35)
     
175.     };
     
176.     memcpy(pData->data, bin, sizeof(bin));
     
177.     memcpy(pData->data + 2, &pData, 4);
     
178.     memcpy(pData->data + 30, &pData, 4);
     
179.     memcpy(pData->data + 35, &pFun, 4);
     
180. 
     
181. #endif
     
182. 
     
183.     FlushInstructionCache(GetCurrentProcess(), pData, sizeof(SUBCLASSSTRUCT));
     
184.     LPSUBCLASSSTRUCT ptr = (LPSUBCLASSSTRUCT)pData;
     
185.     ptr->param = param;
     
186.     // 返回的这个回调函数可以用作子类化的回调函数
     
187.     // 子类化第一个参数是 SUBCLASSSTRUCT 结构指针
     
188.     return ptr;
     
189. }
     
190. 
     
191. // 返回值强转成 WNDPROC 就可以在注册类时赋值, 窗口过程的第一个参数就是这个返回值
     
192. // pThis = 回调函数所在的类指针
     
193. // proc = 子类化回调函数, 可以用 类方法, &类名::方法名 来获取
     
194. // param = 用户数据
     
195. template<typename T>
     
196. inline LPSUBCLASSSTRUCT MakeProc(T* pThis, LRESULT(__stdcall T::* fnCallback)(LPSUBCLASSSTRUCT, UINT, WPARAM, LPARAM), void* param)
     
197. {
     
198.     const INT_PTR proc = (INT_PTR) * ((void**)&fnCallback);
     
199.     __subclass::LPMAKEPROCDATA pData = __subclass::subclassAlloc();
     
200.     if (!pData || !proc)return 0;
     
201. #ifdef _M_X64
     
202.     // 这里执行的指令有67个字节
     
203.     const INT_PTR pFun = proc - (INT_PTR)pData - 67;
     
204.     const unsigned char bin[] = {
     
205.         0x50,                               // push rax 保存原始rax寄存器
     
206.         0x48, 0xB8,0,0,0,0,0,0,0,0,         // mov rax, pData(+3) 把地址放入到eax
     
207.         0x50,                               // push rax 保存地址
     
208.         0x48, 0x8B, 0x40, 0x50,             // mov rax,[rax+50h] 把地址偏移0x50的值存到rax, 指向hWnd
     
209.         0x48, 0xA9, 00, 00, 00, 00,         // test rax, 0   判断rax是否为0
     
210.         0x58,                               // pop rax  把地址取出来放到rax
     
211.         0x75, 0x04,                         // jnz 跳转4个字节
     
212.         0x48, 0x89, 0x48, 0x50,             // mov [rax+50h],rcx 把原来的第一个参数存到地址+0x50的位置
     
213.         0x58,                               // pop rax 还原原始rax数据
     
214.         0x41, 0x51,                         // push r9
     
215.         0x8f, 0x44, 0x24, 0x28,             // pop [esp-28h]
     
216.         0x4d, 0x8b, 0xc8,                   // mov r9, r8
     
217.         0x4c, 0x8b, 0xc2,                   // mov r8, rdx
     
218.         0x48, 0xba, 0,0,0,0,0,0,0,0,        // mov rdx, pData(+44)
     
219.         0x48, 0xb9, 0,0,0,0,0,0,0,0,        // mov rcx, pThis(+54)
     
220.         0xe9, 0,0,0,0                       // jmp pFun(+63)
     
221.     };
     
222.     memcpy(pData->data, bin, sizeof(bin));
     
223.     memcpy(pData->data + 3, &pData, 8);
     
224.     memcpy(pData->data + 44, &pData, 8);
     
225.     memcpy(pData->data + 54, &pThis, 8);
     
226.     memcpy(pData->data + 63, &pFun, 4);
     
227. 
     
228. #else
     
229.     // 这里执行的指令有50个字节
     
230.     const INT_PTR pFun = proc - (INT_PTR)pData - 50;
     
231.     char as[] = {
     
232.     };
     
233.     const unsigned char bin[] = {
     
234.         0x50 ,                              // push eax
     
235.         0xB8, 0,0,0,0,                      // mov eax, pData(+2)
     
236.         0x50,                               // push eax
     
237.         0x8B, 0x40, 0x50,                   // mov eax, [eax+50h]
     
238.         0xA9, 0x00, 0x00, 0x00, 0x00,       // test eax,0
     
239.         0x58,                               // pop eax
     
240.         0x75, 0x08,                         // jne 4个字节
     
241.         0xFF, 0x74, 0x24, 0x08,             // push [esp+8h]
     
242.         0x8F, 0x40, 0x50,                   // pop [eax+50h]
     
243.         0x58,                               // pop eax
     
244.         0xff, 0x34, 0x24,                   // push esp
     
245.         0xc7, 0x44, 0x24, 0x04, 0,0,0,0,    // mov [esp+4], pThis(+33)
     
246.         0xc7, 0x44, 0x24, 0x08, 0,0,0,0,    // mov [esp+8], pData(+41)
     
247.         0xe9, 0,0,0,0                       // jmp pFun(+46)
     
248.     };
     
249.     memcpy(pData->data, bin, sizeof(bin));
     
250.     memcpy(pData->data + 2, &pData, 4);
     
251.     memcpy(pData->data + 32, &pThis, 4);
     
252.     memcpy(pData->data + 41, &pData, 4);
     
253.     memcpy(pData->data + 46, &pFun, 4);
     
254. 
     
255. #endif
     
256.     FlushInstructionCache(GetCurrentProcess(), pData, sizeof(SUBCLASSSTRUCT));
     
257.     LPSUBCLASSSTRUCT ptr = (LPSUBCLASSSTRUCT)pData;
     
258.     ptr->param = param;
     
259.     // 返回的这个回调函数可以用作子类化的回调函数
     
260.     // 子类化第一个参数是 SUBCLASSSTRUCT 结构指针
     
261.     return ptr;
     
262. }
     
263. 
     
264. // 当不需要使用时必须要调用FreeSubClass()进行释放, 传入的数据为子类化的第一个参数
     
265. // 此函数调用 SetWindowLongPtrW(hWnd, GWLP_WNDPROC, (WNDPROC)MakeProc()) 来进行子类化
     
266. // 如果只需要获取子类化的函数, 请调用 MakeProc()
     
267. // hWnd = 要子类化的窗口句柄
     
268. // proc = 子类化回调函数
     
269. // param = 用户数据
     
270. inline bool __stdcall SubClassWindow(HWND hWnd, SUBWNDPROC proc, void* param)
     
271. {
     
272.     //if (!IsWindow(hWnd))return false;
     
273.     LPSUBCLASSSTRUCT ptr = MakeProc(proc, param);
     
274.     if (!ptr)return false;
     
275.     ptr->hWnd = hWnd;
     
276.     ptr->oldProc = (WNDPROC)SetWindowLongPtrW(hWnd, GWLP_WNDPROC, (LONG_PTR)ptr);
     
277.     return true;
     
278. }
     
279. 
     
280. // 当不需要使用时必须要调用FreeSubClass()进行释放, 传入的数据为子类化的第一个参数
     
281. // 此函数调用 SetWindowLongPtrW(hWnd, GWLP_WNDPROC, (WNDPROC)MakeProc()) 来进行子类化
     
282. // 如果只需要获取子类化的函数, 请调用 MakeProc()
     
283. // hWnd = 要子类化的窗口句柄
     
284. // pThis = 回调函数所在的类指针
     
285. // proc = 子类化回调函数, 可以用 类方法, &类名::方法名 来获取
     
286. // param = 用户数据
     
287. template<typename T>
     
288. inline bool __stdcall SubClassWindow( HWND hWnd, T* pThis, LRESULT(__stdcall T::* proc)(LPSUBCLASSSTRUCT, UINT, WPARAM, LPARAM), void* param)
     
289. {
     
290.     if (!IsWindow(hWnd)) return false;
     
291.     LPSUBCLASSSTRUCT ptr = MakeProc(pThis, proc, param);
     
292.     if (!ptr)return false;
     
293.     ptr->hWnd = hWnd;
     
294.     ptr->oldProc = (WNDPROC)SetWindowLongPtrW(hWnd, GWLP_WNDPROC, (LONG_PTR)ptr);
     
295.     // 返回的这个回调函数可以用作子类化的回调函数
     
296.     // 子类化第一个参数是 SUBCLASSSTRUCT 结构指针
     
297.     return true;
     
298. }
     
299. 
     
300. // 释放申请的内存空间, 调用后会把传入参数置0, 参数是子类化里第一个参数的值
     
301. // 调用此函数前必须先调用 SetWindowLongW(hWnd, GWLP_WNDPROC, oldProc) 还原子类化
     
302. inline bool __stdcall FreeSubClass(__subclass::LPMAKEPROCDATA& proc)
     
303. {
     
304.     return __subclass::mempool.free(proc);
     
305. }

复制代码

简单的超类化例子

超类化可以收到 WM_NCCREATE, WM_CREATE 消息
子类化的话是收不到这两个消息的, 我感觉这个不算不常用啊
如果需要在控件创建前处理一些事情的话, 子类化实现不了, 超类化可以实现
因为子类化是针对窗口, 需要子类化的时候表示窗口已经创建成功了
超类化是基于类, 窗口还没创建时就已经处理了

1. LRESULT CALLBACK RegisterClassWndProc(LPSUBCLASSSTRUCT pData, UINT message, WPARAM wParam, LPARAM lParam)
   
2. {
   
3.     // 收到所有消息都转到 pData->oldProc 这个函数去处理
   
4.     // pData->oldProc 这个函数是 button 类的默认处理函数
   
5.     return CallWindowProcW(pData->oldProc, pData->hWnd, message, wParam, lParam);
   
6. }
   
7. void test(HINSTANCE hInst)
   
8. {
   
9.     WNDCLASSEXW wcex = { 0 };
   
10.     wcex.cbSize = sizeof(WNDCLASSEXW);
    
11.     GetClassInfoExW(hInst, L"button", &wcex);   // 获取"button"类的结构
    
12.     wcex.lpszClassName = L"新类名";
    
13.     LPSUBCLASSSTRUCT newProc = MakeProc(RegisterClassWndProc, 0);
    
14.     newProc->oldProc = wcex.lpfnWndProc;     // 保存"button"类的消息过程函数
    
15.     wcex.lpfnWndProc = (WNDPROC)newProc;        // 创建类名为"新类名"时的消息过程函数
    
16.     RegisterClassExW(&wcex);                    // 注册类
    
17. 
    
18.     // 调用 CreateWindowExW 后, 这个控件的所有消息都在 RegisterClassWndProc 这个函数里
    
19.     // RegisterClassWndProc 这个函数把消息都转到 button类原来的消息处理函数
    
20.     CreateWindowExW(0, L"新类名", L"拥有button类的所有特征", 0, 0, 0, 0, 0, 0, 0, 0, 0);
    
21. }

复制代码