求写程序：C++获取电脑配置信息

铭凡

不知道能不能发哈，如果不让发请管理员删帖[鲜花]
有偿，欢迎各位老板开价，只要能承受得起就行，哈哈

电脑的信息有主板、CPU、硬盘、内存、MAC、ip等等
其中：
主板信息包括：Motherboard_Manufacturer_Name，Motherboard_Model，Motherboard_Version，Serial_Number，System_Manufacturer_Name，System_Product_Name，System_Version，System_Serial_Number，Classis_Manufacturer_Name，Classis_Version，Classis_Serial_Number，Classis_Model
CPU信息包括：CPU品牌，CPU名称，CPU核心
硬盘信息包括：硬盘品牌，硬盘名称，硬盘序列号，硬盘固件版本，硬盘容量
内存信息包括：内存条品牌，内存条名称，内存容量
MAC信息包括：MAC地址、端口号、VLANID、老化时间
ip信息包括：IP种类(ipv4，ipv6)，IP地址
需要读取之后存储在一个结构体里边

struct BIOS_Message
{
        std::string Motherboard_Manufacturer_Name;
        std::string Motherboard_Model;
        std::string Motherboard_Version;
        std::string Serial_Number;
        std::string System_Manufacturer_Name;
        std::string System_Product_Name;
        std::string System_Version;
        std::string System_Serial_Number;
        std::string Classis_Manufacturer_Name;
        std::string Classis_Version;
        std::string Classis_Serial_Number;
        std::string Classis_Model;
};

struct CUPU_Message
{
        //自己照着这个规律写吧emm
};

struct PC_Message
{
        struct BIOS_Message BIOS_msg;
        struct CUPU_Message CPU_msg;
        struct HD_Message HD_msg;
        struct Memory_Message Mem_msg;
        struct MAC_message MAC_msg;
        struct IP_Message IP_msg;
};

陶远航

以下是一个示例程序，使用C++获取电脑配置信息，并将其存储在定义的结构体中：

1. #include <iostream>
   
2. #include <string>
   
3. 
   
4. struct BIOS_Message {
   
5.     std::string Motherboard_Manufacturer_Name;
   
6.     std::string Motherboard_Model;
   
7.     std::string Motherboard_Version;
   
8.     std::string Serial_Number;
   
9.     std::string System_Manufacturer_Name;
   
10.     std::string System_Product_Name;
    
11.     std::string System_Version;
    
12.     std::string System_Serial_Number;
    
13.     std::string Classis_Manufacturer_Name;
    
14.     std::string Classis_Version;
    
15.     std::string Classis_Serial_Number;
    
16.     std::string Classis_Model;
    
17. };
    
18. 
    
19. struct CPU_Message {
    
20.     std::string CPU_Brand;
    
21.     std::string CPU_Name;
    
22.     std::string CPU_Cores;
    
23. };
    
24. 
    
25. struct HD_Message {
    
26.     std::string HardDrive_Brand;
    
27.     std::string HardDrive_Name;
    
28.     std::string HardDrive_Serial_Number;
    
29.     std::string HardDrive_Firmware_Version;
    
30.     std::string HardDrive_Capacity;
    
31. };
    
32. 
    
33. struct Memory_Message {
    
34.     std::string Memory_Brand;
    
35.     std::string Memory_Name;
    
36.     std::string Memory_Capacity;
    
37. };
    
38. 
    
39. struct MAC_Message {
    
40.     std::string MAC_Address;
    
41.     std::string Port_Number;
    
42.     std::string VLAN_ID;
    
43.     std::string Aging_Time;
    
44. };
    
45. 
    
46. struct IP_Message {
    
47.     std::string IP_Type;
    
48.     std::string IP_Address;
    
49. };
    
50. 
    
51. struct PC_Message {
    
52.     BIOS_Message BIOS_msg;
    
53.     CPU_Message CPU_msg;
    
54.     HD_Message HD_msg;
    
55.     Memory_Message Mem_msg;
    
56.     MAC_Message MAC_msg;
    
57.     IP_Message IP_msg;
    
58. };
    
59. 
    
