Win32下C++实现快速获取硬盘分区信息

2025-03-14 13:50
文章标签 c++ 实现 快速 获取 信息 win32 硬盘分区

本文主要是介绍Win32下C++实现快速获取硬盘分区信息，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《Win32下C++实现快速获取硬盘分区信息》这篇文章主要为大家详细介绍了Win32下C++如何实现快速获取硬盘分区信息,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下...

实现代码

CDiskDriveUtils.h

#pragma once
 
#include <wtypesbase.h>
#include <string>
#include <tchar.h>
#include <vector>
#include <map>
 
#ifdef _UNICODE
using _tstring = std::wstring;
#else
using _tstring = std::string;
#endif
 
namespace CDiskDriveUtils
{
    enum ePartitionStyle {
        ePartitionMBR,
        ePartitionGPT,
        ePartitionRAW
    };
 
    enum eDriveType
    {
        eDriveUnknown,
        eDriveNoRootDir,
        eDriveRemovable,
        eDriveFixed,
        eDriveRemote,
        eDriveCDROM,
        eDriveRAMdisk
    };
 
    enum eStorageBusType {
        eBusUnknown,
        eBusScsi,
        eBusAtapi,
        eBusAta,
        eBus1394,
        eBusSsa,
        eBusFibre,
        eBusUsb,
        eBusRAID,
        eBusiScsi,
        eBusSas,
        eBusSata,
        eBusSd,
        eBusMmc,
        eBusVirtual,
        eBusFileBackedVirtual,
        eBusSpaces,
        eBusNvme,
        eBusSCM,
        eBusUfs,
        eBusMax,
        eBusMaxReserved = 0x7F
    };
 
    typedef struct _DISK_PARTION_INFO
    {
        _tstring                PathName;
        _tstring                VolumeName;
        uint64_t                StartingOffset;
        uint64_t                PartitionLength;
        uint64_t                FreeBytes;
        uint32_t                PartitionNumber;
        ePartitionStyle         PartitionStyle;
        eDriveType              DriveType;
 
        _DISK_PARTION_INFO() :
            PartitionNumber(0),
            PartitionLength(0),
            StartingOffset(0),
            FreeBytes(0),
            PartitionStyle(ePartitionStyle::ePartitionRAW),
            DriveType(eDriveType::eDriveUnknown)
        {
 
        }
 
    }DISK_PARTION_INFO;
 
    typedef struct _LOGICAL_VOLUME_INFO
    {
        _tstring                PathName;
        _tstring                VolumeName;
        _tstring                FileSystemName;
        uint64_t                StartingOffset;
        uint64_t                ExtentLength;
        uint64_t                FreeBytes;
        uint32_t                DiskNumber;
        eDriveType              DriveType;
 
        _LOGICAL_VOLUME_INFO() :
            DiskNumber(0),
            StartingOffset(0),
            ExtentLength(0),
            FreeBytes(0),
            DriveType(eDriveType::eDriveUnknown)
        {
 
        }
 
    }LOGICAL_VOLUME_INFO;
 
    typedef struct _DISK_INFO
    {
        _tstring                    DevicePath;
        _tstring                    ProductId;
        _tstring                    SerialNumber;
        _tstring                    AdapterSerialNumber;
        _tstring                    ProductRevision;
        _tstring                    BusTypeName;
        uint64_t                    DiskSize;
        uint64_t                    Attributes;
        eStorageBusType             BusType;
        int16_t                     Temperature;
        bool                        fRemovableMedia;
        std::vector<DISK_PARTION_INFO>   Partitions;
 
        _DISK_INFO() :
            Temperature(0),
            BusType(eStorageBusType::eBusUnknown),
            DiskSize(0),
            Attributes(0),
            fRemovableMedia(false)
        {
 
        }
 
    }DISK_DRIVE_INFO;
 
    std::map<uint32_t, DISK_DRIVE_INFO> GetDiskDriveInfos();
    bool GetDiskDriveInfo(dwORD nIndex, DISK_DRIVE_INFO& info);
    bool GetLogicalVolumeInfo(std::vector<LOGICAL_VOLUME_INFO>& vVolumeInfo);
}

CDiskDriveUtils.cpp

#include "CDiskDriveUtils.h"
#include <winioctl.h>
#include <strsafe.h>
#include <cstdint>
 
