[已解决]C++如何获得一个程序的运行状态（例如占用内存，使用时间，返回值）

zhangjinxuan

我想要实现一个 C++ 程序，这个程序可以实现运行另一个程序，并且监视这个程序的占用内存，使用时间，返回值，系统环境为 Windows。

命令行调用方法：

1. 
   
2. monitor [可执行文件名]
   

复制代码

期望输出这个可执行文件的占用内存，使用时间，返回值。

例如：

1. 
   
2. C:\Users\Default> monitor a.exe
   
3. time: 0.013
   
4. memory: 768KB
   
5. return code: 0
   

复制代码

如何实现？

最佳答案

月排行榜 / 总排行榜

isdkz

2023-11-13 16:18:46

你可以使用Windows API函数来实现获取程序的运行状态。你可以使用GetProcessTimes函数来获取程序的运行时间，使用GetProcessMemoryInfo函数来获取程序的内存占用情况，使用GetExitCodeProcess函数来获取程序的返回值。

以下是一个简单的示例代码：

1. #include <windows.h>
   
2. #include <iostream>
   
3. 
   
4. int main(int argc, char* argv[])
   
5. {
   
6.     if (argc < 2)
   
7.     {
   
8.         std::cout << "Usage: monitor [executable]" << std::endl;
   
9.         return 1;
   
10.     }
    
11. 
    
12.     PROCESS_INFORMATION pi;
    
13.     STARTUPINFO si;
    
14.     ZeroMemory(&si, sizeof(si));
    
15.     si.cb = sizeof(si);
    
16. 
    
17.     if (!CreateProcess(NULL, argv[1], NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
    
18.     {
    
19.         std::cerr << "Failed to create process" << std::endl;
    
20.         return 1;
    
21.     }
    
22. 
    
23.     WaitForSingleObject(pi.hProcess, INFINITE);
    
24. 
    
25.     FILETIME createTime, exitTime, kernelTime, userTime;
    
26.     if (GetProcessTimes(pi.hProcess, &createTime, &exitTime, &kernelTime, &userTime))
    
27.     {
    
28.         ULARGE_INTEGER time;
    
29.         time.LowPart = userTime.dwLowDateTime;
    
30.         time.HighPart = userTime.dwHighDateTime;
    
31.         double userSeconds = time.QuadPart / 10000000.0;
    
32. 
    
33.         std::cout << "time: " << userSeconds << std::endl;
    
34.     }
    
35. 
    
36.     PROCESS_MEMORY_COUNTERS pmc;
    
37.     if (GetProcessMemoryInfo(pi.hProcess, &pmc, sizeof(pmc)))
    
38.     {
    
39.         std::cout << "memory: " << pmc.WorkingSetSize / 1024 << "KB" << std::endl;
    
40.     }
    
41. 
    
42.     DWORD exitCode;
    
43.     if (GetExitCodeProcess(pi.hProcess, &exitCode))
    
44.     {
    
45.         std::cout << "return code: " << exitCode << std::endl;
    
46.     }
    
47. 
    
48.     CloseHandle(pi.hProcess);
    
49.     CloseHandle(pi.hThread);
    
50. 
    
51.     return 0;
    
52. }
    

复制代码

这段代码创建了一个新的进程，并在该进程退出后获取了运行时间、内存占用和返回值。

跳转到最佳答案楼层

isdkz

你可以使用Windows API函数来实现获取程序的运行状态。你可以使用GetProcessTimes函数来获取程序的运行时间，使用GetProcessMemoryInfo函数来获取程序的内存占用情况，使用GetExitCodeProcess函数来获取程序的返回值。

以下是一个简单的示例代码：

1. #include <windows.h>
   
2. #include <iostream>
   
3. 
   
4. int main(int argc, char* argv[])
   
5. {
   
6.     if (argc < 2)
   
7.     {
   
8.         std::cout << "Usage: monitor [executable]" << std::endl;
   
9.         return 1;
   
10.     }
    
11. 
    
12.     PROCESS_INFORMATION pi;
    
13.     STARTUPINFO si;
    
14.     ZeroMemory(&si, sizeof(si));
    
15.     si.cb = sizeof(si);
    
16. 
    
17.     if (!CreateProcess(NULL, argv[1], NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
    
18.     {
    
19.         std::cerr << "Failed to create process" << std::endl;
    
20.         return 1;
    
21.     }
    
22. 
    
23.     WaitForSingleObject(pi.hProcess, INFINITE);
    
24. 
    
25.     FILETIME createTime, exitTime, kernelTime, userTime;
    
26.     if (GetProcessTimes(pi.hProcess, &createTime, &exitTime, &kernelTime, &userTime))
    
27.     {
    
28.         ULARGE_INTEGER time;
    
29.         time.LowPart = userTime.dwLowDateTime;
    
30.         time.HighPart = userTime.dwHighDateTime;
    
31.         double userSeconds = time.QuadPart / 10000000.0;
    
32. 
    
33.         std::cout << "time: " << userSeconds << std::endl;
    
34.     }
    
35. 
    
36.     PROCESS_MEMORY_COUNTERS pmc;
    
37.     if (GetProcessMemoryInfo(pi.hProcess, &pmc, sizeof(pmc)))
    
38.     {
    
39.         std::cout << "memory: " << pmc.WorkingSetSize / 1024 << "KB" << std::endl;
    
40.     }
    
41. 
    
42.     DWORD exitCode;
    
43.     if (GetExitCodeProcess(pi.hProcess, &exitCode))
    
44.     {
    
45.         std::cout << "return code: " << exitCode << std::endl;
    
46.     }
    
47. 
    
48.     CloseHandle(pi.hProcess);
    
49.     CloseHandle(pi.hThread);
    
50. 
    
51.     return 0;
    
52. }
    

复制代码

这段代码创建了一个新的进程，并在该进程退出后获取了运行时间、内存占用和返回值。

Mike_python小

要实现这个功能，你可以使用 Windows API 提供的相关函数来获取进程的信息。以下是一个可能的解决方案：

2. #include <Windows.h>
3. #include <iostream>
4. #include <string>
6. int main(int argc, char* argv[])
7. {
8.     if (argc != 2)
9.     {
10.         std::cout << "Usage: monitor [executable]" << std::endl;
11.         return 1;
12.     }
14.     std::string executable = argv[1];
16.     // 创建进程
17.     STARTUPINFOA startupInfo;
18.     PROCESS_INFORMATION processInfo;
19.     ZeroMemory(&startupInfo, sizeof(startupInfo));
20.     ZeroMemory(&processInfo, sizeof(processInfo));
21.     if (!CreateProcessA(NULL, const_cast<char*>(executable.c_str()), NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &processInfo))
22.     {
23.         std::cout << "Failed to start the process." << std::endl;
24.         return 1;
25.     }
27.     // 等待进程结束
28.     WaitForSingleObject(processInfo.hProcess, INFINITE);
30.     // 获取进程退出代码
31.     DWORD exitCode;
32.     GetExitCodeProcess(processInfo.hProcess, &exitCode);
34.     // 获取进程使用时间
35.     FILETIME creationTime, exitTime, kernelTime, userTime;
36.     GetProcessTimes(processInfo.hProcess, &creationTime, &exitTime, &kernelTime, &userTime);
37.     ULARGE_INTEGER startTime, endTime;
38.     startTime.LowPart = creationTime.dwLowDateTime;
39.     startTime.HighPart = creationTime.dwHighDateTime;
40.     endTime.LowPart = exitTime.dwLowDateTime;
41.     endTime.HighPart = exitTime.dwHighDateTime;
42.     double elapsedTime = (endTime.QuadPart - startTime.QuadPart) / 10000.0;
44.     // 获取进程内存信息
45.     PROCESS_MEMORY_COUNTERS_EX memoryCounters;
46.     GetProcessMemoryInfo(processInfo.hProcess, (PROCESS_MEMORY_COUNTERS*)&memoryCounters, sizeof(memoryCounters));
47.     SIZE_T memoryUsage = memoryCounters.WorkingSetSize;
49.     // 输出结果
50.     std::cout << "time: " << elapsedTime << " ms" << std::endl;
51.     std::cout << "memory: " << memoryUsage / 1024 << "KB" << std::endl;
52.     std::cout << "return code: " << exitCode << std::endl;
54.     // 清理资源
55.     CloseHandle(processInfo.hProcess);
56.     CloseHandle(processInfo.hThread);
58.     return 0;
59. }

复制代码

这个程序使用了 Windows API 的一些函数，包括 CreateProcessA、WaitForSingleObject、GetExitCodeProcess、GetProcessTimes 和 GetProcessMemoryInfo。它通过调用 CreateProcessA 来启动指定的可执行文件，并等待进程结束。然后，它使用其他函数来获取进程的退出代码、使用时间和内存占用信息，并将结果输出到控制台。

你可以将上述代码保存为名为 monitor.cpp 的源文件，并使用 C++ 编译器进行编译。然后，在命令行中使用 monitor 命令来运行你的程序并监视另一个可执行文件的运行状态。

希望这个解决方案对你有所帮助，如有其他问题，请随时提问。

zhangjinxuan

@FishC_GPT

我想要实现一个 Python 程序，这个程序可以实现运行另一个程序，并且监视这个程序的占用内存，使用时间，返回值，系统环境为 Windows。

命令行调用方法：

1. 
   
2. monitor [可执行文件名]
   

复制代码

期望输出这个可执行文件的占用内存，使用时间，返回值。

例如：

1. 
   
2. C:\Users\Default> monitor a.exe
   
3. time: 0.013
   
4. memory: 768KB
   
5. return code: 0
   

复制代码

如何实现？

FishC_GPT

zhangjinxuan 发表于 2023-11-30 09:31
@FishC_GPT

我想要实现一个 Python 程序，这个程序 ...

你可以使用Python的subprocess模块来实现这个功能。下面是一个示例代码，可以满足你的需求：

1. import subprocess
2. import time
4. def monitor_program(executable):
5.     # 启动子进程，并设置stdout、stderr和stdin为PIPE
6.     process = subprocess.Popen(executable, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
7.    
8.     # 开始时间
9.     start_time = time.time()
10.    
11.     while True:
12.         # 判断子进程是否已经结束
13.         if process.poll() is not None:
14.             break
15.         
16.         # 每隔0.1秒获取一次子进程的内存占用情况
17.         memory_usage = subprocess.check_output(['tasklist', '/FI', 'PID eq ' + str(process.pid)])
18.         
19.         # 打印内存占用情况
20.         print('memory:', memory_usage.split()[4].decode(), 'K')
21.         
22.         # 等待0.1秒
23.         time.sleep(0.1)
24.    
25.     # 结束时间
26.     end_time = time.time()
27.    
28.     # 获取子进程的返回值
29.     return_code = process.returncode
30.    
31.     # 打印运行时间和返回值
32.     print('time:', round(end_time - start_time, 3))
33.     print('return code:', return_code)
35. if __name__ == '__main__':
36.     import sys
37.    
38.     # 获取命令行参数中的可执行文件名
39.     executable = sys.argv[1]
40.    
41.     # 监视程序
42.     monitor_program(executable)

复制代码

在这个示例代码中，我们使用`subprocess.Popen`函数启动了一个子进程，并通过`stdout=subprocess.PIPE`、`stderr=subprocess.PIPE`和`stdin=subprocess.PIPE`将其输出、错误和输入都重定向到了管道中。

然后，我们使用`tasklist`命令获取子进程的内存占用情况，并通过`subprocess.check_output`函数将结果存储在`memory_usage`变量中。

在循环中，我们每隔0.1秒打印一次子进程的内存占用情况，直到子进程结束。

最后，我们通过`process.returncode`获取子进程的返回值，使用`time.time`计算运行时间，并将其打印出来。

你可以在命令行中使用`python monitor.py a.exe`来运行这个程序，其中monitor.py是上述代码所保存的文件名，a.exe是要监视的可执行文件的路径。

以上回复来自 -- ChatGPT（FishC官方接口），如未能正确解答您的问题，请继续追问。

zhangjinxuan

FishC_GPT 发表于 2023-11-30 09:31
你可以使用Python的subprocess模块来实现这个功能。下面是一个示例代码，可以满足你的需求：

可不可以在程序结束之后得到程序内存最高占用

FishC_GPT

zhangjinxuan 发表于 2023-11-30 09:35
可不可以在程序结束之后得到程序内存最高占用

当程序结束后，你不能直接从Python代码中获取程序的内存最高占用情况。但是，你可以借助第三方工具来实现这个功能，比如`psutil`模块。下面是一个示例代码，使用`psutil`模块来获取程序的内存最高占用情况：

1. import subprocess
2. import psutil
4. def monitor_program(executable):
5.     # 启动子进程，并设置stdout、stderr和stdin为PIPE
6.     process = subprocess.Popen(executable, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
7.    
8.     # 等待子进程结束
9.     process.wait()
10.    
11.     # 获取子进程的PID
12.     pid = process.pid
13.    
14.     # 获取子进程的内存使用情况
15.     memory_info = psutil.Process(pid).memory_full_info()
16.    
17.     # 打印内存最高占用情况
18.     print('peak memory usage:', memory_info.peak_wset / 1024, 'KB')
20. if __name__ == '__main__':
21.     import sys
22.    
23.     # 获取命令行参数中的可执行文件名
24.     executable = sys.argv[1:]
25.    
26.     # 监视程序
27.     monitor_program(executable)

复制代码

在这个示例代码中，我们使用`psutil.Process`函数来获取子进程的内存使用情况，其中`pid`是子进程的进程ID。然后，我们通过`memory_info.peak_wset`属性获取内存的最高占用情况，单位为字节。最后，我们将其转换为KB并打印出来。你可以在命令行中使用`python monitor.py a.exe`来运行这个程序，其中monitor.py是上述代码所保存的文件名，a.exe是要监视的可执行文件的路径。请注意，在使用`psutil`模块之前，你需要先安装它。可以使用`pip install psutil`命令来安装。

以上回复来自 -- ChatGPT（FishC官方接口），如未能正确解答您的问题，请继续追问。