在Visual C++应用程序中彻底清除进程

　读者朋友们可能经常会碰到这样一个问题，想对某些进行操作时，发现这些文件正在被其它程序使用，处于打开状态，而且是被独占打开，这时是没法对文件进行操作的。因此，要想操作这些文件，必须将打开这些文件的进程清除掉。那么如何干净地清除进程呢？其实，在Windows2000操作系统版本中有一个工具程序叫tskill.exe，用它就可以清除掉某个程序的进程，在输入\"tskill 程序名\"后就可以清除其运行实例。但是如何要在代码里实现tskill的功能该如何做呢？针对这一问题，本实例介绍了在Windows2000下实现的方法。

　　 一、实现方法

　　在Visual C++编程中，最安全的杀死进程的方法是向运行程序的主窗口发送WM_CLOSE消息，其实现代码如下：

HWND hwnd =this.m_hWnd； // 获得主窗口
PostMessage(hwnd, WM_CLOSE, 0, 0)；
　　发送此消息后，通常应该等待直到进程确实终止，当进程终止时，它发出状态信号，并且 WaitForSingleObject 返回WAIT_OBJECT_0。如果返回别的值，进程要么挂起了，要么仍然在进行处理。在这种情况下，杀死这个进程的唯一方法是用功能更强大的API函数：TerminateProcess（）。如果想干得漂亮一点，可以在关闭之前向主窗口发送一个WM_QUERYENDSESSION消息，当用户结束会话（log out）或者调用ExitWindows（）函数时，应用程序会收到这个消息，然后准备退出进程，此时一般都会弹出一个确认对话框，告诉用户：\"程序要推出了，如果要保存修改的东西，现在是最佳时机，想保存吗？\"有三种选择（Yes/No/Cancel）。此外，发送WM_QUERYENDSESSION消息可以拒绝推出进程（按下\"Cancel键\"），如果是这样，进程将会延续。

　　如果想要关闭的进程被挂起，使用SendMessageTimeout（）函数就非常重要，而不是用SendMessage（）函数，其参数SMTO_NOTIMEOUTIFNOTHUNG是一个只有Windows 2000 和Windows XP才有的标志。其意义是\"如果线程没有挂起，不要超时\"，换句话说就是如果线程正在进行正常处理，那么永远等待，以便用户能看到对话框并决定做什么，当用户最终做出决定后，SendMessageTimeout（）将带着相应的bOKToKill值返回。

　　本例为了增强代码的可重用性，将实现细节都封装在一个叫CFindKillProcess的类中，包括查找和杀死进程，详情请参见EnumProc.h和EnumProc.cpp文件。文件中还有另外两个可重用类，一个是CProcessIterator，另一个是CWindowIterator。

　　CfindKillProcess类的成员函数FindProcess（）查找某个进程序，如果找到这个进程，它返回此进程的ID，然后将此ID传给CFindKillProcess::KillProcess（）函数，KillProcess（）函数封装了关闭窗口以及终止逻辑，它利用CmainWindowIterator类对象来枚举进程的主窗口（可能不止一个，见\"如何获取某个进程的主窗口以及创建进程的程序名？\"），并发送WM_CLOSE到每一个窗口，然后等待进程死亡。它有一个布尔型参数用来指示当应用程序进程不愿意退出时是否执行TerminateProcess（）函数。详细细节请参见下载的代码。

　　 二、编程步骤

　　1、 启动Visual C++6.0，生成一个控制台应用程序，将该程序命名为\"kp\"；

　　2、 在程序代码中添加CfindKillProcess、CProcessIterator类的定义；

　　3、 添加代码，编译运行程序。
　 三、程序代码

1. ///////////////////////////////////////////////////////////////////////////////////////////
   
2. #pragma once
   
3. //////////////////
   
4. // Process iterator -- iterator over all system processes
   
5. // Always skips the first (IDLE) process with PID=0.
   
6. class CProcessIterator {
   
7. protected:
   
8. 　DWORD* m_pids; // array of procssor IDs
   
9. 　DWORD m_count; // size of array
   
10. 　DWORD m_current; // next array item
    
11. 
    
12. public:
    
13. 　CProcessIterator();
    
14. 　~CProcessIterator();
    
15. 　DWORD First();
    
16. 　DWORD Next() {
    
17. 　　return m_pids && m_current < m_count ? m_pids[m_current++] : 0;
    
18. 　}
    
19. 　DWORD GetCount() {
    
20. 　　return m_count;
    
21. 　}
    
22. };
    
23. //////////////////
    
