C / C++ / MFC

LPCWSTR filePath = L"H:";
HANDLE volumeHandle = NULL;
HANDLE driveHandle = NULL;


// Récupère le nom du volume
// Get volume name
TCHAR volumePath[MAX_PATH]; // for expository purposes
bool res = GetVolumePathName(filePath, volumePath, ARRAYSIZE(volumePath));
wprintf(L"%s \n", volumePath);

/*
    Récupère le GUID (ne marche pas si c'est pas un disque dur local) \\?\Volume{guid}\
    Get Guid (doesn't work if it's not a local disk) \\?\Volume{guid}
*/
TCHAR volumeName[MAX_PATH]; // for expository purposes
GetVolumeNameForVolumeMountPoint(volumePath, volumeName, ARRAYSIZE(volumeName));

wprintf(L"%s \n", volumeName);

/* Raymond Chen's notes:
    If you pass that path to the CreateFile function with the trailing backslash intact, then you
    are opening a handle to the root directory of the volume.
    If you pass that path to the CreateFile function with the trailing backslash removed, then you
    are opening a handle to the volume itself.
*/

// In our case, we want to open a handle to the volume itself, so we need to remove that trailing    backslash.The call to CreateFile looks like this:
CString test = volumeName;
test.TrimRight('\\');

LPCWSTR volumeNameWithoutTrailingBackslash = test;

// Handle sur le volume (en retirant le dernier \)
// Handle on volum (by removing last \)
volumeHandle = CreateFile(volumeNameWithoutTrailingBackslash,
    0, /* no special access requested */
    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
    nullptr, /* no custom security */
    OPEN_EXISTING,
    FILE_FLAG_BACKUP_SEMANTICS,
    nullptr); /* template */

// --- Récupération du disque dur physique contenant le volume
// --- Get physical disk containing the volume
/*
    On demande au volume ses disques étendus, en cas de volume installé sur plusieurs disques, la
    première fois va dire la taille de la structure dont on a besoin, et la seconde donnera la
    structure.
    Puisque la plupart des volumes n'ont qu'une bande (voir raid), on peut optimiser légèrement
    pour ce cas par passer un buffer initial assez gros pour contenir une seule bande. Si ça
    fonctionne, c'est qu'il n'y a pas besoin d'essayer une seconde fois.

    Since nearly all volumes have only one extent, we can optimize slightly for that case by
    passing an initial buffer big enough to hold a single extent. If that works, then there’s no
    need to try a second time.

    (Raymond Chen)
*/

VOLUME_DISK_EXTENTS* extents = nullptr;

// Anticipate common case where there is only one extent.
VOLUME_DISK_EXTENTS singleExtent;

// But also have a place to manage allocated data.
std::unique_ptr<BYTE[]> lifetime;

DWORD bytesWritten;
if (DeviceIoControl(volumeHandle, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
    nullptr, 0,
    &singleExtent, sizeof(singleExtent),
    &bytesWritten,
    nullptr))
{
    // Worked on the first try. Use the preallocated buffer.
    extents = &singleExtent;
}
else
{
    VOLUME_DISK_EXTENTS* lastQuery = &singleExtent;
    while (GetLastError() == ERROR_MORE_DATA)
    {
        // Evaluation de la requête
        assert(RTL_CONTAINS_FIELD(lastQuery, bytesWritten, NumberOfDiskExtents));

        DWORD extentCount = lastQuery->NumberOfDiskExtents;
        DWORD allocatedSize = FIELD_OFFSET(VOLUME_DISK_EXTENTS, Extents[extentCount]);
        lifetime.reset(new BYTE[allocatedSize]);
        lastQuery = (VOLUME_DISK_EXTENTS*)lifetime.get();
        if (DeviceIoControl(volumeHandle, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
            nullptr, 0,
            lastQuery, allocatedSize,
            &bytesWritten,
            nullptr)) {
            extents = lastQuery;
            break;
        }
    }
}

/*
    The extents tell you which physical drives the volume draws its storage from, and which bytes
    on those physical drives are devoted to the volume. But for this exercise, we just want the
    physical drives.
 */
if (extents)
{
    // process the extents
    int physicalDriveNumber = extents->Extents->DiskNumber;

    /*
        Once you have the physical drive numbers, you can convert them to physical drive handles by
        building a path of the form \\.\PhysicalDrive# where the # is the decimal expansion of the
        drive number.
    */

    wchar_t physicalDrivePath[80];
    swprintf_s(physicalDrivePath, L"\\\\.\\PhysicalDrive%d", physicalDriveNumber);
    driveHandle = CreateFile(physicalDrivePath,
        0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
        nullptr, OPEN_EXISTING, 0, nullptr);


    STORAGE_PROPERTY_QUERY query{};
    query.PropertyId = StorageAdapterProperty;
    query.QueryType = PropertyStandardQuery;
    DWORD bytesWritten;
    STORAGE_ADAPTER_DESCRIPTOR result{};

    if (DeviceIoControl(driveHandle, IOCTL_STORAGE_QUERY_PROPERTY,
        &query, sizeof(query),
        &result, sizeof(result),
        &bytesWritten, nullptr))
    {
        // type 7 = usb
        printf("Interface type: %d", result.BusType);

    }
}

CloseHandle(volumeHandle);
CloseHandle(driveHandle);

#include<iostream>
using namespace std;
class calculate
{
	private:
                  int x,y;
	public:
	  void input (int p, int q);
	  {
	  	x=p;
	  	y=q;
	  }
           void output()	
	  {
	  	cout<<"In sum=" <<(x+y);
	  	cout<<"In product" <<(x*y);
	  }
};

           main()
           {
         	calculate m;
         	m.input(60,40);
		m.output();
	}