namespace CDiskDriveUtils
{
    std::string _WStrToMultiStr(UINT CodePage, const std::wstring& str)
    {
        int cbMultiByte = ::WideCharToMultiByte(CodePage, 0, str.c_str(), -1, NULL, 0, NULL, NULL);
        std::string strResult(cbMultiByte, 0);
        size_t nConverted = ::WideCharToMultiByte(CodePage, 0, str.c_str(), (int)str.size(), &strResult[0], (int)strResult.size(), NULL, NULL);
        strResult.resize(nConverted);
        return strResult;
    }
 
    std::wstring _MultiStrToWStr(UINT CodePage, const std::string& str)
    {
        int cchWideChar = ::MultiByteToWideChar(CodePage, 0, str.c_str(), -1, NULL, 0);
        std::wstring strResult(cchWideChar, 0);
        size_t nConverted = ::MultiByteToWideChar(CodePage, 0, str.c_str(), (int)str.size(), &strResult[0], (int)strResult.size());
        strResult.resize(nConverted);
        return strResult;
    }
 
    _tstring WStrToTStr(const std::wstring& str)
    {
#ifdef _UNICODE
      android  return str;
#else
        return _WStrToMultiStr(CP_ACP, str);
#endif
    }
 
    _tstring AStrToTStr(const std::string& str)
    {
#ifdef _UNICODE
        return _MultiStrToWStr(CP_ACP, str);
#else
        return str;
#endif
    }
 
    std::map<uint32_t, DISK_DRIVE_INFO> GetDiskDriveInfos()
    {
        std::map<uint32_t, DISK_DRIVE_INFO> result;
        for (int i = 0; i < 1000; i++)
        {
            DISK_DRIVE_INFO info;
            if (GetDiskDriveInfo(i, info))
            {
                result.emplace(i, info);
            }
        }
 
        return result;
    }
 
    void RemoveBackSpace(_tstring& strName)
    {
        size_t nLength = strName.size();
        for (auto it = strName.crbegin(); it != strName.crend(); it++)
        {
            if (_T(' ') == *it)
            {
                nLength--;
            }
            else
            {
                break;
            }
        }
 
        strName.resize(nLength);
    }
 