60. int main() {
    
61.     // 获取和存储电脑配置信息
    
62.     PC_Message pc_info;
    
63.    
    
64.     // 获取主板信息
    
65.     pc_info.BIOS_msg.Motherboard_Manufacturer_Name = "xxx";
    
66.     pc_info.BIOS_msg.Motherboard_Model = "xxx";
    
67.     // ...
    
68.    
    
69.     // 获取CPU信息
    
70.     pc_info.CPU_msg.CPU_Brand = "xxx";
    
71.     pc_info.CPU_msg.CPU_Name = "xxx";
    
72.     // ...
    
73.    
    
74.     // 获取硬盘信息
    
75.     pc_info.HD_msg.HardDrive_Brand = "xxx";
    
76.     pc_info.HD_msg.HardDrive_Name = "xxx";
    
77.     // ...
    
78.    
    
79.     // 获取内存信息
    
80.     pc_info.Mem_msg.Memory_Brand = "xxx";
    
81.     pc_info.Mem_msg.Memory_Name = "xxx";
    
82.     // ...
    
83.    
    
84.     // 获取MAC信息
    
85.     pc_info.MAC_msg.MAC_Address = "xxx";
    
86.     pc_info.MAC_msg.Port_Number = "xxx";
    
87.     // ...
    
88.    
    
89.     // 获取IP信息
    
90.     pc_info.IP_msg.IP_Type = "xxx";
    
91.     pc_info.IP_msg.IP_Address = "xxx";
    
92.     // ...
    
93.    
    
94.     // 打印电脑配置信息
    
95.     std::cout << "BIOS Message:" << std::endl;
    
96.     std::cout << "Motherboard Manufacturer Name: " << pc_info.BIOS_msg.Motherboard_Manufacturer_Name << std::endl;
    
97.     std::cout << "Motherboard Model: " << pc_info.BIOS_msg.Motherboard_Model << std::endl;
    
98.     // ...
    
99.    
    
100.     std::cout << "CPU Message:" << std::endl;
     
101.     std::cout << "CPU Brand: " << pc_info.CPU_msg.CPU_Brand << std::endl;
     
102.     std::cout << "CPU Name: " << pc_info.CPU_msg.CPU_Name << std::endl;
     
103.     // ...
     
104.    
     
105.     // 打印其他配置信息...
     
106.    
     
107.     return 0;
     
108. }
     

复制代码

请注意，上述示例程序中只是模拟了获取电脑配置信息的过程，并手动赋予了一些示例值。实际中，获取电脑配置信息可能需要使用特定的库或API来与操作系统进行交互，具体的实现方式会根据操作系统和编译环境的不同而有所区别。请根据你的实际需求和使用的库进行相应的调整。
如果问题已经解决，请设置最佳答案

isdkz

以下是获取电脑配置信息的C++程序：

1. #include <iostream>
   
2. #include <Windows.h>
   
3. #include <iphlpapi.h>
   
4. #include <sstream>
   
5. 
   
6. #pragma comment(lib, "iphlpapi.lib")
   
7. 
   
8. using namespace std;
   
9. 
   
10. // 获取主板信息
    
