VC++使用WMI来获取CPU的名称、主频和核心数

源码资源网

VC++使用WMI来获取CPU的名称、主频和核心数
要更准确地获取CPU的主频，我们可以使用Windows Management Instrumentation (WMI)。以下是改进后的代码示例，使用WMI来获取CPU的名称、主频和核心数：

1. #include <windows.h>
   
2. #include <iostream>
   
3. #include <string>
   
4. #include <comdef.h>
   
5. #include <wbemidl.h>
   
6. #pragma comment(lib, "wbemuuid.lib")
   
7. std::string GetCPUName() {
   
8.     std::string cpuName;
   
9.     HRESULT hres;
   
10.      // 初始化COM库
    
11.     hres = CoInitializeEx(0, COINIT_MULTITHREADED);
    
12.     if (FAILED(hres)) {
    
13.         return "无法初始化COM库";
    
14.     }
    
15.      // 初始化COM
    
16.     hres = CoInitializeSecurity(NULL,
    
17.         -1,                          // COM negotiates service
    
18.         NULL,                       // Authentication services
    
19.         NULL,                       // Reserved
    
20.         RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication
    
21.         RPC_C_IMP_LEVEL_IMPERSONATE,// Impersonation
    
22.         NULL,                       // Reserved
    
23.         EOAC_NONE,                 // Additional capabilities
    
24.         NULL                        // Reserved
    
25.     );
    
26.      // 创建WMI接口
    
27.     IWbemLocator *pLoc = NULL;
    
28.     hres = CoCreateInstance(
    
29.         CLSID_WbemLocator,
    
30.         0,
    
31.         CLSCTX_INPROC_SERVER,
    
32.         IID_IWbemLocator, (LPVOID *)&pLoc);
    
33.      IWbemServices *pSvc = NULL;
    
34.      // 连接到WMI命名空间
    
35.     hres = pLoc->ConnectServer(
    
36.         _bstr_t(L"ROOT\\CIMV2"), // WMI命名空间
    
37.         NULL,                    // 用户名
    
38.         NULL,                    // 密码
    
39.         0,                       // Locale
    
40.         NULL,                    // Security flags
    
41.         0,                       // Authority
    
42.         0,                       // Context object
    
43.         &pSvc                    // IWbemServices代理
    
44.     );
    
45.      // 设置安全级别
    
46.     hres = CoInitializeSecurity(
    
47.         NULL,
    
48.         -1,                          // COM negotiates service
    
49.         NULL,                       // Authentication services
    
50.         NULL,                       // Reserved
    
51.         RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication
    
52.         RPC_C_IMP_LEVEL_IMPERSONATE,// Impersonation
    
53.         NULL,                       // Reserved
    
54.         EOAC_NONE,                 // Additional capabilities
    
55.         NULL                        // Reserved
    
56.     );
    
57.      // 查询CPU信息
    
58.     IEnumWbemClassObject* pEnumerator = NULL;
    
59.     hres = pSvc->ExecQuery(
    
60.         bstr_t("WQL"),
    
61.         bstr_t("SELECT Name, MaxClockSpeed, NumberOfCores FROM Win32_Processor"),
    
62.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
    
63.         NULL,
    
64.         &pEnumerator);
    
65.      IWbemClassObject *pclsObj = NULL;
    
66.     ULONG uReturn = 0;
    
67.      while (pEnumerator) {
    
68.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
    
69.         if (0 == uReturn) {
    
70.             break;
    
71.         }
    
72.          VARIANT vtProp;
    
73.          // 获取CPU名称
    
74.         hr = pclsObj->Get(L"Name", 0, &vtProp, 0, 0);
    
75.         cpuName = _bstr_t(vtProp.bstrVal);
    
76.         VariantClear(&vtProp);
    
77.     }
    
78.      // 清理
    
79.     pSvc->Release();
    
80.     pLoc->Release();
    
81.     pEnumerator->Release();
    
82.     pclsObj->Release();
    
83.     CoUninitialize();
    
84.      return cpuName;
    
85. }
    