    bool GetDiskDriveInfo(DWORD nIndex, DISK_DRIVE_INFO& info)
    {
        TCHAR szFileName[MAX_PATH] = { 0 };
        HANDLE hFile = INVALID_HANDLE_VALUE;
        DWORD dwBytesReturned = 0;
        bool bSuccess = false;
 
        do
        {
            (void)::StringCchPrintf(szFileName, _countof(szFileNameChina编程), _T(R"(\\.\PhysicalDrive%d)"), nIndex);
            DWORD dwDesiredAccess = GENERIC_READ | GENERICwww.chinasem.cn_WRITE;
            DWORD dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
            hFile = ::CreateFile(szFileName, dwDesiredAccess, dwShareMode, NULL, OPEN_EXISTING, 0, NULL);
            if (INVALID_HANDLE_VALUE == hFile)
            {
                break;
            }
 
            STORAGE_PROPERTY_QUERY StorageQuery = { };
            StorageQuery.PropertyId = StorageDeviceProperty;
            StorageQuery.QueryType = PropertyStandardQuery;
            std::vector<uint8_t> OutBuffer(1024 * 64);
 
            info.DevicePath = szFileName;
            if (::DeviceIoControl(hFile, IOCTL_STORAGE_QUERY_PROPERTY, &StorageQuery, sizeof(StorageQuery), OutBuffer.data(), OutBuffer.size(), &dwBytesReturned, NULL))
            {
                PSTORAGE_DEVICE_DESCRIPTOR pDesc = (PSTORAGE_DEVICE_DESCRIPTOR)OutBuffer.data();
                info.ProductId = AStrToTStr((LPCSTR)((LPBYTE)pDesc + pDesc->ProductIdOffset));
                info.ProductRevision = AStrToTStr((LPCSTR)((LPBYTE)pDesc + pDesc->ProductRevisionOffset));
                info.SerialNumber = AStrToTStr((LPCSTR)((LPBYTE)pDesc + pDesc->SerialNumberOffset));
                info.BusType = (eStorageBusType)pDesc->BusType;
                info.fRemovableMedia = pDesc->RemovableMedia;
                RemoveBackSpace(info.ProductId);
            }
 
            StorandroidageQuery.PropertyId = StorageDeviceTemperatureProperty;
            if (::DeviceIoControl(hFile, IOCTL_STORAGE_QUERY_PROPERTY, &StorageQuery, sizeof(StorageQuery), OutBuffer.data(), OutBuffer.size(), &dwBytesReturned, NULL))
            {
                PSTORAGE_TEMPERATURE_DATA_DESCRIPTOR pDesc = (PSTORAGE_TEMPERATURE_DATA_DESCRIPTOR)OutBuffer.data();
                info.Temperatujsre = pDesc->TemperatureInfo->Temperature;
            }
 
            StorageQuery.PropertyId = StorageAdapterSerialNumberProperty;
            if (::DeviceIoControl(hFile, IOCTL_STORAGE_QUERY_PROPERTY, &StorageQuery, sizeof(StorageQuery), OutBuffer.data(), OutBuffer.size(), &dwBytesReturned, NULL))
            {
                PSTORAGE_ADAPTER_SERIAL_NUMBER pDesc = (PSTORAGE_ADAPTER_SERIAL_NUMBER)OutBuffer.data();
                info.AdapterSerialNumber = WStrToTStr(pDesc->SerialNumber);
            }
 
            if (::DeviceIoControl(hFile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, NULL, 0, OutBuffer.data(), OutBuffer.size(), &dwBytesReturned, NULL))
            {
                PDISK_GEOMETRY_EX pDesc = (PDISK_GEOMETRY_EX)OutBuffer.data();
                info.DiskSize = *(unsigned long long*) & pDesc->DiskSize;
            }
 
            if (::DeviceIoControl(hFile, IOCTL_DISK_GET_DRIVE_LAYOUT_EX, NULL, 0, OutBuffer.data(), OutBuffer.size(), &dwBytesReturned, NULL))
            {
                PDRIVE_LAYOUT_INFORMATION_EX pDesc = (PDRIVE_LAYOUT_INFORMATION_EX)OutBuffer.data();
                for (DWORD i = 0; i < pDesc->PartitionCount; i++)
                {
                    PPARTITION_INFORMATION_EX pPartInfo = &pDesc->PartitionEntry[i];
                    if (0 == pPartInfo->PartitionNumber)
                    {
                        continue;
                    }
 
                    DISK_PARTION_INFO partionInfo;
                    partionInfo.PartitionStyle = (ePartitionStyle)pPartInfo->PartitionStyle;
                    partionInfo.PartitionLength = pPartInfo->PartitionLength.QuadPart;
                    partionInfo.PartitionNumber = pPartInfo->PartitionNumber;
                    partionInfo.StartingOffset = pPartInfo->StartingOffset.QuadPart;
                    info.Partitions.push_back(partionInfo);
                }
            }
 
            if (::DeviceIoControl(hFile, IOCTL_DISK_GET_DISK_ATTRIBUTES, NULL, 0, OutBuffer.data(), OutBuffer.size(), &dwBytesReturned, NULL))
            {
                PGET_DISK_ATTRIBUTES pDesc = (PGET_DISK_ATTRIBUTES)OutBuffer.data();
                info.Attributes = pDesc->Attributes;
            }
 
            if (::DeviceIoControl(hFile, IOCTL_DISK_GET_CACHE_INFORMATION, NULL, 0, OutBuffer.data(), OutBuffer.size(), &dwBytesReturned, NULL))
            {
                PDISK_CACHE_INFORMATION pDesc = (PDISK_CACHE_INFORMATION)OutBuffer.data();
                pDesc = (PDISK_CACHE_INFORMATION)OutBuffer.data();
            }
 
            // 从卷信息设置分区信息
            std::vector<LOGICAL_VOLUME_INFO> vVolumeInfo;
            (void)GetLogicalVolumeInfo(vVolumeInfo);
            for (auto& Partition : info.Partitions)
            {
                for (const auto& volume : vVolumeInfo)
                {
                    if (nIndex == volume.DiskNumber && Partition.StartingOffset == volume.StartingOffset)
                    {
                        Partition.PathName = volume.PathName;
                        Partition.VolumeName = volume.VolumeName;
                        Partition.FreeBytes = volume.FreeBytes;
                        Partition.DriveType = volume.DriveType;
                        break;
                    }
                }
            }
 
            bSuccess = true;
 
        } while (false);
 
        if (INVALID_HANDLE_VALUE != hFile)
        {
            ::CloseHandle(hFile);
        }
 
        return bSuccess;
    }
 