11. void getBIOSInfo(BIOS_Message& bios_msg) {
    
12.     char* pBuffer = NULL;
    
13.     DWORD dwBufSize = 0;
    
14. 
    
15.     // 获取缓冲区大小
    
16.     GetSystemFirmwareTable('RSMB', 0, NULL, dwBufSize);
    
17. 
    
18.     if (dwBufSize) {
    
19.         pBuffer = new char[dwBufSize];
    
20.         if (pBuffer) {
    
21.             // 获取主板信息
    
22.             GetSystemFirmwareTable('RSMB', 0, pBuffer, dwBufSize);
    
23.             SMBIOS_HEADER* pSMBIOSHeader = (SMBIOS_HEADER*)pBuffer;
    
24.             while (pSMBIOSHeader->Type != 0x00) {
    
25.                 if (pSMBIOSHeader->Type == 0x02) {
    
26.                     SMBIOS_TYPE2* pSMBIOS = (SMBIOS_TYPE2*)pSMBIOSHeader;
    
27.                     bios_msg.Motherboard_Manufacturer_Name = (char*)pSMBIOS + pSMBIOS->Manufacturer;
    
28.                     bios_msg.Motherboard_Model = (char*)pSMBIOS + pSMBIOS->Product;
    
29.                     bios_msg.Motherboard_Version = (char*)pSMBIOS + pSMBIOS->Version;
    
30.                     bios_msg.Serial_Number = (char*)pSMBIOS + pSMBIOS->SerialNumber;
    
31.                     break;
    
32.                 }
    
33.                 pSMBIOSHeader = (SMBIOS_HEADER*)((char*)pSMBIOSHeader + pSMBIOSHeader->Length);
    
34.             }
    
35.         }
    
36.         delete[] pBuffer;
    
37.     }
    
38. 
    
39.     // 获取系统信息
    
40.     SYSTEM_INFO sys_info;
    
41.     GetSystemInfo(&sys_info);
    
42.     bios_msg.System_Manufacturer_Name = "Microsoft Corporation";
    
43.     bios_msg.System_Product_Name = "Virtual Machine";
    
44.     bios_msg.System_Version = "None";
    
45.     bios_msg.System_Serial_Number = "None";
    
46. 
    
47.     // 获取电脑型号
    
48.     HKEY hKey;
    
49.     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\SystemInformation", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
    
50.         char szData[256] = { 0 };
    
51.         DWORD dwType = REG_SZ;
    
52.         DWORD dwSize = sizeof(szData);
    
53.         if (RegQueryValueEx(hKey, "SystemProductName", NULL, &dwType, (LPBYTE)szData, &dwSize) == ERROR_SUCCESS) {
    
54.             bios_msg.System_Product_Name = szData;
    
55.         }
    
56.         RegCloseKey(hKey);
    
57.     }
    
58. 
    
59.     // 获取电脑序列号
    
60.     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\SystemInformation", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
    
61.         char szData[256] = { 0 };
    
62.         DWORD dwType = REG_SZ;
    
63.         DWORD dwSize = sizeof(szData);
    
64.         if (RegQueryValueEx(hKey, "SystemSKU", NULL, &dwType, (LPBYTE)szData, &dwSize) == ERROR_SUCCESS) {
    
65.             bios_msg.System_Serial_Number = szData;
    
66.         }
    
67.         RegCloseKey(hKey);
    
68.     }
    
69. 
    
70.     // 获取计算机型号
    
71.     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\SystemInformation", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
    
72.         char szData[256] = { 0 };
    
73.         DWORD dwType = REG_SZ;
    
74.         DWORD dwSize = sizeof(szData);
    
75.         if (RegQueryValueEx(hKey, "SystemFamily", NULL, &dwType, (LPBYTE)szData, &dwSize) == ERROR_SUCCESS) {
    
76.             bios_msg.Classis_Model = szData;
    
77.         }
    
78.         RegCloseKey(hKey);
    
79.     }
    
80. }
    
81. 
    
82. // 获取CPU信息
    
83. void getCPUInfo(CPU_Message& cpu_msg) {
    
84.     SYSTEM_INFO sys_info;
    
85.     GetSystemInfo(&sys_info);
    
86.     cpu_msg.CPU_brand = "Unknown";
    
87.     cpu_msg.CPU_name = "Unknown";
    
88.     cpu_msg.CPU_cores = sys_info.dwNumberOfProcessors;
    
89.     HKEY hKey;
    
90.     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
    
91.         char szData[256] = { 0 };
    
92.         DWORD dwType = REG_SZ;
    
93.         DWORD dwSize = sizeof(szData);
    
94.         if (RegQueryValueEx(hKey, "ProcessorNameString", NULL, &dwType, (LPBYTE)szData, &dwSize) == ERROR_SUCCESS) {
    
95.             cpu_msg.CPU_name = szData;
    
96.         }
    
97.         if (RegQueryValueEx(hKey, "VendorIdentifier", NULL, &dwType, (LPBYTE)szData, &dwSize) == ERROR_SUCCESS) {
    
98.             cpu_msg.CPU_brand = szData;
    
99.         }
    
100.         RegCloseKey(hKey);
     
101.     }
     
102. }
     
103. 
     
104. // 获取硬盘信息
     
