Win32 / C++ 快速获取硬盘分区信息

已于 2025-03-28 17:00:33 修改
阅读量334 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Win32 C++ 硬盘信息 文章标签： Win32 C++ 硬盘信息
于 2025-03-13 19:17:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Flame_Cyclone/article/details/146240004

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;
        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
        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(szFileName), _T(R"(\\.\PhysicalDrive%d)"), nIndex);
            DWORD dwDesiredAccess = GENERIC_READ | GENERIC_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);
            }

            StorageQuery.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.Temperature = 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;
}

C/C++教程 第十三章 —— 制作U盘小偷
余识-
08-05 2792
本文详细介绍了如何使用MFC编写一个U盘文件拷贝程序，涵盖了从监听U盘消息、遍历文件到多线程拷贝的全过程。项目通过创建线程、线程同步及互斥体确保程序稳定运行，同时强调了代码中可能存在的问题和改进点，旨在提升读者的MFC编程实践能力。
C/C++学习笔记
AnChenliang_1002的博客
04-15 1885
函数重载： C++ 允许多个函数拥有相同的名字，只要它们的参数列表不同就可以，这就是函数的重载（Function Overloading）。借助重载，一个函数名可以有多种用途。 参数列表又叫参数签名，包括参数的类型、参数的个数和参数的顺序，只要有一个不同就叫做参数列表不同。 注意，参数列表不同包括参数的个数不同、类型不同或顺序不同，仅仅参数名称不同是不可以的。函数返回值也不能作为重载的依据。 函数的重载的规则： 函数名称必须相同。 参数列表必须不同（个数不同、类型不同、参数排列顺序不同等）。 函数的返回类型
c++获得硬盘信息
09-24
本项目采用vs2010开发，目的是获取本地硬盘的个数，硬盘容量，硬盘上的分区， 以及分区的大小和名称
获取硬盘信息（c++代码实现）
09-13
获取硬盘信息 （c++代码实现）
c语言磁盘信息,C/C++ Windows API——获取磁盘信息
weixin_42166623的博客
05-24 1352
// LogicalDrive.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include //将PULARGE_INTEGER类型的字节(B)数转化为(GB)单位#define GB(x) (x.HighPart << 2) + (x.LowPart >> ...
[c++] 获取磁盘信息(磁盘驱号和内存使用情况）
初阳-.-#的博客
01-10 2588
VS2017 使用Unicode 字符集写的一个例子---获取磁盘标号，大小，使用情况。 GetDriveType 头文件在“winbase.h" 判断一个磁盘驱动器的类型，返回值long，如果不能识别，则返回0.若是指定目录不存在，则返回1，如执行成功，则用下述任何一个常数指定驱动器类型：DRIVE_REMOVABLE， DRIVE_FIXED， DRIVE_REMOTE， DRIVE_...
基于c++，读取windows系统的磁盘信息
smilehjl
05-02 1582
使用c++去读取windows磁盘文件的信息
简易C++程序：获取硬盘的不变序列号
例如，在Windows系统中，可以通过Win32 API中的Disk Management函数或者Setup API函数来获取硬盘的详细信息。在Linux系统中，则可能需要使用诸如sysfs、/proc接口等来访问这些信息。 ### 6. 编程环境搭建和编译过程...
使用VS2005和WINDOWS API开发硬盘分区读取小程序
递归读取硬盘分区的控制台小程序是利用Windows操作系统提供的API函数，通过递归的方式遍历硬盘中的所有分区信息，并在控制台中输出相关信息的一个程序示例。通过这个程序，开发者可以更好地理解和掌握如何在Windows...
用VC源码检测电脑硬盘分区容量的方法
在Windows系统中，可以通过调用Win32 API来获取硬盘分区的容量信息。常用API函数包括GetDiskFreeSpaceEx()，它可以获取指定磁盘驱动器上的可用空间、总空间以及剩余空间。 #### 4. VC程序实现硬盘容量检测 使用VC...
C++获取硬件信息
01-19
代码还有一些问题，，，， 后续再改。 不过对于懂一些C++的人可以自己修正那几个外部宏
C++获取磁盘的信息
miao6664659的专栏
10-31 8853
主要参考了两篇博客 http://www.cnblogs.com/qq78292959/archive/2012/06/12/2546914.html http://blog.youkuaiyun.com/abidepan/article/details/7877329   众所周知，在微软的操作系统下编写应用程序，最主要的还是通过windows所提供的api函数来实现各种操作的，这些函数通常是可以直
C++中获取硬盘ID的方法
最新发布
道亦无名
10-27 333
如果你只是需要唯一地标识一个系统或硬盘，并且不需要非常具体的硬件信息，那么考虑使用其他方法，如生成一个基于系统配置的唯一标识符（如使用UUID库生成一个UUID），或者依赖于操作系统的某些唯一属性（如Windows上的SID或Linux上的某些系统文件内容）。在C++中，直接获取硬盘的ID（通常是硬盘的序列号或唯一标识符）并不是一项简单的任务，因为这通常涉及到低级的硬件访问，这通常是由操作系统或特定的硬件驱动程序管理的。由于直接访问硬盘ID涉及到系统安全和隐私，许多操作系统和硬件制造商都限制了这种访问。
C++获取电脑的各个磁盘盘符及容量信息（附源码）
dvlinker的技术专栏
05-31 1万+
本文详细介绍如何调用系统API函数来获取各个磁盘及容量信息。
C/C++ 实现获取硬盘序列号
优快云
11-16 7084
获取硬盘的序列号、型号和固件版本号，此类功能通常用于做硬盘绑定或硬件验证操作，通过使用。函数与物理硬盘驱动程序进行通信，发送。获取硬盘信息，并输出到控制台。命令来获取硬盘的信息。
windows平台下 c++获取 系统版本 网卡 内存 CPU 硬盘 显卡信息
乌托邦
10-11 2528
GetsysInfo.h： #ifndef _H_GETSYSINFO #define _H_GETSYSINFO #pragma once #include <afxtempl.h> class GetSysInfo { public: GetSysInfo(void); ~GetSysInfo(void); public: /********获取操作系统版本，Service pack版本、系统类型************/ void GetOSVersion(
C++ 硬件信息 获取硬盘序列号
热门推荐
郎涯技术
11-02 2万+
这里介绍的是获取硬盘的序列号，不是获取硬盘分区的序列号。核心是通过DeviceIoControl接口获取硬盘的版本与数据信息，很 简单。 【1】h头文件 //如果编译有问题，添加#include #if !defined(AFX_HDSERIAL_H__1F6D2512_EBA9_4443_9FEF_DE78D7A28AFB__INCLUDED_) #define AFX_HDS
C/C++应用--Window下获取硬件信息（CPU, 硬盘，网卡等）
Anlia_liao的博客
09-28 2509
一、头文件如下： #include <Windows.h> #include <string> #include <iostream> #include <winnt.h> #include <tchar.h> #include <IPHlpApi.h> #pragma comment(lib,...
获取物理磁盘信息的C/C++编程方法
CoderExtra的博客
09-15 466
通过使用C/C++编程语言和操作系统提供的API，我们可以获取物理磁盘的信息。在上述代码中，我们使用了Windows API来实现获取物理磁盘信息的功能。希望本篇文章对你有所帮助！在C/C++编程中，我们可以使用操作系统提供的API来获取物理磁盘的信息。下面将介绍如何使用C/C++编程语言获取物理磁盘的消息，并提供相应的源代码。编译成功后，运行生成的可执行文件，即可获取物理磁盘的信息。接下来，我们可以定义一个函数来获取物理磁盘的信息。现在，我们可以在主函数中调用刚才定义的获取物理磁盘信息的函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值