    bool GetLogicalVolumeInfo(std::vector<LOGICAL_VOLUME_INFO>& vVolumeInfo)
    {
        CHAR szOutBuffer[1024] = { 0 };
        TCHAR szBuf[MAX_PATH] = { 0 };
        DWORD dwBytesReturned = 0;
 
        if (0 == GetLogicalDriveStrings(_countof(szBuf), szBuf))
        {
            return false;
        }
 
        LPCTSTR lpDriveString = szBuf;
        while (_T('\0') != *lpDriveString)
        {
            TCHAR szDeviceBuf[MAX_PATH] = { 0 };
            HANDLE hDevice = INVALID_HANDLE_VALUE;
 
            ::StringCchCopy(szDeviceBuf, _countof(szDeviceBuf), _T(R"(\\.\)"));
            ::StringCchCatN(szDeviceBuf, _countof(szDeviceBuf), lpDriveString, 2);
            hDevice = ::CreateFile(szDeviceBuf, GENERIC_READ | GENERIC_WRITE,
                FILE_SHARE_READ | FILE_SHARE_WRITE,
                NULL,
                OPEN_EXISTING,
                FILE_FLAG_SEQUENTIAL_SCAN,
                NULL);
 
            if (INVALID_HANDLE_VALUE == hDevice)
            {
                lpDriveString += 4;
                continue;
            }
 
            if (::DeviceIoControl(hDevice,
                IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
                NULL,
                0,
                &szOutBuffer,
                sizeof(szOutBuffer),
                &dwBytesReturned,
                NULL))
            {
                PVOLUME_DISK_EXTENTS pDesc = (PVOLUME_DISK_EXTENTS)szOutBuffer;
 
                //当用户尝试获取有关没有软盘的软盘驱动器或没有光盘的 CD-ROM 驱动器的信息时，
                //系统会显示一个消息框, 防止系统显示此消息框
                (void)::SetErrorMode(SEM_FAILCRITICALERRORS);
 
                //获取卷信息 (卷中的磁盘数可以跨多个磁盘) 。
                for (DWORD i = 0; i < pDesc->NumberOfDiskExtents; i++)
                {
                    PDISK_EXTENT pDiskExtent = &pDesc->Extents[i];
                    TCHAR szVolumeName[MAX_PATH] = { 0 };
                    DWORD dwVolumeSerialNumber = 0;
                    DWORD dwMaximumComponentLength = 0;
                    DWORD dwFileSystemFlags = 0;
                    TCHAR szFileSystemName[MAX_PATH] = { 0 };
                    ::GetVolumeInformation(lpDriveString,
                        szVolumeName,
                        _countof(szVolumeName),
                        &dwVolumeSerialNumber,
                        &dwMaximumComponentLength,
                        &dwFileSystemFlags,
                        szFileSystemName,
                        _countof(szFileSystemName)
                    );
 
 
                    ULARGE_INTEGER FreeBytesAvailableToCaller = { 0 };
                    ULARGE_INTEGER TotalNumberOfBytes = { 0 };
                    ULARGE_INTEGER TotalNumberOfFreeBytes = { 0 };
 
                    GetDiskFreeSpaceEx(lpDriveString, &FreeBytesAvailableToCaller, &TotalNumberOfBytes, &TotalNumberOfFreeBytes);
 
                    LOGICAL_VOLUME_INFO info;
                    info.PathName = _tstring(lpDriveString).substr(0, 2);
                    info.VolumeName = szVolumeName;
                    info.FileSystemName = szFileSystemName;
                    info.DiskNumber = pDiskExtent->DiskNumber;
                    info.StartingOffset = *(unsigned long long*) & pDiskExtent->StartingOffset;
                    info.ExtentLength = *(unsigned long long*) & pDiskExtent->ExtentLength;
                    info.FreeBytes = TotalNumberOfFreeBytes.QuadPart;
 
                    info.DriveType = (eDriveType)::GetDriveType(lpDriveString);
 
                    vVolumeInfo.push_back(info);
                }
            }
 
            ::CloseHandle(hDevice);
            lpDriveString += 4;
        }
 
        return true;
    }
}

main.cpp

#include <locale.h>
#include <tchar.h>
#include "Win32Utils/CDiskDriveUtils.h"
 
int _tmain(int argc, LPCTSTR argv[])
{
    setlocale(LC_ALL, "");
 
    std::map<uint32_t, CDiskDriveUtils::DISK_DRIVE_INFO> diskInfoList = CDiskDriveUtils::GetDiskDriveInfos();
 
    return 0;
}

结果如下

Win32下C++实现快速获取硬盘分区信息

以上就是Win32下C++实现快速获取硬盘分区信息的详细内容，更多关于C++获取硬盘分区信息的资料请关注China编程(www.chinasem.cn)其它相关文章！