86. int GetCPUCores() {
    
87.     int cpuCores = 0;
    
88.     HRESULT hres;
    
89.      // 初始化COM库
    
90.     hres = CoInitializeEx(0, COINIT_MULTITHREADED);
    
91.     if (FAILED(hres)) {
    
92.         return -1;
    
93.     }
    
94.      // 创建WMI接口
    
95.     IWbemLocator *pLoc = NULL;
    
96.     hres = CoCreateInstance(
    
97.         CLSID_WbemLocator,
    
98.         0,
    
99.         CLSCTX_INPROC_SERVER,
    
100.         IID_IWbemLocator, (LPVOID *)&pLoc);
     
101.      IWbemServices *pSvc = NULL;
     
102.      // 连接到WMI命名空间
     
103.     hres = pLoc->ConnectServer(
     
104.         _bstr_t(L"ROOT\\CIMV2"),
     
105.         NULL,                    
     
106.         NULL,                    
     
107.         0,                       
     
108.         NULL,                    
     
109.         0,                       
     
110.         0,                       
     
111.         &pSvc                    
     
112.     );
     
113.      // 查询CPU信息
     
114.     IEnumWbemClassObject* pEnumerator = NULL;
     
115.     hres = pSvc->ExecQuery(
     
116.         bstr_t("WQL"),
     
117.         bstr_t("SELECT NumberOfCores FROM Win32_Processor"),
     
118.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
119.         NULL,
     
120.         &pEnumerator);
     
121.      IWbemClassObject *pclsObj = NULL;
     
122.     ULONG uReturn = 0;
     
123.      while (pEnumerator) {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
     
125.         if (0 == uReturn) {
     
126.             break;
     
127.         }
     
128.          VARIANT vtProp;
     
129.          // 获取CPU核心数
     
130.         hr = pclsObj->Get(L"NumberOfCores", 0, &vtProp, 0, 0);
     
131.         cpuCores = vtProp.uintVal;
     
132.         VariantClear(&vtProp);
     
133.     }
     
134.      // 清理
     
135.     pSvc->Release();
     
136.     pLoc->Release();
     
137.     pEnumerator->Release();
     
138.     pclsObj->Release();
     
139.     CoUninitialize();
     
140.      return cpuCores;
     
141. }
     
142. int GetCPUFrequency() {
     
143.     int cpuFrequency = 0;
     
144.     HRESULT hres;
     
145.      // 初始化COM库
     
146.     hres = CoInitializeEx(0, COINIT_MULTITHREADED);
     
147.     if (FAILED(hres)) {
     
148.         return -1;
     
149.     }
     
150.      // 创建WMI接口
     
151.     IWbemLocator *pLoc = NULL;
     
152.     hres = CoCreateInstance(
     
153.         CLSID_WbemLocator,
     
154.         0,
     
155.         CLSCTX_INPROC_SERVER,
     
156.         IID_IWbemLocator, (LPVOID *)&pLoc);
     
157.      IWbemServices *pSvc = NULL;
     
158.      // 连接到WMI命名空间
     
159.     hres = pLoc->ConnectServer(
     
160.         _bstr_t(L"ROOT\\CIMV2"),
     
161.         NULL,                    
     
162.         NULL,                    
     
163.         0,                       
     
164.         NULL,                    
     
165.         0,                       
     
166.         0,                       
     
167.         &pSvc                    
     
168.     );
     
169.      // 查询CPU信息
     
170.     IEnumWbemClassObject* pEnumerator = NULL;
     
171.     hres = pSvc->ExecQuery(
     
172.         bstr_t("WQL"),
     
173.         bstr_t("SELECT MaxClockSpeed FROM Win32_Processor"),
     
174.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
175.         NULL,
     
176.         &pEnumerator);
     
177.      IWbemClassObject *pclsObj = NULL;
     
178.     ULONG uReturn = 0;
     
179.      while (pEnumerator) {
     
180.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
     
181.         if (0 == uReturn) {
     
182.             break;
     
183.         }
     
184.          VARIANT vtProp;
     
185.          // 获取CPU主频
     
186.         hr = pclsObj->Get(L"MaxClockSpeed", 0, &vtProp, 0, 0);
     
187.         cpuFrequency = vtProp.uintVal;
     
188.         VariantClear(&vtProp);
     
189.     }
     
190.      // 清理
     
191.     pSvc->Release();
     
192.     pLoc->Release();
     
193.     pEnumerator->Release();
     
194.     pclsObj->Release();
     
195.     CoUninitialize();
     
196.      return cpuFrequency;
     
197. }
     
198. int main() {
     
199.     std::string cpuName = GetCPUName();
     
200.     int cpuCores = GetCPUCores();
     
201.     int cpuFrequency = GetCPUFrequency();
     
202.      std::cout << "CPU名称: " << cpuName << std::endl;
     
203.     std::cout << "CPU核心数: " << cpuCores << std::endl;
     
204.     std::cout << "CPU主频: " << cpuFrequency << " MHz" << std::endl;
     
205.      return 0;
     
206. }

复制代码

### 说明：
1. **COM初始化**：使用 `CoInitializeEx` 和 `CoInitializeSecurity` 初始化COM库。
2. **WMI查询**：通过WMI查询获取CPU的信息，包括名称、主频和核心数。
3. **清理资源**：在最后释放WMI接口和COM库。
### 注意事项：
- 确保在项目中链接 `wbemuuid.lib` 库。
- 需要在Windows环境下运行此代码。
- 可能需要以管理员权限运行程序，以便访问WMI信息。