c++获取Windows的磁盘的指标
我想获取物理磁盘的缓存、转速（仅限机械磁盘），物理磁盘的性能指标：IO延迟、读IO/s、写IO/s、读KB/s、写KB/s、读error/s、写error/s，逻辑磁盘的inode可用、inode使用率的消息（物理磁盘是disk0 disk1这种，逻辑磁盘是C,D,E,F卷这种）
参考另一个问题 https://ask.csdn.net/questions/7976154?spm=1001.2014.3001.5505
#include <windows.h>
#include <iostream>
#include <string>
#include <vector>
// 获取物理磁盘的性能指标
void GetPhysicalDiskPerformance()
{
// 获取物理磁盘的性能计数器
PDH_HQUERY queryHandle;
PDH_HCOUNTER counterHandle;
PdhOpenQuery(NULL, NULL, &queryHandle);
PdhAddCounter(queryHandle, L"\\PhysicalDisk(_Total)\\Avg. Disk sec/Transfer", NULL, &counterHandle);
PdhCollectQueryData(queryHandle);
// 获取性能数据
PDH_FMT_COUNTERVALUE counterValue;
PdhGetFormattedCounterValue(counterHandle, PDH_FMT_DOUBLE, NULL, &counterValue);
// 输出平均磁盘传输时间
std::cout << "Avg. Disk sec/Transfer: " << counterValue.doubleValue << " seconds" << std::endl;
// 清理资源
PdhCloseQuery(queryHandle);
}
// 获取逻辑磁盘的性能指标
void GetLogicalDiskPerformance()
{
// 获取逻辑磁盘的性能计数器
PDH_HQUERY queryHandle;
PDH_HCOUNTER counterHandle;
PdhOpenQuery(NULL, NULL, &queryHandle);
PdhAddCounter(queryHandle, L"\\LogicalDisk(_Total)\\Disk Read Bytes/sec", NULL, &counterHandle);
PdhCollectQueryData(queryHandle);
// 获取性能数据
PDH_FMT_COUNTERVALUE counterValue;
PdhGetFormattedCounterValue(counterHandle, PDH_FMT_LONG, NULL, &counterValue);
// 输出磁盘读取速度
std::cout << "Disk Read Bytes/sec: " << counterValue.longValue << " bytes/sec" << std::endl;
// 清理资源
PdhCloseQuery(queryHandle);
}
int main()
{
// 获取物理磁盘的指标
GetPhysicalDiskPerformance();
// 获取逻辑磁盘的指标
GetLogicalDiskPerformance();
return 0;
}
请注意，要编译和运行上述代码，你需要链接pdh.lib库，并在Windows平台上进行编译。
使用Windows API函数来完成
#include <Windows.h>
#include <iostream>
#include <vector>
#include <TlHelp32.h>
#include<direct.h>
#include<winternl.h>
#include <Psapi.h>
#include <winioctl.h>
#pragma comment(lib,"kernel32.lib")
#pragma comment(lib,"Psapi.lib")
//// 获取物理磁盘的性能指标
//void GetPhysicalDiskPerformance()
//{
// DWORD bufferSize = 0;
// DWORD diskCount = 0;
// std::vector<PERFORMANCE_INFORMATION> performanceInfo;
//
// // 获取磁盘计数
// if (!GetLogicalProcessorInformation(NULL, &bufferSize))
// {
// if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
// {
// SYSTEM_LOGICAL_PROCESSOR_INFORMATION* buffer = reinterpret_cast<SYSTEM_LOGICAL_PROCESSOR_INFORMATION*>(malloc(bufferSize));
// if (GetLogicalProcessorInformation(buffer, &bufferSize))
// {
// DWORD processorInfoSize = bufferSize / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
// for (DWORD i = 0; i < processorInfoSize; i++)
// {
// if (buffer[i].Relationship == RelationDisk)
// {
// diskCount++;
// }
// }
// }
// free(buffer);
// }
// }
//
// // 获取物理磁盘性能信息
// performanceInfo.resize(diskCount);
// if (GetPerformanceInfo(&performanceInfo[0], bufferSize))
// {
// for (DWORD i = 0; i < diskCount; i++)
// {
// std::cout << "Physical Disk " << i + 1 << ":" << std::endl;
// std::cout << " IO延迟: " << performanceInfo[i].ReadTransferCount << std::endl;
// std::cout << " 读IO/s: " << performanceInfo[i].ReadOperationCount << std::endl;
// std::cout << " 写IO/s: " << performanceInfo[i].WriteOperationCount << std::endl;
// std::cout << " 读KB/s: " << performanceInfo[i].ReadTransferCount / 1024 << std::endl;
// std::cout << " 写KB/s: " << performanceInfo[i].WriteTransferCount / 1024 << std::endl;
// std::cout << " 读error/s: " << performanceInfo[i].ReadOperationCount - performanceInfo[i].ReadTransferCount << std::endl;
// std::cout << " 写error/s: " << performanceInfo[i].WriteOperationCount - performanceInfo[i].WriteTransferCount << std::endl;
// }
// }
//}
void GetDiskPerformance()
{
std::vector<char> buffer(MAX_PATH);
// 获取磁盘的性能信息
HANDLE hDevice = CreateFileA("\\\\.\\PhysicalDrive0", 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if (hDevice != INVALID_HANDLE_VALUE)
{
DWORD bytesReturned = 0;
if (DeviceIoControl(hDevice, IOCTL_DISK_PERFORMANCE, NULL, 0, &buffer[0], MAX_PATH, &bytesReturned, NULL))
{
DISK_PERFORMANCE* diskPerformance = reinterpret_cast<DISK_PERFORMANCE*>(&buffer[0]);
std::cout << "磁盘性能:" << std::endl;
std::cout << " 平均读取时间: " << diskPerformance->ReadTime.QuadPart << " ns" << std::endl;
std::cout << " 平均写入时间: " << diskPerformance->WriteTime.QuadPart << " ns" << std::endl;
std::cout << " 读取计数: " << diskPerformance->ReadCount << std::endl;
std::cout << " 写入计数: " << diskPerformance->WriteCount << std::endl;
std::cout << " 读取的字节数: " << diskPerformance->BytesRead.QuadPart << " bytes" << std::endl;
std::cout << " 写入的字节: " << diskPerformance->BytesWritten.QuadPart << " bytes" << std::endl;
//std::cout << " Read Errors: " << diskPerformance->ReadErrors << std::endl;
//std::cout << " Write Errors: " << diskPerformance->WriteErrors << std::endl;
}
CloseHandle(hDevice);
}
}
// 获取逻辑磁盘的性能指标
void GetLogicalDiskPerformance()
{
DWORD bufferSize = 0;
DWORD drives = GetLogicalDrives();
std::vector<char> buffer(MAX_PATH);
// 获取逻辑磁盘的性能信息
for (char drive = 'A'; drive <= 'Z'; drive++)
{
if (drives & (1 << (drive - 'A')))
{
std::string drivePath = std::string("\\\\.\\") + drive + ":";
HANDLE hDevice = CreateFileA(drivePath.c_str(), 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if (hDevice != INVALID_HANDLE_VALUE)
{
DWORD bytesReturned = 0;
if (DeviceIoControl(hDevice, IOCTL_DISK_PERFORMANCE, NULL, 0, &buffer[0], MAX_PATH, &bytesReturned, NULL))
{
DISK_PERFORMANCE* diskPerformance = reinterpret_cast<DISK_PERFORMANCE*>(&buffer[0]);
std::cout << "Logical Disk " << drive << ":" << std::endl;
//std::cout << " Inode可用: " << diskPerformance->FreeInodes.QuadPart << std::endl;
//std::cout << " Inode使用率: " << diskPerformance->TotalInodes.QuadPart - diskPerformance->FreeInodes.QuadPart << std::endl;
}
CloseHandle(hDevice);
}
}
}
}
int main()
{
GetDiskPerformance();
//GetPhysicalDiskPerformance();
GetLogicalDiskPerformance();
return 0;
}
WMI ？
Windows系统的 API函数啊
参考如下案例
#include <iostream>
#include <windows.h>
using namespace std;
int main()
{
int DiskCount = 0;
DWORD DiskInfo = GetLogicalDrives();
//利用GetLogicalDrives()函数可以获取系统中逻辑驱动器的数量，函数返回的是一个32位无符号整型数据。
while(DiskInfo)//通过循环操作查看每一位数据是否为1，如果为1则磁盘为真,如果为0则磁盘不存在。
{
if(DiskInfo&1)//通过位运算的逻辑与操作，判断是否为1
{
++DiskCount;
}
DiskInfo = DiskInfo >> 1;//通过位运算的右移操作保证每循环一次所检查的位置向右移动一位。
//DiskInfo = DiskInfo/2;
}
cout<<"逻辑磁盘数量:"<<DiskCount<<endl;
//-------------------------------------------------------------------
int DSLength = GetLogicalDriveStrings(0,NULL);
//通过GetLogicalDriveStrings()函数获取所有驱动器字符串信息长度。
char* DStr = new char[DSLength];//用获取的长度在堆区创建一个c风格的字符串数组
GetLogicalDriveStrings(DSLength,(LPTSTR)DStr);
//通过GetLogicalDriveStrings将字符串信息复制到堆区数组中,其中保存了所有驱动器的信息。
int DType;
int si=0;
BOOL fResult;
unsigned _int64 i64FreeBytesToCaller;
unsigned _int64 i64TotalBytes;
unsigned _int64 i64FreeBytes;
for(int i=0;i<DSLength/4;++i)
//为了显示每个驱动器的状态，则通过循环输出实现，由于DStr内部保存的数据是A:\NULLB:\NULLC:\NULL，这样的信息，所以DSLength/4可以获得具体大循环范围
{
char dir[3]={DStr[si],':','\\'};
cout<<dir;
DType = GetDriveType(DStr+i*4);
//GetDriveType函数，可以获取驱动器类型，参数为驱动器的根目录
if(DType == DRIVE_FIXED)
{
cout<<"硬盘";
}
else if(DType == DRIVE_CDROM)
{
cout<<"光驱";
}
else if(DType == DRIVE_REMOVABLE)
{
cout<<"可移动式磁盘";
}
else if(DType == DRIVE_REMOTE)
{
cout<<"网络磁盘";
}
else if(DType == DRIVE_RAMDISK)
{
cout<<"虚拟RAM磁盘";
}
else if (DType == DRIVE_UNKNOWN)
{
cout<<"未知设备";
}
fResult = GetDiskFreeSpaceEx (
dir,
(PULARGE_INTEGER)&i64FreeBytesToCaller,
(PULARGE_INTEGER)&i64TotalBytes,
(PULARGE_INTEGER)&i64FreeBytes);
//GetDiskFreeSpaceEx函数，可以获取驱动器磁盘的空间状态,函数返回的是个BOOL类型数据
if(fResult)//通过返回的BOOL数据判断驱动器是否在工作状态
{
cout<<" totalspace:"<<(float)i64TotalBytes/1024/1024<<" MB";//磁盘总容量
cout<<" freespace:"<<(float)i64FreeBytesToCaller/1024/1024<<" MB";//磁盘剩余空间
}
else
{
cout<<" 设备未准备好";
}
cout<<endl;
si+=4;
}
system("pause");
}
要获取物理磁盘和逻辑磁盘的指标，你可以使用Windows的API函数和WMI查询。以下是一个示例代码，展示如何获取一些常用的磁盘指标：
#include <iostream>
#include <windows.h>
#include <wbemidl.h>
// 获取物理磁盘信息
void GetPhysicalDiskInfo()
{
DWORD dwDrives = GetLogicalDrives();
DWORD dwDriveMask = 1;
while (dwDriveMask < 0x80000000) {
if (dwDrives & dwDriveMask) {
char szRootPath[4] = {};
sprintf_s(szRootPath, "%c:\\", 'A' + log2(dwDriveMask));
DISK_PERFORMANCE diskPerformance;
DWORD dwBytesReturned;
HANDLE hDevice = CreateFileA(
szRootPath,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (hDevice == INVALID_HANDLE_VALUE) {
std::cout << "Failed to open the disk." << std::endl;
}
else {
if (DeviceIoControl(
hDevice,
IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
NULL,
0,
&diskPerformance,
sizeof(diskPerformance),
&dwBytesReturned,
NULL))
{
std::cout << "Disk: " << szRootPath << std::endl;
std::cout << "Cache Size: " << diskPerformance.CacheSize.QuadPart << std::endl;
std::cout << "Rotation Speed: " << diskPerformance.RotationRate.QuadPart << std::endl;
// 其他性能指标的获取方法类似
}
else {
std::cout << "Failed to get disk performance." << std::endl;
}
CloseHandle(hDevice);
}
}
dwDriveMask <<= 1;
}
}
// 获取逻辑磁盘信息
void GetLogicalDiskInfo()
{
HRESULT hres;
// COM初始化
hres = CoInitializeEx(0, COINIT_MULTITHREADED);
if (FAILED(hres)) {
std::cout << "Failed to initialize COM library." << std::endl;
return;
}
// 连接WMI
hres = CoInitializeSecurity(
NULL,
-1,
NULL,
NULL,
RPC_C_AUTHN_LEVEL_DEFAULT,
RPC_C_IMP_LEVEL_IMPERSONATE,
NULL,
EOAC_NONE,
NULL
);
if (FAILED(hres)) {
CoUninitialize();
std::cout << "Failed to initialize security." << std::endl;
return;
}
IWbemLocator* pLoc = NULL;
hres = CoCreateInstance(
CLSID_WbemLocator,
0,
CLSCTX_INPROC_SERVER,
IID_IWbemLocator,
(LPVOID*)&pLoc
);
if (FAILED(hres)) {
CoUninitialize();
std::cout << "Failed to create IWbemLocator object." << std::endl;
return;
}
IWbemServices* pSvc = NULL;
// 连接本地WMI提供者
hres = pLoc->ConnectServer(
_bstr_t(L"ROOT\\CIMV2"),
NULL,
NULL,
0,
NULL,
0,
0,
&pSvc
);
if (FAILED(hres)) {
pLoc->Release();
CoUninitialize();
std::cout << "Failed to connect to WMI provider." << std::endl;
return;
}
// 设置安全级别
hres = CoSetProxyBlanket(
pSvc,
RPC_C_AUTHN_WINNT,
RPC_C_AUTHZ_NONE,
NULL,
RPC_C_AUTHN_LEVEL_CALL,
RPC_C_IMP_LEVEL_IMPERSONATE,
NULL,
EOAC_NONE
);
if (FAILED(hres)) {
pSvc->Release();
pLoc->Release();
CoUninitialize();
std::cout << "Failed to set proxy blanket." << std::endl;
return;
}
IEnumWbemClassObject* pEnumerator = NULL;
// 查询逻辑磁盘信息
hres = pSvc->ExecQuery(
bstr_t("WQL"),
bstr_t("SELECT * FROM Win32_LogicalDisk"),
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
NULL,
&pEnumerator
);
if (FAILED(hres)) {
pSvc->Release();
pLoc->Release();
CoUninitialize();
std::cout << "Failed to execute query. Error code: " << hres << std::endl;
return;
}
IWbemClassObject* pclsObj = NULL;
ULONG uReturn = 0;
while (pEnumerator) {
// 获取查询结果
hres = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
if (0 == uReturn)
break;
VARIANT vtProp;
// 获取设备ID
hres = pclsObj->Get(L"DeviceID", 0, &vtProp, 0, 0);
if (SUCCEEDED(hres)) {
std::wstring wsDeviceID(vtProp.bstrVal);
std::wcout << L"Logical Disk: " << wsDeviceID << std::endl;
VariantClear(&vtProp);
// 获取inode可用和使用率等信息
// ...
pclsObj->Release();
}
}
pSvc->Release();
pLoc->Release();
pEnumerator->Release();
CoUninitialize();
}
int main()
{
GetPhysicalDiskInfo();
GetLogicalDiskInfo();
return 0;
}
在上述代码中，GetPhysicalDiskInfo()函数获取物理磁盘的信息，包括缓存大小和转速（仅限机械磁盘）。而GetLogicalDiskInfo()函数通过WMI查询获取逻辑磁盘的信息，你可以根据需求进一步获取inode可用和使用率等信息。
请注意，你需要在项目中引入windows.h和wbemidl.h头文件，并链接wbemuuid.lib库文件。
/* 头文件 */
#include <windows.h>
#include <stdio.h>
/* ************************************
* BOOL GetDiskSpaceInfo(LPCSTR pszDrive
* 功能 根据输入的驱动器，获取磁盘总容量
* 空闲空间、簇数量等磁盘信息
* 参数 驱动器根路径，比如“D:\”。
**************************************/
BOOL GetDiskSpaceInfo(LPCSTR pszDrive)
{
DWORD64 qwFreeBytesToCaller, qwTotalBytes, qwFreeBytes;
DWORD dwSectPerClust, dwBytesPerSect, dwFreeClusters, dwTotalClusters;
BOOL bResult;
//使用GetDiskFreeSpaceEx获取磁盘信息并打印结果
bResult = GetDiskFreeSpaceEx (pszDrive,
(PULARGE_INTEGER)&qwFreeBytesToCaller,
(PULARGE_INTEGER)&qwTotalBytes,
(PULARGE_INTEGER)&qwFreeBytes);
if(bResult)
{
printf("使用GetDiskFreeSpaceEx获取磁盘空间信息\n");
printf("可获得的空闲空间（字节）: \t%I64d\n", qwFreeBytesToCaller);
printf("空闲空间（字节）: \t\t%I64d\n", qwFreeBytes);
printf("磁盘总容量（字节）: \t\t%I64d\n", qwTotalBytes);
}
//使用GetDiskFreeSpace获取磁盘信息并打印结果
bResult = GetDiskFreeSpace (pszDrive,
&dwSectPerClust,
&dwBytesPerSect,
&dwFreeClusters,
&dwTotalClusters);
if(bResult)
{
printf("\n使用GetDiskFreeSpace获取磁盘空间信息\n");
printf("空闲的簇数量 : \t\t\t%d\n",dwFreeClusters);
printf("总簇数量 : \t\t\t%d\n",dwTotalClusters);
printf("每簇的扇区数量 : \t\t%d\n",dwSectPerClust);
printf("每扇区的容量（字节）: \t\t%d\n",dwBytesPerSect);
printf("空闲空间（字节）: \t\t%I64d\n",
(DWORD64)dwFreeClusters*
(DWORD64)dwSectPerClust*(DWORD64)dwBytesPerSect);
printf("磁盘总容量（字节）: \t\t%I64d",
(DWORD64)dwTotalClusters*
(DWORD64)dwSectPerClust*(DWORD64)dwBytesPerSect);
}
return bResult;
}
/* ************************************
* int main( int argc, PCHAR argv[] )
* 功能 应用程序主函数，根据输入参数
* 调用GetDiskSpaceInfo函数获取
* 磁盘空间信息
* 参数 驱动器根路径，比如“D:\”。
**************************************/
int main(int argc, PCHAR argv[])
{
GetDiskSpaceInfo (argv[1]);
}
要获取 Windows 的磁盘指标信息，你可以使用 Windows 提供的性能计数器接口，通过查询相应的性能计数器来获取所需的信息。以下是一些示例代码，展示了如何使用 C++ 和 Windows API 来获取磁盘指标：
#include <iostream>
#include <windows.h>
#include <pdh.h>
#include <pdhmsg.h>
#pragma comment(lib, "pdh.lib")
int main() {
PDH_STATUS status;
HQUERY query;
HCOUNTER counter;
// 打开性能计数器查询
status = PdhOpenQuery(NULL, NULL, &query);
if (status != ERROR_SUCCESS) {
std::cerr << "Failed to open performance counter query: " << status << std::endl;
return 1;
}
// 添加磁盘读取速率计数器
status = PdhAddCounter(query, "\\PhysicalDisk(_Total)\\Disk Reads/sec", NULL, &counter);
if (status != ERROR_SUCCESS) {
std::cerr << "Failed to add disk reads/sec counter: " << status << std::endl;
PdhCloseQuery(query);
return 1;
}
// 设置性能计数器查询更新频率
status = PdhSetQueryTimeInterval(query, 1000); // 1秒更新一次
if (status != ERROR_SUCCESS) {
std::cerr << "Failed to set query time interval: " << status << std::endl;
PdhCloseQuery(query);
return 1;
}
// 查询并显示磁盘读取速率
while (true) {
status = PdhCollectQueryData(query);
if (status != ERROR_SUCCESS) {
std::cerr << "Failed to collect query data: " << status << std::endl;
PdhCloseQuery(query);
return 1;
}
PDH_FMT_COUNTERVALUE value;
status = PdhGetFormattedCounterValue(counter, PDH_FMT_DOUBLE, NULL, &value);
if (status == ERROR_SUCCESS) {
std::cout << "Disk Reads/sec: " << value.doubleValue << std::endl;
} else {
std::cerr << "Failed to get counter value: " << status << std::endl;
}
Sleep(1000); // 等待1秒
}
// 关闭性能计数器查询
PdhCloseQuery(query);
return 0;
}
上述代码演示了如何使用性能计数器查询接口来获取磁盘的读取速率指标。你可以根据需要添加其他性能计数器来获取不同的磁盘指标信息，例如磁盘写入速率、磁盘延迟等。
请注意，上述代码仅提供了获取磁盘指标的基本示例，实际应用中可能需要更多的代码来处理错误、解析和显示其他指标等。此外，还可以通过使用 WMI (Windows Management Instrumentation) 接口来获取更丰富的系统性能信息。
需要特别注意的是，Windows API 和性能计数器的使用可能会因为操作系统版本、权限限制等因素而有所差异，因此你可能需要根据具体的操作系统和应用环境进行调整和适配。
试着写下
以下答案参考newbing,回答由博主波罗歌编写：
要获取Windows的磁盘指标，你可以使用Windows API提供的函数来实现。以下是一个示例代码，可用于获取物理磁盘的缓存、转速以及物理磁盘和逻辑磁盘的性能指标：
#include <iostream>
#include <Windows.h>
#include <tchar.h>
#include <regex>
#include <vector>
// 获取逻辑磁盘信息
void GetLogicalDiskInfo() {
// 获取逻辑磁盘信息
wchar_t drives[256];
DWORD result = GetLogicalDriveStringsW(256, drives);
if (result > 0) {
std::wstring drive(drives);
std::wregex reg(L"(.):\\\\");
std::wsmatch match_result;
std::vector<std::wstring> logicalDrives;
while (std::regex_search(drive, match_result, reg)) {
logicalDrives.push_back(match_result[1]);
drive = match_result.suffix().str();
}
for (const auto& logicalDrive : logicalDrives) {
std::wcout << L"Logical Drive: " << logicalDrive << std::endl;
std::wcout << L"--------------------------" << std::endl;
// 获取逻辑磁盘属性
ULARGE_INTEGER freeBytesAvailable, totalBytes, totalFreeBytes;
BOOL success = GetDiskFreeSpaceExW(logicalDrive.c_str(), &freeBytesAvailable, &totalBytes, &totalFreeBytes);
if (success) {
std::wcout << L"Free space: " << freeBytesAvailable.QuadPart << std::endl;
std::wcout << L"Total space: " << totalBytes.QuadPart << std::endl;
std::wcout << L"Total free space: " << totalFreeBytes.QuadPart << std::endl;
} else {
DWORD error = GetLastError();
std::cout << "Failed to get disk information. Error code: " << error << std::endl;
}
std::wcout << std::endl;
}
} else {
DWORD error = GetLastError();
std::cout << "Failed to get logical drives. Error code: " << error << std::endl;
}
}
// 获取物理磁盘信息
void GetPhysicalDiskInfo() {
// 获取物理磁盘信息
DWORD dwSize;
TCHAR szBuffer[1024] = {0};
DWORD dwResult = 0;
dwResult = GetLogicalDriveStrings(dwSize, NULL);
TCHAR* szDrv = new TCHAR[++dwSize];
dwResult = GetLogicalDriveStrings(dwSize, szDrv);
if (dwResult > 0) {
TCHAR* szSingleDrive = szDrv;
while (*szSingleDrive) {
UINT uDriveType = GetDriveType(szSingleDrive);
if (DRIVE_FIXED == uDriveType || DRIVE_REMOTE == uDriveType) {
// 获取物理磁盘序号
std::string singleDrive = TCHARToString(szSingleDrive);
std::regex reg("\\\\.\\PHYSICALDRIVE(\\d+)");
std::smatch match;
if (regex_search(singleDrive, match, reg)) {
std::string physicalDiskIndex = match[1];
std::cout << "Physical Disk Index: " << physicalDiskIndex << std::endl;
// 获取物理磁盘属性
HANDLE hDevice = CreateFile(TEXT(szSingleDrive), GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if (hDevice != INVALID_HANDLE_VALUE) {
STORAGE_PROPERTY_QUERY query;
DWORD cbBytesReturned = 0;
ZeroMemory(&query, sizeof(query));
query.PropertyId = StorageDeviceProperty;
query.QueryType = PropertyStandardQuery;
STORAGE_DEVICE_DESCRIPTOR deviceDescriptor;
ZeroMemory(&deviceDescriptor, sizeof(deviceDescriptor));
if (DeviceIoControl(hDevice, IOCTL_STORAGE_QUERY_PROPERTY,
&query, sizeof(query),
&deviceDescriptor, sizeof(deviceDescriptor),
&cbBytesReturned, NULL)) {
std::cout << "Buffer Size: " << deviceDescriptor.Size << std::endl;
std::cout << "Device Type: " << deviceDescriptor.DeviceType << std::endl;
std::cout << "Device Characteristics: " << deviceDescriptor.DeviceCharacteristics << std::endl;
}
delete[] szSingleDrive;
CloseHandle(hDevice);
} else {
DWORD error = GetLastError();
std::cout << "Failed to open device. Error code: " << error << std::endl;
}
}
}
szSingleDrive += lstrlen(szSingleDrive) + 1;
}
}
delete[] szDrv;
}
int main() {
GetLogicalDiskInfo();
GetPhysicalDiskInfo();
return 0;
}
如果我的回答解决了您的问题，请采纳！