这篇关于Win32下C++实现快速获取硬盘分区信息的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1153741。

相关文章

python设置环境变量路径实现过程

python设置环境变量路径实现过程

《python设置环境变量路径实现过程》本文介绍设置Python路径的多种方法：临时设置（Windows用`set`,Linux/macOS用`export`）、永久设置（系统属性或shell配置文件... 目录设置python路径的方法临时设置环境变量（适用于当前会话）永久设置环境变量（Windows系统
阅读更多...
C++11范围for初始化列表auto decltype详解

C++11范围for初始化列表auto decltype详解

《C++11范围for初始化列表autodecltype详解》C++11引入auto类型推导、decltype类型推断、统一列表初始化、范围for循环及智能指针,提升代码简洁性、类型安全与资源管理效... 目录C++11新特性1. 自动类型推导auto1.1 基本语法2. decltype3. 列表初始化3
阅读更多...
C++11右值引用与Lambda表达式的使用

C++11右值引用与Lambda表达式的使用

《C++11右值引用与Lambda表达式的使用》C++11引入右值引用,实现移动语义提升性能,支持资源转移与完美转发；同时引入Lambda表达式,简化匿名函数定义,通过捕获列表和参数列表灵活处理变量... 目录C++11新特性右值引用和移动语义左值 / 右值常见的左值和右值移动语义移动构造函数移动复制运算符
阅读更多...
Python对接支付宝支付之使用AliPay实现的详细操作指南

Python对接支付宝支付之使用AliPay实现的详细操作指南

《Python对接支付宝支付之使用AliPay实现的详细操作指南》支付宝没有提供PythonSDK,但是强大的github就有提供python-alipay-sdk,封装里很多复杂操作,使用这个我们就... 目录一、引言二、准备工作2.1 支付宝开放平台入驻与应用创建2.2 密钥生成与配置2.3 安装ali
阅读更多...
Spring Security 单点登录与自动登录机制的实现原理

Spring Security 单点登录与自动登录机制的实现原理

《SpringSecurity单点登录与自动登录机制的实现原理》本文探讨SpringSecurity实现单点登录（SSO）与自动登录机制,涵盖JWT跨系统认证、RememberMe持久化Token... 目录一、核心概念解析1.1 单点登录（SSO）1.2 自动登录（Remember Me）二、代码分析三、
阅读更多...
Python获取浏览器Cookies的四种方式小结

Python获取浏览器Cookies的四种方式小结

《Python获取浏览器Cookies的四种方式小结》在进行Web应用程序测试和开发时,获取浏览器Cookies是一项重要任务,本文我们介绍四种用Python获取浏览器Cookies的方式,具有一定的... 目录什么是 Cookie？1.使用Selenium库获取浏览器Cookies2.使用浏览器开发者工具
阅读更多...
PyCharm中配置PyQt的实现步骤

PyCharm中配置PyQt的实现步骤

《PyCharm中配置PyQt的实现步骤》PyCharm是JetBrains推出的一款强大的PythonIDE,结合PyQt可以进行pythion高效开发桌面GUI应用程序,本文就来介绍一下PyCha... 目录1. 安装China编程PyQt1.PyQt 核心组件2. 基础 PyQt 应用程序结构3. 使用 Q
阅读更多...
Java获取当前时间String类型和Date类型方式

Java获取当前时间String类型和Date类型方式

《Java获取当前时间String类型和Date类型方式》：本文主要介绍Java获取当前时间String类型和Date类型方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,... 目录Java获取当前时间String和Date类型String类型和Date类型输出结果总结Java获取
阅读更多...
Python实现批量提取BLF文件时间戳

Python实现批量提取BLF文件时间戳

《Python实现批量提取BLF文件时间戳》BLF（BinaryLoggingFormat）作为Vector公司推出的CAN总线数据记录格式,被广泛用于存储车辆通信数据,本文将使用Python轻松提取... 目录一、为什么需要批量处理 BLF 文件二、核心代码解析：从文件遍历到数据导出1. 环境准备与依赖库
阅读更多...
linux下shell脚本启动jar包实现过程

linux下shell脚本启动jar包实现过程

《linux下shell脚本启动jar包实现过程》确保APP_NAME和LOG_FILE位于目录内,首次启动前需手动创建log文件夹,否则报错,此为个人经验,供参考,欢迎支持脚本之家... 目录linux下shell脚本启动jar包样例1样例2总结linux下shell脚本启动jar包样例1#!/bin
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2