24. // Handy class to facilitate finding and killing a process by name.
    
25. class CFindKillProcess {
    
26. public:
    
27. 　CFindKillProcess();
    
28. 　~CFindKillProcess();
    
29. 　DWORD FindProcess(LPCTSTR lpModname, BOOL bAddExe=TRUE);
    
30. 　BOOL KillProcess(DWORD pid, BOOL bZap);
    
31. };
    
32. 
    
33. ///////////////////////////////////////////////////////////////////////////////////////////////
    
34. #include "stdafx.h"
    
35. #include "EnumProc.h"
    
36. // CProcessIterator - Iterates all processes
    
37. CProcessIterator::CProcessIterator()
    
38. {
    
39. 　m_pids = NULL;
    
40. }
    
41. 
    
42. CProcessIterator::~CProcessIterator()
    
43. {
    
44. 　delete [] m_pids;
    
45. }
    
46. 
    
47. //////////////////
    
48. // Get first process: Call EnumProcesses to init array. Return first one.
    
49. DWORD CProcessIterator::First()
    
50. {
    
51. 　m_current = (DWORD)-1;
    
52. 　m_count = 0;
    
53. 　DWORD nalloc = 1024;
    
54. 　do {
    
55. 　　delete [] m_pids;
    
56. 　　m_pids = new DWORD [nalloc];
    
57. 　　if (EnumProcesses(m_pids, nalloc*sizeof(DWORD), &m_count)) {
    
58. 　　　m_count /= sizeof(DWORD);
    
59. 　　　m_current = 1; // skip IDLE process
    
60. 　　}
    
61. 　} while (nalloc <= m_count);
    
62. 　　return Next();
    
63. }
    
64. 
    
65. ////////////////////////////////////////////////////////////////
    
66. // CFindKillProcess - to find/kill a process by module name.
    
67. //
    
68. CFindKillProcess::CFindKillProcess()
    
69. {}
    
70. 
    
71. CFindKillProcess::~CFindKillProcess()
    
72. {}
    
73. 
    
74. //////////////////
    
75. // Search for process whose module name matches parameter.
    
76. // Finds "foo" or "foo.exe"
    
77. DWORD CFindKillProcess::FindProcess(LPCTSTR modname, BOOL bAddExe)
    
78. {
    
79. 　CProcessIterator itp;
    
80. 　for (DWORD pid=itp.First(); pid; pid=itp.Next()) {
    
81. 　　TCHAR name[_MAX_PATH];
    
82. 　　CProcessModuleIterator itm(pid);
    
83. 　　HMODULE hModule = itm.First(); // .EXE
    
84. 　　if (hModule) {
    
85. 　　　GetModuleBaseName(itm.GetProcessHandle(),hModule, name, _MAX_PATH);
    
86. 　　　string sModName = modname;
    
87. 　　　if (strcmpi(sModName.c_str(),name)==0)
    
88. 　　　　return pid;
    
89. 　　　　sModName += ".exe";
    
90. 　　　if (bAddExe && strcmpi(sModName.c_str(),name)==0)
    
91. 　　　　return pid;
    
92. 　　}
    
93. 　}
    
94. 　return 0;
    
95. }
    
96. 
    
97. //////////////////
    
98. // Kill a process cleanly: Close main windows and wait.
    
99. // bZap=TRUE to force kill.
    
100. BOOL CFindKillProcess::KillProcess(DWORD pid, BOOL bZap)
     
101. {
     
102. 　CMainWindowIterator itw(pid);
     
103. 　for (HWND hwnd=itw.First(); hwnd; hwnd=itw.Next()) {
     
104. 　　DWORD bOKToKill = FALSE;
     
105. 　　SendMessageTimeout(hwnd, WM_QUERYENDSESSION, 0, 0,SMTO_ABORTIFHUNG|SMTO_NOTIMEOUTIFNOTHUNG,100, &bOKToKill);
     
106. 　　if (!bOKToKill)
     
107. 　　　return FALSE; // window doesn&#39;t want to die: abort
     
108. 　　　PostMessage(hwnd, WM_CLOSE, 0, 0);
     
109. 　}
     
110. 　// I&#39;ve closed the main windows; now wait for process to die.
     
111. 　BOOL bKilled = TRUE;
     
112. 　HANDLE hp=OpenProcess(SYNCHRONIZE|PROCESS_TERMINATE,FALSE,pid);
     
113. 　if (hp) {
     
114. 　　if (WaitForSingleObject(hp, 5000) != WAIT_OBJECT_0) {
     
115. 　　　if (bZap) { // didn&#39;t die: force kill it if zap requested
     
116. 　　　　TerminateProcess(hp,0);
     
117. 　　　} else {
     
118. 　　　　bKilled = FALSE;
     
119. 　　　}
     
120. 　　}
     
121. 　　CloseHandle(hp);
     
122. 　}
     
123. 　return bKilled;
     
124. }
     
