Comment afficher la liste des disques physiques?

WMIC

wmic est un outil très complet

wmic diskdrive list

fournir une (trop) la liste détaillée, par exemple

pour moins d'infos

wmic diskdrive list brief 

C

Sebastian Godelet mentionne dans les commentaires:

Dans C:

system("wmic diskdrive list");

Comme indiqué, vous pouvez également appeler la WinAPI, mais... comme indiqué dans "Comment obtenir des données à partir de WMI à l'aide d'une Application C?", c'est assez complexe (et généralement fait avec C++, pas du C).

PowerShell

Ou avec PowerShell:

Get-WmiObject Win32_DiskDrive

Cela pourrait être de 5 ans trop tard :). Mais comme je ne vois pas de réponse à cette question encore, l'ajout de cette.

Nous pouvons utiliser Configuration Api pour obtenir la liste des disques c'est à dire., des appareils dans le système de la mise en œuvre de GUID_DEVINTERFACE_DISK.

Une fois que nous avons de leurs chemins d'accès de périphériques, nous pouvons émettre IOCTL_STORAGE_GET_DEVICE_NUMBER de construire "\\.\PHYSICALDRIVE%d" avec STORAGE_DEVICE_NUMBER.DeviceNumber

Voir aussi SetupDiGetClassDevs function

#include <Windows.h>
#include <Setupapi.h>
#include <Ntddstor.h>
#pragma comment( lib, "setupapi.lib" )
#include <iostream>
#include <string>
using namespace std;
#define START_ERROR_CHK()           \
DWORD error = ERROR_SUCCESS;    \
DWORD failedLine;               \
string failedApi;
#define CHK( expr, api )            \
if ( !( expr ) ) {              \
error = GetLastError( );    \
failedLine = __LINE__;      \
failedApi = ( api );        \
goto Error_Exit;            \
}
#define END_ERROR_CHK()             \
error = ERROR_SUCCESS;          \
Error_Exit:                     \
if ( ERROR_SUCCESS != error ) { \
cout << failedApi << " failed at " << failedLine << " : Error Code - " << error << endl;    \
}
int main( int argc, char **argv ) {
HDEVINFO diskClassDevices;
GUID diskClassDeviceInterfaceGuid = GUID_DEVINTERFACE_DISK;
SP_DEVICE_INTERFACE_DATA deviceInterfaceData;
PSP_DEVICE_INTERFACE_DETAIL_DATA deviceInterfaceDetailData;
DWORD requiredSize;
DWORD deviceIndex;
HANDLE disk = INVALID_HANDLE_VALUE;
STORAGE_DEVICE_NUMBER diskNumber;
DWORD bytesReturned;
START_ERROR_CHK();
//
//Get the handle to the device information set for installed
//disk class devices. Returns only devices that are currently
//present in the system and have an enabled disk device
//interface.
//
diskClassDevices = SetupDiGetClassDevs( &diskClassDeviceInterfaceGuid,
NULL,
NULL,
DIGCF_PRESENT |
DIGCF_DEVICEINTERFACE );
CHK( INVALID_HANDLE_VALUE != diskClassDevices,
"SetupDiGetClassDevs" );
ZeroMemory( &deviceInterfaceData, sizeof( SP_DEVICE_INTERFACE_DATA ) );
deviceInterfaceData.cbSize = sizeof( SP_DEVICE_INTERFACE_DATA );
deviceIndex = 0;
while ( SetupDiEnumDeviceInterfaces( diskClassDevices,
NULL,
&diskClassDeviceInterfaceGuid,
deviceIndex,
&deviceInterfaceData ) ) {
++deviceIndex;
SetupDiGetDeviceInterfaceDetail( diskClassDevices,
&deviceInterfaceData,
NULL,
0,
&requiredSize,
NULL );
CHK( ERROR_INSUFFICIENT_BUFFER == GetLastError( ),
"SetupDiGetDeviceInterfaceDetail - 1" );
deviceInterfaceDetailData = ( PSP_DEVICE_INTERFACE_DETAIL_DATA ) malloc( requiredSize );
CHK( NULL != deviceInterfaceDetailData,
"malloc" );
ZeroMemory( deviceInterfaceDetailData, requiredSize );
deviceInterfaceDetailData->cbSize = sizeof( SP_DEVICE_INTERFACE_DETAIL_DATA );
CHK( SetupDiGetDeviceInterfaceDetail( diskClassDevices,
&deviceInterfaceData,
deviceInterfaceDetailData,
requiredSize,
NULL,
NULL ),
"SetupDiGetDeviceInterfaceDetail - 2" );
disk = CreateFile( deviceInterfaceDetailData->DevicePath,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL );
CHK( INVALID_HANDLE_VALUE != disk,
"CreateFile" );
CHK( DeviceIoControl( disk,
IOCTL_STORAGE_GET_DEVICE_NUMBER,
NULL,
0,
&diskNumber,
sizeof( STORAGE_DEVICE_NUMBER ),
&bytesReturned,
NULL ),
"IOCTL_STORAGE_GET_DEVICE_NUMBER" );
CloseHandle( disk );
disk = INVALID_HANDLE_VALUE;
cout << deviceInterfaceDetailData->DevicePath << endl;
cout << "\\\\?\\PhysicalDrive" << diskNumber.DeviceNumber << endl;
cout << endl;
}
CHK( ERROR_NO_MORE_ITEMS == GetLastError( ),
"SetupDiEnumDeviceInterfaces" );
END_ERROR_CHK();
Exit:
if ( INVALID_HANDLE_VALUE != diskClassDevices ) {
SetupDiDestroyDeviceInfoList( diskClassDevices );
}
if ( INVALID_HANDLE_VALUE != disk ) {
CloseHandle( disk );
}
return error;
}