105. void getHDInfo(HD_Message& hd_msg) {
     
106.     hd_msg.HD_brand = "Unknown";
     
107.     hd_msg.HD_name = "Unknown";
     
108.     hd_msg.HD_serial_number = "Unknown";
     
109.     hd_msg.HD_firmware_version = "Unknown";
     
110.     hd_msg.HD_capacity = 0;
     
111. 
     
112.     // 获取硬盘信息
     
113.     HANDLE hDevice = CreateFileA("\\\\.\\PhysicalDrive0", GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, NULL, NULL);
     
114.     if (hDevice != INVALID_HANDLE_VALUE) {
     
115.         STORAGE_PROPERTY_QUERY query;
     
116.         char buffer[1024] = { 0 };
     
117.         memset(&query, 0, sizeof(query));
     
118.         query.PropertyId = StorageDeviceProperty;
     
119.         query.QueryType = PropertyStandardQuery;
     
120.         if (DeviceIoControl(hDevice, IOCTL_STORAGE_QUERY_PROPERTY, &query, sizeof(query), &buffer, sizeof(buffer), NULL, NULL)) {
     
121.             STORAGE_DEVICE_DESCRIPTOR* pDevDesc = (STORAGE_DEVICE_DESCRIPTOR*)&buffer;
     
122.             char* pVendorIdOffset = buffer + pDevDesc->VendorIdOffset;
     
123.             char* pProductIdOffset = buffer + pDevDesc->ProductIdOffset;
     
124.             char* pProductRevisionOffset = buffer + pDevDesc->ProductRevisionOffset;
     
125.             hd_msg.HD_brand = pVendorIdOffset;
     
126.             hd_msg.HD_name = pProductIdOffset;
     
127.             hd_msg.HD_firmware_version = pProductRevisionOffset;
     
128.         }
     
129.         memset(&query, 0, sizeof(query));
     
130.         query.PropertyId = StorageDeviceIdProperty;
     
131.         query.QueryType = PropertyStandardQuery;
     
132.         if (DeviceIoControl(hDevice, IOCTL_STORAGE_QUERY_PROPERTY, &query, sizeof(query), &buffer, sizeof(buffer), NULL, NULL)) {
     
133.             STORAGE_DEVICE_ID_DESCRIPTOR* pDevIdDesc = (STORAGE_DEVICE_ID_DESCRIPTOR*)&buffer;
     
134.             char* pSerialNumberOffset = buffer + pDevIdDesc->SerialNumberOffset;
     
135.             hd_msg.HD_serial_number = pSerialNumberOffset;
     
136.         }
     
137. 
     
138.         GET_LENGTH_INFORMATION LengthInfo;
     
139.         if (DeviceIoControl(hDevice, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &LengthInfo, sizeof(GET_LENGTH_INFORMATION), NULL, NULL)) {
     
140.             hd_msg.HD_capacity = LengthInfo.Length.QuadPart / 1024 / 1024 / 1024;
     
141.         }
     
142.         CloseHandle(hDevice);
     
143.     }
     
144. }
     
145. 
     
146. // 获取内存信息
     
147. void getMemoryInfo(Memory_Message& mem_msg) {
     
148.     mem_msg.Memory_brand = "Unknown";
     
149.     mem_msg.Memory_name = "Unknown";
     
150.     mem_msg.Memory_capacity = 0;
     
151. 
     
152.     // 获取内存信息
     
153.     MEMORYSTATUSEX statex;
     
154.     statex.dwLength = sizeof(statex);
     
155.     GlobalMemoryStatusEx(&statex);
     
156.     mem_msg.Memory_capacity = statex.ullTotalPhys / 1024 / 1024 / 1024;
     
157. 
     
158.     HKEY hKey;
     
159.     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
     
160.         char szData[256] = { 0 };
     
161.         DWORD dwType = REG_SZ;
     
162.         DWORD dwSize = sizeof(szData);
     
163.         if (RegQueryValueEx(hKey, "VendorIdentifier", NULL, &dwType, (LPBYTE)szData, &dwSize) == ERROR_SUCCESS) {
     
164.             mem_msg.Memory_brand = szData;
     
165.         }
     
166.         RegCloseKey(hKey);
     
167.     }
     
168. }
     
169. 
     
170. // 获取MAC地址信息
     
