c++子类化源码, 支持类方法, 留帖记录

福仔

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

复制代码

下面是调用例子

1. 
   
2. class test
   
3. {
   
4. public:
   
5.         LRESULT WINAPI testProc(LPSUBCLASSSTRUCT pData, UINT message, WPARAM wParam, LPARAM lParam)
   
6.         {
   
7.                 // 跟正常的子类化差不多, 只不过第一个参数不是窗口句柄, 而是一个结构指针
   
8.                 return CallWindowProcW(pData->oldProc, pData->hWnd, message, wParam, lParam);
   
9.         }
   
10. };
    
11. 
    
12. LRESULT CALLBACK testProc(LPSUBCLASSSTRUCT pData, UINT message, WPARAM wParam, LPARAM lParam)
    
13. {
    
14.         // 跟正常的子类化差不多, 只不过第一个参数不是窗口句柄, 而是一个结构指针
    
15.         return CallWindowProcW(pData->oldProc, pData->hWnd, message, wParam, lParam);
    
16. }
    
17. 
    
18. void test1(HWND hWnd)
    
19. {
    
20.         test a;
    
21.         SubClassWindow(hWnd, &a, &test::testProc, 0);
    
22.         SubClassWindow(hWnd, testProc, 0);
    
23. }

复制代码

subclass.zip (2.88 KB, 下载次数: 8)

2020-2-28 18:20 上传

点击文件名下载附件
这个附件就是上面的内容, 防止某些字符被和谐