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

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

本文主要是介绍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。

相关文章

openCV中KNN算法的实现

openCV中KNN算法的实现

《openCV中KNN算法的实现》KNN算法是一种简单且常用的分类算法,本文主要介绍了openCV中KNN算法的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的... 目录KNN算法流程使用OpenCV实现KNNOpenCV 是一个开源的跨平台计算机视觉库，它提供了各
阅读更多...
OpenCV图像形态学的实现

OpenCV图像形态学的实现

《OpenCV图像形态学的实现》本文主要介绍了OpenCV图像形态学的实现,包括腐蚀、膨胀、开运算、闭运算、梯度运算、顶帽运算和黑帽运算,文中通过示例代码介绍的非常详细,需要的朋友们下面随着小编来一起... 目录一、图像形态学简介二、腐蚀（Erosion）1. 原理2. OpenCV 实现三、膨胀China编程（
阅读更多...
通过Spring层面进行事务回滚的实现

通过Spring层面进行事务回滚的实现

《通过Spring层面进行事务回滚的实现》本文主要介绍了通过Spring层面进行事务回滚的实现,包括声明式事务和编程式事务,具有一定的参考价值,感兴趣的可以了解一下... 目录声明式事务回滚：1. 基础注解配置2. 指定回滚异常类型3. ​不回滚特殊场景编程式事务回滚：1. ​使用 TransactionT
阅读更多...
Android实现打开本地pdf文件的两种方式

Android实现打开本地pdf文件的两种方式

《Android实现打开本地pdf文件的两种方式》在现代应用中,PDF格式因其跨平台、稳定性好、展示内容一致等特点,在Android平台上,如何高效地打开本地PDF文件,不仅关系到用户体验,也直接影响... 目录一、项目概述二、相关知识2.1 PDF文件基本概述2.2 android 文件访问与存储权限2.
阅读更多...
使用Python实现全能手机虚拟键盘的示例代码

使用Python实现全能手机虚拟键盘的示例代码

《使用Python实现全能手机虚拟键盘的示例代码》在数字化办公时代,你是否遇到过这样的场景：会议室投影电脑突然键盘失灵、躺在沙发上想远程控制书房电脑、或者需要给长辈远程协助操作？今天我要分享的Pyth... 目录一、项目概述：不止于键盘的远程控制方案1.1 创新价值1.2 技术栈全景二、需求实现步骤一、需求
阅读更多...
Spring Shell 命令行实现交互式Shell应用开发

Spring Shell 命令行实现交互式Shell应用开发

《SpringShell命令行实现交互式Shell应用开发》本文主要介绍了SpringShell命令行实现交互式Shell应用开发,能够帮助开发者快速构建功能丰富的命令行应用程序,具有一定的参考价... 目录引言一、Spring Shell概述二、创建命令类三、命令参数处理四、命令分组与帮助系统五、自定义S
阅读更多...
SpringBatch数据写入实现

SpringBatch数据写入实现

《SpringBatch数据写入实现》SpringBatch通过ItemWriter接口及其丰富的实现,提供了强大的数据写入能力,本文主要介绍了SpringBatch数据写入实现,具有一定的参考价值,... 目录python引言一、ItemWriter核心概念二、数据库写入实现三、文件写入实现四、多目标写入
阅读更多...
Android Studio 配置国内镜像源的实现步骤

Android Studio 配置国内镜像源的实现步骤

《AndroidStudio配置国内镜像源的实现步骤》本文主要介绍了AndroidStudio配置国内镜像源的实现步骤,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,... 目录一、修改 hosts，解决 SDK 下载失败的问题二、修改 gradle 地址，解决 gradle
阅读更多...
SpringSecurity JWT基于令牌的无状态认证实现

SpringSecurity JWT基于令牌的无状态认证实现

《SpringSecurityJWT基于令牌的无状态认证实现》SpringSecurity中实现基于JWT的无状态认证是一种常见的做法,本文就来介绍一下SpringSecurityJWT基于令牌的无... 目录引言一、JWT基本原理与结构二、Spring Security JWT依赖配置三、JWT令牌生成与
阅读更多...
C++ vector的常见用法超详细讲解

C++ vector的常见用法超详细讲解

《C++vector的常见用法超详细讲解》：本文主要介绍C++vector的常见用法,包括C++中vector容器的定义、初始化方法、访问元素、常用函数及其时间复杂度,通过代码介绍的非常详细,... 目录1、vector的定义2、vector常用初始化方法1、使编程用花括号直接赋值2、使用圆括号赋值3、ve
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2