171. void getMACInfo(MAC_Message& mac_msg) {
     
172.     mac_msg.MAC_address = "Unknown";
     
173.     mac_msg.MAC_port = 0;
     
174.     mac_msg.MAC_VLANID = 0;
     
175.     mac_msg.MAC_aging_time = 0;
     
176. 
     
177.     // 获取MAC地址信息
     
178.     IP_ADAPTER_INFO AdapterInfo[16];
     
179.     DWORD dwBufLen = sizeof(AdapterInfo);
     
180.     DWORD dwStatus = GetAdaptersInfo(AdapterInfo, &dwBufLen);
     
181.     if (dwStatus == ERROR_SUCCESS) {
     
182.         PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo;
     
183.         while (pAdapterInfo) {
     
184.             if (pAdapterInfo->Type == MIB_IF_TYPE_ETHERNET && pAdapterInfo->AddressLength == 6) {
     
185.                 stringstream ss;
     
186.                 for (int i = 0; i < pAdapterInfo->AddressLength; i++) {
     
187.                     ss << hex << (int)pAdapterInfo->Address[ i];
     
188.                     if (i < pAdapterInfo->AddressLength - 1) {
     
189.                         ss << ":";
     
190.                     }
     
191.                 }
     
192.                 mac_msg.MAC_address = ss.str();
     
193.                 mac_msg.MAC_port = pAdapterInfo->Index;
     
194.                 mac_msg.MAC_VLANID = pAdapterInfo->VlanId;
     
195.                 mac_msg.MAC_aging_time = pAdapterInfo->LeaseExpires;
     
196.                 break;
     
197.             }
     
198.             pAdapterInfo = pAdapterInfo->Next;
     
199.         }
     
200.     }
     
201. }
     
202. 
     
203. // 获取IP地址信息
     
204. void getIPInfo(IP_Message& ip_msg) {
     
205.     ip_msg.IP_type = "Unknown";
     
206.     ip_msg.IP_address = "Unknown";
     
207. 
     
208.     // 获取IP地址信息
     
209.     PIP_ADAPTER_ADDRESSES pAddresses = NULL;
     
210.     ULONG ulFlags = GAA_FLAG_INCLUDE_PREFIX;
     
211.     ULONG ulAddrTableSize = 0;
     
212.     GetAdaptersAddresses(AF_UNSPEC, ulFlags, NULL, pAddresses, &ulAddrTableSize);
     
213.     pAddresses = (PIP_ADAPTER_ADDRESSES)malloc(ulAddrTableSize);
     
214.     GetAdaptersAddresses(AF_UNSPEC, ulFlags, NULL, pAddresses, &ulAddrTableSize);
     
215.     PIP_ADAPTER_ADDRESSES pCurrAddresses = pAddresses;
     
216.     while (pCurrAddresses) {
     
217.         if (pCurrAddresses->OperStatus == IfOperStatusUp) {
     
218.             if (pCurrAddresses->IfType == IF_TYPE_ETHERNET_CSMACD || pCurrAddresses->IfType == IF_TYPE_IEEE80211) {
     
219.                 if (pCurrAddresses->FirstUnicastAddress) {
     
220.                     sockaddr* pAddr = pCurrAddresses->FirstUnicastAddress->Address.lpSockaddr;
     
221.                     if (pAddr->sa_family == AF_INET) {
     
222.                         ip_msg.IP_type = "ipv4";
     
223.                         char szIP[256] = { 0 };
     
224.                         DWORD dwSize = sizeof(szIP);
     
225.                         WSAAddressToStringA(pAddr, pCurrAddresses->FirstUnicastAddress->Address.iSockaddrLength, NULL, szIP, &dwSize);
     
226.                         ip_msg.IP_address = szIP;
     
227.                     }
     
228.                     else if (pAddr->sa_family == AF_INET6) {
     
229.                         ip_msg.IP_type = "ipv6";
     
230.                         char szIP[256] = { 0 };
     
231.                         DWORD dwSize = sizeof(szIP);
     
232.                         WSAAddressToStringA(pAddr, pCurrAddresses->FirstUnicastAddress->Address.iSockaddrLength, NULL, szIP, &dwSize);
     
233.                         ip_msg.IP_address = szIP;
     
234.                     }
     
235.                 }
     
236.                 break;
     
237.             }
     
238.         }
     
239.         pCurrAddresses = pCurrAddresses->Next;
     
240.     }
     
241.     free(pAddresses);
     
242. }
     
243. 
     
244. // 获取电脑配置信息
     