125. 
     
126. //////////////////////////////////////////////////////////////////////////
     
127. #include "stdafx.h"
     
128. #include "EnumProc.h"
     
129. #define tpf _tprintf // to save typing
     
130. typedef list CStringList; // like MFC, but with STL
     
131. // pre-declare functions
     
132. int help();
     
133. // check for switch: / or -
     
134. inline BOOL isswitch(TCHAR c) { return c==L&#39;/&#39; || c==L&#39;-&#39;; }
     
135. 
     
136. int main(int argc, TCHAR* argv[], TCHAR* envp[])
     
137. {
     
138. 　CStringList cmdargs; // command-line args (processes to kill)
     
139. 　BOOL bDisplayOnly=FALSE; // don&#39;t kill, just show results
     
140. 　BOOL bQuiet=FALSE; // suppress error messages
     
141. 　BOOL bZap=FALSE; // force-kill process
     
142. 　// Parse command line. Switches can come in any order.
     
143. 　for (int i=1; i 　　if (isswitch(argv[i][0])) {
     
144. 　　　for (UINT j=1; j 　　　　switch(tolower(argv[i][j])) {
     
145. 　　　　　case &#39;?&#39;: help(); return 0;
     
146. 　　　　　case &#39;n&#39;: bDisplayOnly=TRUE; break;
     
147. 　　　　　case &#39;q&#39;: bQuiet=TRUE; break;
     
148. 　　　　　case &#39;z&#39;: bZap=TRUE; break;
     
149. 　　　　　default:
     
150. 　　　　　　return help();
     
151. 　　　　}
     
152. 　　　}
     
153. 　　} else {
     
154. 　　　cmdargs.push_back(argv[i]); // got a non-switch arg: add to list
     
155. 　　}
     
156. 　}
     
157. 　if (cmdargs.size() <=0)
     
158. 　　help();
     
159. 　　// Now iterate args (module names), killing each one
     
160. 　　CStringList::iterator it;
     
161. 　　for (it=cmdargs.begin(); it!=cmdargs.end(); it++) {
     
162. 　　　CFindKillProcess fkp;
     
163. 
     
164. 　　　DWORD pid = fkp.FindProcess(it-> c_str());
     
165. 　　　if (pid) {
     
166. 　　　　if (bDisplayOnly) {
     
167. 　　　　　tpf(_T("Kill process %d(0x%08x)\\n"),pid,pid);
     
168. 　　　　} else {
     
169. 　　　　　fkp.KillProcess(pid, bZap);
     
170. 　　　　}
     
171. 　　　} else if (!bQuiet) {
     
172. 　　　　tpf(_T("Error: Can&#39;t find process &#39;%s&#39;.\\n"),it-> c_str());
     
173. 　　　}
     
174. 　　}
     
175. 　　return 0;
     
176. 　}
     
177. 
     
178. 　int help()
     
179. 　{
     
180. 　　tpf(_T("kp: Kill process from command line.\\n"));
     
181. 　　tpf(_T(" Copyright 2002 Paul DiLascia.\\n\\n"));
     
182. 　　tpf(_T(" kp [/nqz?] modname1 [modname2....]\\n"));
     
183. 　　tpf(_T(" where modnameN is a module name; eg foo or foo.exe\\n"));
     
184. 　　tpf(_T("\\n"));
     
185. 　　tpf(_T(" /n(othing) don&#39;t kill, just show results\\n"));
     
186. 　　tpf(_T(" /q(uiet) don&#39;t show errors\\n"));
     
187. 　　tpf(_T(" /z(ap) force kill (ignore WM_QUERYENDSESSION)\\n"));
     
188. 　　tpf(_T("\\n"));
     
189. 　　return 0;
     
190. 　}

复制代码

　　 四、小结

　　本实例通过介绍CfindKillProcess类探讨了在Windows2000下彻底消除进程的方法，虽然该程序只能在Windows2000环境下编译运行，但是该方法对Windows98下进程的控制也是有借鉴意义的

HOHO~~~~~~

给我点愤怒.

看,刚说你眼神不好,你还就来劲了不是.

不早了 各位晚安~~~~

先看看怎么样！