J'ai modifié un programme open-source appelé "dskwipe" afin de tirer de cette information sur le disque hors de lui. Dskwipe est écrit en C, et vous pouvez tirer de cette fonction en dehors de ça. Le binaire et source sont disponibles ici: dskwipe 0.3 a été publié

Les informations renvoyées ressembler à quelque chose comme ceci:

Device Name                         Size Type      Partition Type
------------------------------ --------- --------- --------------------
\\.\PhysicalDrive0               40.0 GB Fixed
\\.\PhysicalDrive1               80.0 GB Fixed
\Device\Harddisk0\Partition0     40.0 GB Fixed
\Device\Harddisk0\Partition1     40.0 GB Fixed     NTFS
\Device\Harddisk1\Partition0     80.0 GB Fixed
\Device\Harddisk1\Partition1     80.0 GB Fixed     NTFS
\\.\C:                           80.0 GB Fixed     NTFS
\\.\D:                            2.1 GB Fixed     FAT32
\\.\E:                           40.0 GB Fixed     NTFS

GetLogicalDrives() énumère tous les montées des partitions de disque, pas disques physiques.

Vous pouvez énumérer les lettres de lecteur avec (ou sans) GetLogicalDrives, puis d'appeler QueryDosDevice() pour trouver le disque physique qui la lettre est associé.

Alternativement, vous pouvez décoder les informations contenues dans le registre sous la clé HKEY_LOCAL_MACHINE\SYSTEM\MountedDevices. Les données binaires codages il ne sont pas évidentes, cependant. Si vous avez une copie de Russinovich et Salomon, le livre de Microsoft Windows Internals, cette ruche de registre est discuté dans le Chapitre 10.

Thique commande WMIC combinaison fonctionne très bien:

wmic volume list brief

Je viens de tomber sur ça dans mon Lecteur de flux RSS aujourd'hui. J'ai une solution de nettoyage pour vous. Cet exemple est en Delphi, mais peuvent très facilement être converti en C/C++ (pour Win32).

Requête tous les noms de valeur à partir de l'emplacement de registre suivant:
HKLM\SYSTEM\MountedDevices

Un par un, les passer à la fonction suivante et vous sera restitué le nom de l'appareil. Assez propre et simple! J'ai trouvé ce code sur un blog ici.

function VolumeNameToDeviceName(const VolName: String): String;
var
s: String;
TargetPath: Array[0..MAX_PATH] of WideChar;
bSucceeded: Boolean;
begin
Result := ”;
//VolumeName has a format like this: \\?\Volume{c4ee0265-bada-11dd-9cd5-806e6f6e6963}\
//We need to strip this to Volume{c4ee0265-bada-11dd-9cd5-806e6f6e6963}
s :=  Copy(VolName, 5, Length(VolName) - 5);
bSucceeded := QueryDosDeviceW(PWideChar(WideString(s)), TargetPath, MAX_PATH) <> 0;
if bSucceeded then
begin
Result := TargetPath;
end
else begin
//raise exception
end;
end;

Ici est un nouveau solution de le faire avec faire des appels WMI.

Alors tout ce que vous devez faire est de simplement appeler :

queryAndPrintResult(L"SELECT * FROM Win32_DiskDrive", L"Name");