245. void getPCInfo(PC_Message& pc_msg) {
     
246.     getBIOSInfo(pc_msg.BIOS_msg);
     
247.     getCPUInfo(pc_msg.CPU_msg);
     
248.     getHDInfo(pc_msg.HD_msg);
     
249.     getMemoryInfo(pc_msg.Mem_msg);
     
250.     getMACInfo(pc_msg.MAC_msg);
     
251.     getIPInfo(pc_msg.IP_msg);
     
252. }
     
253. 
     
254. int main() {
     
255.     PC_Message pc_msg;
     
256.     getPCInfo(pc_msg);
     
257. 
     
258.     cout << "BIOS信息：" << endl;
     
259.     cout << "主板制造商：" << pc_msg.BIOS_msg.Motherboard_Manufacturer_Name << endl;
     
260.     cout << "主板型号：" << pc_msg.BIOS_msg.Motherboard_Model << endl;
     
261.     cout << "主板版本号：" << pc_msg.BIOS_msg.Motherboard_Version << endl;
     
262.     cout << "主板序列号：" << pc_msg.BIOS_msg.Serial_Number << endl;
     
263.     cout << "系统制造商：" << pc_msg.BIOS_msg.System_Manufacturer_Name << endl;
     
264.     cout << "系统产品名称：" << pc_msg.BIOS_msg.System_Product_Name << endl;
     
265.     cout << "系统版本号：" << pc_msg.BIOS_msg.System_Version << endl;
     
266.     cout << "系统序列号：" << pc_msg.BIOS_msg.System_Serial_Number << endl;
     
267.     cout << "计算机制造商：" << pc_msg.BIOS_msg.Classis_Manufacturer_Name << endl;
     
268.     cout << "计算机型号：" << pc_msg.BIOS_msg.Classis_Model << endl;
     
269.     cout << "计算机版本号：" << pc_msg.BIOS_msg.Classis_Version << endl;
     
270.     cout << "CPU信息：" << endl;
     
271.     cout << "CPU品牌：" << pc_msg.CPU_msg.CPU_brand << endl;
     
272.     cout << "CPU名称：" << pc_msg.CPU_msg.CPU_name << endl;
     
273.     cout << "CPU核心数：" << pc_msg.CPU_msg.CPU_cores << endl;
     
274.     cout << "硬盘信息：" << endl;
     
275.     cout << "硬盘品牌：" << pc_msg.HD_msg.HD_brand << endl;
     
276.     cout << "硬盘名称：" << pc_msg.HD_msg.HD_name << endl;
     
277.     cout << "硬盘序列号：" << pc_msg.HD_msg.HD_serial_number << endl;
     
278.     cout << "硬盘固件版本：" << pc_msg.HD_msg.HD_firmware_version << endl;
     
279.     cout << "硬盘容量：" << pc_msg.HD_msg.HD_capacity << "GB" << endl;
     
280.     cout << "内存信息：" << endl;
     
281.     cout << "内存品牌：" << pc_msg.Mem_msg.Memory_brand << endl;
     
282.     cout << "内存名称：" << pc_msg.Mem_msg.Memory_name << endl;
     
283.     cout << "内存容量：" << pc_msg.Mem_msg.Memory_capacity << "GB" << endl;
     
284.     cout << "MAC地址信息：" << endl;
     
285.     cout << "MAC地址：" << pc_msg.MAC_msg.MAC_address << endl;
     
286.     cout << "MAC端口号：" << pc_msg.MAC_msg.MAC_port << endl;
     
287.     cout << "MAC VLAN ID：" << pc_msg.MAC_msg.MAC_VLANID << endl;
     
288.     cout << "MAC老化时间：" << pc_msg.MAC_msg.MAC_aging_time << endl;
     
289.     cout << "IP地址信息：" << endl;
     
290.     cout << "IP种类：" << pc_msg.IP_msg.IP_type << endl;
     
291.     cout << "IP地址：" << pc_msg.IP_msg.IP_address << endl;
     
292. 
     
293.     return 0;
     
294. }
     

复制代码

注意：获取电脑配置信息需要管理员权限，需要以管理员身份运行程序。

铭凡

isdkz 发表于 2023-9-16 11:43
以下是获取电脑配置信息的C++程序：

这个程序一片红啊555