windows下初始化格式化磁盘

最新推荐文章于 2024-05-20 13:02:56 发布
最新推荐文章于 2024-05-20 13:02:56 发布
阅读量1.1w 收藏 10
点赞数
分类专栏： c++ 文章标签： windows 格式化 磁盘

新买来的硬盘是未初始化的，以我的理解就是没有引导扇区的，通常是没有MBR，如下图磁盘1，右边有大小，但显示“未分配”，

左边显示“没有初始化”， 点鼠标右键就可以【初始化磁盘】。


初始化时可以选择MBR和GPT， MBR方式顶多支持2T硬盘的。

初始化后


初始化后可以新建简单卷了，之前是不行的：



CreateDisk(1, 3) 就是把磁盘1分为3个分区



奇怪，如果只分1个区，就是自动以NTFS格式化掉， 而分3个区，还会提示是否格式化。


如果想回到刚买回来的空白状态怎么办呢？ 用DestroyDisk()就可以了


代码： 

CPP：CMDiskManager.cpp

#include "stdafx.h"
#include "CMDiskManager.h"

CMDiskManager::CMDiskManager(){}

//获取磁盘大小,单位是MB
int CMDiskManager::GetDiskSize(DWORD vDiskNo)
{
	HANDLE hDevice;               // handle to the drive to be examined 
	BOOL bResult;                 // results flag
	DWORD junk;                   // discard results

	char diskPath[256];				//磁盘内部路径
	//生成磁盘内部路径
	sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);

	hDevice = CreateFile(TEXT(diskPath),  // drive 或者 用"\\\\.\\PhysicalDrive0"  代表第一块磁盘
		GENERIC_READ,                // no access to the drive
		FILE_SHARE_READ | // share mode
		FILE_SHARE_WRITE,
		NULL,             // default security attributes
		OPEN_EXISTING,    // disposition
		0,                // file attributes
		NULL);            // do not copy file attributes

	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
	{
		return (FALSE);
	}
	
	GET_LENGTH_INFORMATION pdg;
	bResult = DeviceIoControl(hDevice,  // device to be queried
		IOCTL_DISK_GET_LENGTH_INFO,  // operation to perform
		NULL, 0, // no input buffer
		&pdg, sizeof(pdg),     // output buffer
		&junk,                 // # bytes returned
		(LPOVERLAPPED)NULL);  // synchronous I/O

	CloseHandle(hDevice);

/*	INT64 nUseSize = disk_len.Length.QuadPart;
	INT64 sizeGB = nUseSize / 1014 / 1024 / 1024;
	CString szSize;
	szSize.Format(L"C盘大小 %I64d GB", sizeGB);
	*/
	int MB = pdg.Length.QuadPart >> 20;
	//CString s; 
	//s.Format("C盘大小 %f GB", MB/1024.0);
	//AfxMessageBox(s, 0, MB_OK);  
	//float x = (float) MB ;
	return MB  ;
}


/*
获取磁盘分区个数
vDiskNo:磁盘序号
*/
int CMDiskManager::GetPartNum(DWORD vDiskNo)
{
	char diskPath[256];				//磁盘内部路径
	//生成磁盘内部路径
	sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);
	HANDLE hDevice;               //硬盘句柄 handle to the drive to be examined
	BOOL result;                  //结果标志 results flag
	DWORD readed;                 // discard results

	hDevice = CreateFile(
		diskPath,
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,           //default security attributes  
		OPEN_EXISTING, // disposition  
		0,              // file attributes  
		NULL
		);
	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
	{
		fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());
		return int(-1);
	}

	DRIVE_LAYOUT_INFORMATION_EX* dl;
	DWORD tSize = 0x4000; // sizeof(DRIVE_LAYOUT_INFORMATION_EX) * 10;
	dl = (DRIVE_LAYOUT_INFORMATION_EX*)malloc(tSize);
	if (NULL == dl)
	{
		(void)CloseHandle(hDevice);
		return (int)-2;
	}

	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
		NULL,
		0,
		dl,
		tSize,
		&readed,
		NULL
		);

	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_GET_DRIVE_LAYOUT_EX Error: %ld\n", GetLastError());
		(void)CloseHandle(hDevice);
		return int(-3);
	}

	CString tPartitionStyle = "RAW";
	switch (dl->PartitionStyle){
	case 0:
		tPartitionStyle = "MBR";
		break;
	case 1:
		tPartitionStyle = "GPT";
		break;
	}

	//printf("dl->PartitionCount = %d", dl->PartitionCount);
	TRACE("dl->PartitionCount = %d, tPartitionStyle:%s \n", dl->PartitionCount, tPartitionStyle.GetBuffer());

	//printf("dl->PartitionCount = %d", dl->PartitionCount);
	int tRet = dl->PartitionCount/4;
	//TRACE("dl->PartitionCount tRet = %d", tRet);

	free(dl);
	(void)CloseHandle(hDevice);

	return tRet;
}

//读MBR信息
BOOL CMDiskManager::ReadMBR(int vDiskNo, LPVOID *pBuffer)
{
	HANDLE hDevice;
	DWORD dwSize;
	DWORD dwOverRead;
	BOOL bRet = TRUE;
	char diskPath[256];				//磁盘内部路径
	//生成磁盘内部路径
	sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);

	hDevice = CreateFile(TEXT(diskPath),
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,
		OPEN_EXISTING,
		0,
		NULL);
	if (hDevice == INVALID_HANDLE_VALUE) {
		TRACE("Open \\\\.\\PhysicalDrive failed. Error=%u\n", GetLastError());
		return FALSE;
	}

	if (!DeviceIoControl(hDevice, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0, &dwSize, NULL)) {
		CloseHandle(hDevice);
		TRACE("FSCTL_LOCK_VOLUME \\\\.\\PhysicalDrive0 failed. Error=%u\n", GetLastError());
		return FALSE;
	}

	DISK_GEOMETRY Geometry;
	if (!DeviceIoControl(hDevice, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &Geometry, sizeof(DISK_GEOMETRY), &dwSize, NULL)) {
		bRet = FALSE;
		TRACE("IOCTL_DISK_GET_DRIVE_GEOMETRY \\\\.\\PhysicalDrive0 failed. Error=%u\n", GetLastError());
		goto _out;
	}

	*pBuffer = (LPVOID)GlobalAlloc(GPTR, Geometry.BytesPerSector);
	if (*pBuffer) {
		if (!ReadFile(hDevice, *pBuffer, Geometry.BytesPerSector, &dwOverRead, NULL)) {
			printf("ReadFile \\\\.\\PhysicalDrive %u bytes failed. Error=%u\n", Geometry.BytesPerSector, GetLastError());
			bRet = FALSE;
		}
	}

_out:
	DeviceIoControl(hDevice, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0, &dwSize, NULL);
	CloseHandle(hDevice);
	return bRet;

}


/*
获取磁盘分区信息
vDiskNo:磁盘序号
*/
DWORD CMDiskManager::GetLayoutInfo(DWORD vDiskNo)
{
	char diskPath[256];				//磁盘内部路径
	//生成磁盘内部路径
	sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);
	HANDLE hDevice;               //硬盘句柄 handle to the drive to be examined
	BOOL result;                  //结果标志 results flag
	DWORD readed;                 // discard results
	  
	hDevice = CreateFile(
		diskPath,
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,           //default security attributes  
		OPEN_EXISTING, // disposition  
		0,              // file attributes  
		NULL
		);
	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
	{
		fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());
		return DWORD(-1);
	}

	DRIVE_LAYOUT_INFORMATION_EX* dl;
	DWORD tSize = 0x4000; // sizeof(DRIVE_LAYOUT_INFORMATION_EX) * 10;
	dl = (DRIVE_LAYOUT_INFORMATION_EX*)malloc(tSize);
	if (NULL == dl)
	{
		(void)CloseHandle(hDevice);
		return (WORD)-1;
	}

	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
		NULL,
		0,
		dl,
		tSize,
		&readed,
		NULL
		);

	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_GET_DRIVE_LAYOUT_EX Error: %ld\n", GetLastError());
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	CString tPartitionStyle = "RAW";
	switch (dl->PartitionStyle){
	case 0:	
		tPartitionStyle = "MBR";
		break; 
	case 1:
		tPartitionStyle = "GPT";
		break;
	}

	//printf("dl->PartitionCount = %d", dl->PartitionCount);
	TRACE("dl->PartitionCount = %d, tPartitionStyle:%s", dl->PartitionCount, tPartitionStyle.GetBuffer());

	free(dl);
	(void)CloseHandle(hDevice);

	return 0;
}

/*
初始化磁盘，创建分区
vDiskNo:磁盘序号，千万要避开系统盘，系统盘一般是0
vPartNum:分区数，只要1个分区就可以了
*/
DWORD CMDiskManager::CreateDisk(DWORD vDiskNo, WORD vPartNum)
{
	printf("准备CreateDisk, vDiskNo=%d, vPartNum=%d \n", vDiskNo, vPartNum);

	//第0块磁盘是系统盘，不能格式化掉！！！但不排除某些情况下新插入的移动硬盘会是第0块磁盘
	if (0 == vDiskNo){
		printf("第0块磁盘是系统盘，不能格式化掉\n");
		return 0;
	}

	HANDLE hDevice;               //硬盘句柄 handle to the drive to be examined
	BOOL result;                  //结果标志 results flag
	DWORD readed;                 // discard results
	DWORD ret;
	WORD i;
	char diskPath[256];				//磁盘内部路径
	DISK_GEOMETRY pdg;
	DWORD sectorSize;			//扇区大小
	DWORD signature;			//签名
	LARGE_INTEGER diskSize;		//磁盘大小
	LARGE_INTEGER partSize;		//分区大小
	BYTE actualPartNum;			//实际上的分区数

	DWORD layoutStructSize;		//
	DRIVE_LAYOUT_INFORMATION_EX *dl;	//磁盘分区信息
	CREATE_DISK newDisk;		//创建磁盘（初始化？）

	//生成磁盘内部路径
	sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);

	actualPartNum = 4;
	if (vPartNum > actualPartNum)
	{
		printf("vPartNum > 4\n");
		return (WORD)-1;
	}

	hDevice = CreateFile(
		diskPath,
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,           //default security attributes  
		OPEN_EXISTING, // disposition  
		0,              // file attributes  
		NULL
		);
	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
	{
		fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());
		return DWORD(-1);
	}

	// Create primary partition MBR
	//创建主分区的MBR
	printf("创建主分区的MBR\n");

	newDisk.PartitionStyle = PARTITION_STYLE_MBR;
	signature = (DWORD)time(0);     // 原为time(NULL),   get signature from current time
	newDisk.Mbr.Signature = signature;

	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_CREATE_DISK,
		&newDisk,
		sizeof(CREATE_DISK),
		NULL,
		0,
		&readed,
		NULL
		);
	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_CREATE_DISK Error: %ld\n", GetLastError());
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	//fresh the partition table
	//刷新分区表
	printf("刷新分区表\n");
	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_UPDATE_PROPERTIES,
		NULL,
		0,
		NULL,
		0,
		&readed,
		NULL
		);
	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_UPDATE_PROPERTIES Error: %ld\n", GetLastError());
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	//Now create the partitions
	//现在创建分区
	ret = GetDriveGeometry(vDiskNo, &pdg);
	if ((DWORD)-1 == ret)
	{
		return ret;
	}

	//扇区大小
	sectorSize = pdg.BytesPerSector;
	diskSize.QuadPart = pdg.Cylinders.QuadPart * pdg.TracksPerCylinder *
		pdg.SectorsPerTrack * pdg.BytesPerSector;       //calculate the disk size;
	partSize.QuadPart = diskSize.QuadPart / vPartNum;

	//分区结构大小
	layoutStructSize = sizeof(DRIVE_LAYOUT_INFORMATION_EX) + (actualPartNum - 1) * sizeof(PARTITION_INFORMATION_EX);
	dl = (DRIVE_LAYOUT_INFORMATION_EX*)malloc(layoutStructSize);
	if (NULL == dl)
	{
		(void)CloseHandle(hDevice);
		return (WORD)-1;
	}

	dl->PartitionStyle = (DWORD)PARTITION_STYLE_MBR;
	dl->PartitionCount = actualPartNum;
	dl->Mbr.Signature = signature;

	//clear the unused partitions
	//清除未用的分区
	printf("清除未用的分区\n");
	for (i = 0; i < actualPartNum; i++){
		dl->PartitionEntry[i].RewritePartition = 1;
		dl->PartitionEntry[i].Mbr.PartitionType = PARTITION_ENTRY_UNUSED;
	}

	//set the profile of the partitions
	for (i = 0; i < vPartNum; i++){
		dl->PartitionEntry[i].PartitionStyle = PARTITION_STYLE_MBR;
		dl->PartitionEntry[i].StartingOffset.QuadPart =
			(partSize.QuadPart * i) + ((LONGLONG)(pdg.SectorsPerTrack) * (LONGLONG)(pdg.BytesPerSector));   //32256
		dl->PartitionEntry[i].PartitionLength.QuadPart = partSize.QuadPart;
		dl->PartitionEntry[i].PartitionNumber = i + 1;
		dl->PartitionEntry[i].RewritePartition = TRUE;
		dl->PartitionEntry[i].Mbr.PartitionType = PARTITION_IFS;
		dl->PartitionEntry[i].Mbr.BootIndicator = FALSE;
		dl->PartitionEntry[i].Mbr.RecognizedPartition = TRUE;
		dl->PartitionEntry[i].Mbr.HiddenSectors =
			pdg.SectorsPerTrack + (DWORD)((partSize.QuadPart / sectorSize) * i);
	}
	//execute the layout  
	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_SET_DRIVE_LAYOUT_EX,
		dl,
		layoutStructSize,
		NULL,
		0,
		&readed,
		NULL
		);
	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_SET_DRIVE_LAYOUT_EX Error: %ld\n", GetLastError());
		free(dl);
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	//fresh the partition table
	printf("刷新分区表\n");
	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_UPDATE_PROPERTIES,
		NULL,
		0,
		NULL,
		0,
		&readed,
		NULL
		);
	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_UPDATE_PROPERTIES Error: %ld\n", GetLastError());
		free(dl);
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	free(dl);
	(void)CloseHandle(hDevice);
	printf("CreateDisk完成\n");
	Sleep(3000);            //wait the operations take effect
	return 0;
}


//获取磁盘几何信息
BOOL CMDiskManager::GetDriveGeometry(DWORD vDiskNo, DISK_GEOMETRY *pdg)
{
	HANDLE hDevice; // handle to the drive to be examined
	BOOL bResult; // results flag
	DWORD junk; // discard results

	char diskPath[256];				//磁盘内部路径
	sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);

	hDevice = CreateFile(TEXT(diskPath), // drive
		0, // no access to the drive
		FILE_SHARE_READ | // share mode
		FILE_SHARE_WRITE,
		NULL, // default security attributes
		OPEN_EXISTING, // disposition
		0, // file attributes
		NULL); // do not copy file attributes

	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
	{
		return (FALSE);
	}

	bResult = DeviceIoControl(hDevice, // device to be queried
		IOCTL_DISK_GET_DRIVE_GEOMETRY, // operation to perform
		NULL, 0, // no input buffer
		pdg, sizeof(*pdg), // output buffer
		&junk, // # bytes returned
		(LPOVERLAPPED)NULL); // synchronous I/O

	CloseHandle(hDevice);

	return (bResult);
}


/******************************************************************************
* Function: delete the partition layout of the disk
删除磁盘分区信息（恢复出厂设置）
* input: disk, disk name
* output: N/A
* return: Succeed, 0
*         Fail, -1
******************************************************************************/
DWORD CMDiskManager::DestroyDisk(DWORD vDiskNo)
{
	if (0 == vDiskNo){
		//系统盘是0号盘，为了安全，不能删除
		return 0; 
	}

	HANDLE hDevice;               // handle to the drive to be examined
	BOOL result;                  // results flag
	DWORD readed;                 // discard results
	CHAR diskPath[256];

	sprintf(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);

	hDevice = CreateFile(
		diskPath, // drive to open
		GENERIC_READ | GENERIC_WRITE,     // access to the drive
		FILE_SHARE_READ | FILE_SHARE_WRITE, //share mode
		NULL,             // default security attributes
		OPEN_EXISTING,    // disposition
		0,                // file attributes
		NULL            // do not copy file attribute
		);
	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
	{
		fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());
		return DWORD(-1);
	}

	result = DeviceIoControl(
		hDevice,               // handle to device
		IOCTL_DISK_DELETE_DRIVE_LAYOUT, // dwIoControlCode
		NULL,                           // lpInBuffer
		0,                              // nInBufferSize
		NULL,                           // lpOutBuffer
		0,                              // nOutBufferSize
		&readed,      // number of bytes returned
		NULL        // OVERLAPPED structure
		);
	if (!result)
	{
		//fprintf(stderr, "IOCTL_DISK_DELETE_DRIVE_LAYOUT Error: %ld\n", GetLastError());
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	//fresh the partition table
	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_UPDATE_PROPERTIES,
		NULL,
		0,
		NULL,
		0,
		&readed,
		NULL
		);
	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_UPDATE_PROPERTIES Error: %ld\n", GetLastError());
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	(void)CloseHandle(hDevice);
	return 0;
}

/******************************************************************************
* Function:快速格式化某个磁盘，文件系统NTFS，
如果在CreateDisk()创建磁盘后，磁盘的文件系统是RAW的话，才需要调用该函数
* input: disk, disk name
* output: N/A
* return: Succeed, 0
*         Fail, 1
******************************************************************************/
DWORD CMDiskManager::FormatVolume(CHAR letter)
{
	DWORD ret;
	CHAR cmd[64];
	sprintf(cmd, "format %c: /FS:NTFS /Q /Y", letter);
	ret = (DWORD)system(cmd);
	return ret;
}

//获取第dwNum个磁盘的信息
void CMDiskManager::GetDiskInfo(DWORD &dwNum, CString chDriveInfo[])
{
	DWORD DiskCount = 0;

	//利用GetLogicalDrives()函数可以获取系统中逻辑驱动器的数量，函数返回的是一个32位无符号整型数据。  
	DWORD DiskInfo = GetLogicalDrives();

	//通过循环操作查看每一位数据是否为1，如果为1则磁盘为真,如果为0则磁盘不存在。  
	while (DiskInfo)
	{
		//通过位运算的逻辑与操作，判断是否为1  
		Sleep(10);
		if (DiskInfo & 1)
		{
			DiskCount++;
		}
		DiskInfo = DiskInfo >> 1;//通过位运算的右移操作保证每循环一次所检查的位置向右移动一位。*/  
	}

	if (dwNum < DiskCount)
	{
		return;//实际的磁盘数目大于dwNum  
	}
	dwNum = DiskCount;//将磁盘分区数量保存  


	//-------------------------------------------------------------------//  
	//通过GetLogicalDriveStrings()函数获取所有驱动器字符串信息长度  
	int DSLength = GetLogicalDriveStrings(0, NULL);

	CHAR* DStr = new CHAR[DSLength];
	memset(DStr, 0, DSLength);

	//通过GetLogicalDriveStrings将字符串信息复制到堆区数组中,其中保存了所有驱动器的信息。  
	GetLogicalDriveStrings(DSLength, DStr);

	int DType;
	int si = 0;
	BOOL fResult;
	unsigned _int64 i64FreeBytesToCaller;
	unsigned _int64 i64TotalBytes;
	unsigned _int64 i64FreeBytes;

	//读取各驱动器信息，由于DStr内部数据格式是A:\NULLB:\NULLC:\NULL，所以DSLength/4可以获得具体大循环范围  
	for (int i = 0; i<DSLength / 4; ++i)
	{
		Sleep(10);
		CString strdriver = DStr + i * 4;
		CString strTmp, strTotalBytes, strFreeBytes;
		DType = GetDriveType(strdriver);//GetDriveType函数，可以获取驱动器类型，参数为驱动器的根目录  
		switch (DType)
		{
		case DRIVE_FIXED:
		{
			strTmp.Format(_T("本地磁盘"));
		}
			break;
		case DRIVE_CDROM:
		{
			strTmp.Format(_T("DVD驱动器"));
		}
			break;
		case DRIVE_REMOVABLE:
		{
			strTmp.Format(_T("可移动磁盘"));
		}
			break;
		case DRIVE_REMOTE:
		{
			strTmp.Format(_T("网络磁盘"));
		}
			break;
		case DRIVE_RAMDISK:
		{
			strTmp.Format(_T("虚拟RAM磁盘"));
		}
			break;
		case DRIVE_UNKNOWN:
		{
			strTmp.Format(_T("虚拟RAM未知设备"));
		}
			break;
		default:
			strTmp.Format(_T("未知设备"));
			break;
		}

		//GetDiskFreeSpaceEx函数，可以获取驱动器磁盘的空间状态,函数返回的是个BOOL类型数据  
		fResult = GetDiskFreeSpaceEx(strdriver,
			(PULARGE_INTEGER)&i64FreeBytesToCaller,
			(PULARGE_INTEGER)&i64TotalBytes,
			(PULARGE_INTEGER)&i64FreeBytes);

		if (fResult)
		{
			strTotalBytes.Format(_T("磁盘总容量%.2fMB"), (float)i64TotalBytes / 1024 / 1024);
			strFreeBytes.Format(_T("磁盘剩余空间%.2fMB"), (float)i64FreeBytesToCaller / 1024 / 1024);
		}
		else
		{
			strTotalBytes.Format(_T(""));
			strFreeBytes.Format(_T(""));
		}
		chDriveInfo[i] = strTmp + _T("(") + strdriver + _T("):") + strTotalBytes + ", " +strFreeBytes;
		si += 4;
	}
}


/******************************************************************************

* Function: get disk's physical number from its drive letter
		根据逻辑盘符找到物理硬盘号

*           e.g. C-->0 (C: is on disk0)

* input: letter, drive letter

* output: N/A

* return: Succeed, disk number

*         Fail, -1

******************************************************************************/

//根据逻辑盘符找到物理硬盘号
DWORD CMDiskManager::GetPhysicalDriveFromPartitionLetter(CHAR letter)
{
	HANDLE hDevice;               // handle to the drive to be examined

	BOOL result;                 // results flag

	DWORD readed;                   // discard results

	STORAGE_DEVICE_NUMBER number;   //use this to get disk numbers
	
	CHAR path[256];

	sprintf(path, "\\\\.\\%c:", letter);

	hDevice = CreateFile(path, // drive to open

		GENERIC_READ | GENERIC_WRITE,    // access to the drive

		FILE_SHARE_READ | FILE_SHARE_WRITE,    //share mode

		NULL,             // default security attributes

		OPEN_EXISTING,    // disposition

		0,                // file attributes

		NULL);            // do not copy file attribute

	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive

	{

		fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());

		return DWORD(-1);
	}
	
	result = DeviceIoControl(

		hDevice,                // handle to device

		IOCTL_STORAGE_GET_DEVICE_NUMBER, // dwIoControlCode

		NULL,                            // lpInBuffer

		0,                               // nInBufferSize

		&number,           // output buffer

		sizeof(number),         // size of output buffer

		&readed,       // number of bytes returned

		NULL      // OVERLAPPED structure

		);

	if (!result) // fail
	{

		fprintf(stderr, "IOCTL_STORAGE_GET_DEVICE_NUMBER Error: %ld\n", GetLastError());

		(void)CloseHandle(hDevice);

		return (DWORD)-1;
	}

	//printf("%d %d %d\n\n", number.DeviceType, number.DeviceNumber, number.PartitionNumber);
	
	(void)CloseHandle(hDevice);
	
	return number.DeviceNumber;

}

/******************************************************************************

* Function: get disk's drive letters from physical number
获取一个物理硬盘上的所有盘符
*           e.g. 0-->{C, D, E} (disk0 has 3 drives, C:, D: and E:)

* input: vDiskNo, disk's physical number

* output: letters, letters array

* return: Succeed, the amount of letters

*         Fail, -1

******************************************************************************/

CString CMDiskManager::GetPartitionLetterFromPhysicalDrive(DWORD vDiskNo)
{
	DWORD mask;
	DWORD driveType;
	DWORD bmLetters;
	DWORD diskNumber;
	CHAR path[256];
	CHAR letter;
	DWORD letterNum;
	WORD i;
	CHAR *p;
	CString tRet = ""; 

	bmLetters = GetLogicalDrives();

	if (0 == bmLetters)
	{
		return "";
	}
	
	letterNum = 0;

	for (i = 0; i < sizeof(DWORD) * 8; i++)
	{
		mask = 0x1u << i;

		if ((mask & bmLetters) == 0)        //get one letter
		{
			continue;
		}

		letter = (CHAR)(0x41 + i);    //ASCII change

		sprintf(path, "%c:\\", letter);

		driveType = GetDriveType(path);

		if (driveType != DRIVE_FIXED)
		{
			bmLetters &= ~mask;     //clear this bit
			continue;
		}

		diskNumber = GetPhysicalDriveFromPartitionLetter(letter);

		if (diskNumber != vDiskNo)
		{
			bmLetters &= ~mask;     //clear this bit

			continue;
		}

		letterNum++;
	}
	
	//build the result

	/*letters = (CHAR *)malloc(letterNum);
	
	if (NULL == *letters)
	{
		return (DWORD)-1;
	}

	p = *letters;
	*/
	CString s;
	for (i = 0; i < sizeof(DWORD) * 8; i++)
	{
		mask = 0x1u << i;

		if ((mask & bmLetters) == 0)
		{
			continue;
		}

		letter = (CHAR)(0x41 + i);    //ASCII change
		s.Format("%c", letter); 
		if (!tRet.IsEmpty()){
			tRet +=  ",";
		}
		tRet += s + ":"; 
		
	}

	return tRet;
}



头文件：CMDiskManager.h

#include <windows.h>
#include <winioctl.h>
#include <stdio.h>
#include "time.h"

#include <stdlib.h>
#include <tchar.h>

#pragma pack(1)

#define MAX_MBR_PARTITIONS          4
#define MBR_DISK_SIGNATURE_OFFSET   440
#define MBR_DISK_PPT_OFFSET         446
#define MBR_SIGNATURE_OFFSET        510

//
// MBR Partition Entry
//
typedef struct {
	UINT8  BootIndicator;
	UINT8  StartHead;
	UINT8  StartSector;
	UINT8  StartTrack;
	UINT8  OSType;
	UINT8  EndHead;
	UINT8  EndSector;
	UINT8  EndTrack;
	UINT32 StartingLBA;
	UINT32 SizeInLBA;
} MBR_PARTITION_RECORD;

//
// MBR Partition table
//
typedef struct {
	UINT8                 BootCode[440];
	UINT32                UniqueMbrSignature;
	UINT16                Unknown;
	MBR_PARTITION_RECORD  PartitionRecord[MAX_MBR_PARTITIONS];
	UINT16                Signature;
} MASTER_BOOT_RECORD;

#pragma pack()

#define MBR_SIGNATURE               0xAA55
#define EXTENDED_DOS_PARTITION      0x05
#define EXTENDED_WINDOWS_PARTITION  0x0F


class CMDiskManager {

public:

	CMDiskManager(); 

	//获取磁盘几何
	BOOL GetDriveGeometry(DWORD vDiskNo, DISK_GEOMETRY *pdg);
	 
	//获取磁盘大小,单位是MB
	int GetDiskSize(DWORD vDiskNo);

	/*
	获取磁盘分区信息
	vDiskNo:磁盘序号 
	*/
	DWORD GetLayoutInfo(DWORD vDiskNo);

	//读MBR信息
	BOOL ReadMBR(int vDiskNo, LPVOID *pBuffer);

	/*
	获取磁盘分区个数
	vDiskNo:磁盘序号
	*/
	int GetPartNum(DWORD vDiskNo);

	/*
	初始化磁盘，创建分区
	vDiskNo:磁盘序号，千万要避开系统盘，系统盘一般是0
	vPartNum:分区数，只要1个分区就可以了
	*/
	DWORD CreateDisk(DWORD vDiskNo, WORD vPartNum);

	/*
	回复磁盘到空白状态，删除MBR分区信息
	*/
	DWORD DestroyDisk(DWORD vDiskNo);

};

如果CreateDisk之后文件系统格式还是RAW的，那么可以用这个： 
/******************************************************************************
* Function:快速格式化某个磁盘，文件系统NTFS
* input: disk, disk name
* output: N/A
* return: Succeed, 0
*         Fail, 1
******************************************************************************/
DWORD CMDiskManager::FormatVolume(CHAR letter)
{
	DWORD ret;
	CHAR cmd[64];
	sprintf(cmd, "format %c: /FS:NTFS /Q /Y", letter);
	ret = (DWORD)system(cmd);
	return ret;
}







wuzuyu365
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
获取网卡MAC、硬盘序列号、CPU_ID、BIOS编号
樱*夜精灵
01-17 1246
获取网卡MAC、硬盘序列号、CPU ID、BIOS编号 以下代码可以取得系统特征码（网卡MAC、硬盘序列号、CPU ID、BIOS编号）     BYTE szSystemInfo[4096]; // 在程序执行完毕后，此处存储取得的系统特征码     UINT uSystemInfoLen = 0; // 在程序执行完毕后，此处存储取得的系统特征码的长度     // 网卡 MAC 地址
Windows下硬盘低级格式化工具（中文）
02-05
低级格式化（Low-Level Formatting，LLF）是对硬盘进行初始化的过程，它会在磁盘上创建物理上的存储区域，如扇区、磁道和柱面，为数据存储提供基础结构。与普通的高级格式化（High-Level Formatting）不同，后者主要...
Windows 和 GPT 常见问题
allway2的博客
12-18 2264
常见问题有关 GUID 分区表 (GPT) 的解答。 此版本的 Windows 和 GPT 常见问题适用于 Windows 10 和 Windows Server 2016。本常见问题解答的以前版本，请参阅Windows 和 GPT 常见问题 MSDN 上。 由于个人计算机的引入，在硬盘上的数据存储区域都分成较小的区域称为扇区。这些扇区分为分区在磁盘上创建单独的卷或驱动器。分区都被...
初始化硬盘
点道为止
04-11 838
从光盘进入纯DOS，输入一下命令 1.debug 2.-a 3.mov ax,301 4.mov bx,90 5.mov cx,1 6.mov dx,80 7.int 13 8.int 20 9.ctrl+c (按ctrl+c) 10.-g 11.-q 从1到11按逐个执行就行了，这样硬盘就被初始化了，部分硬盘黑卖家就是这样搞的
磁盘未初始化详解：原因、数据恢复与预防措施
最新发布
dintc的博客
05-20 718
最后，病毒或恶意软件的攻击也是一个不可忽视的原因，它们可能会破坏磁盘分区信息或文件系统。在面对磁盘未初始化的问题时，我们应保持冷静并采取正确的应对措施以最大程度地减少数据损失。当您尝试访问某个磁盘或分区时，系统提示该磁盘未初始化，这意味着磁盘上的数据可能无法读取或写入。本文将深入探讨磁盘未初始化的原因，并提供有效的数据恢复方案，同时分享如何预防此类问题的发生。数之寻是一款功能强大的数据恢复软件，能够扫描并尝试恢复未初始化磁盘中的数据。在未来的使用过程中，我们要时刻保持警惕，确保数据的安全与完整。
命令行格式化硬盘
ytfy12的专栏
04-16 4653
参考https://jingyan.baidu.com/article/5553fa82c878ac65a239349e.html https://answers.microsoft.com/zh-hans/windows/forum/windows_10-update/%E7%94%A8-dism/a3ea0d10-036c-41ff-8bb9-350c2bda525b 最近使用了微软...
解码 I/O 控制代码——Windows
Yalneh的博客
01-08 1324
0x0004d014 IOCTL_SCSI_PASS_THROUGH_DIRECT
读取硬盘序列号
热门推荐
Tody Guo的专栏
05-17 1万+
#pragma hdrstop #pragma argsused #include #include #include #include "hdd.h" const WORD IDE_ATAPI_IDENTIFY = 0xA1; // 读取ATAPI设备的命令 const WORD IDE_ATA_IDENTIFY = 0xEC; // 读取ATA设备的命令 const in
用C实现的硬盘格式化程序
06-22
5. **检查与校验**：最后，格式化程序可能会进行磁盘错误检测，如CRC校验，确保硬盘的健康状态。 在C语言中实现硬盘格式化，我们需要以下关键知识点： - **系统调用**：C语言没有直接处理硬件的函数，因此需要通过...
移动硬盘低级格式化.zip
03-18
在计算机硬件层面，低级格式化（Low-Level Formatting，简称LLF）是对硬盘或存储设备进行初始化的过程，它会创建磁盘上的物理扇区和磁道，并构建一个可供操作系统使用的逻辑结构。与之相对的是高级格式化（High-...
完整版磁盘格式化模块 1.0.rar
04-03
磁盘格式化是计算机操作中一个重要的环节，主要用于清理硬盘上的数据、初始化新的存储空间或为操作系统安装做准备。在本文中，我们将深入探讨“完整版磁盘格式化模块 1.0”的核心功能和重要知识点。 1. **磁盘格式...
vc中英文转换
09-04
可以实现vc单文档程序的中英文菜单转换，当然也可以多种语言
获取CPU占用率、物理内存、硬盘源码，修正支持win10
04-09
原地址 ：https://www.lkuaiy.com/rsdetails?page=1&id=16486050237205286 转发至利快云官网,例子代码都是原作者 @灰羊羊
低格式化工具硬盘救星非常好用
09-14
低级格式化是一种彻底的初始化过程，它会清除硬盘上的所有数据并重新划分磁道和扇区，使得硬盘恢复到出厂状态。 描述中的“硬盘低级格式化工具”进一步明确了主题，这种工具通常被专业技术人员或高级用户使用，因为...
geshihua.rar_硬盘格式化_自动化
09-21
标题“geshihua.rar_硬盘格式化_自动化”暗示了这个压缩包文件包含了一个与硬盘格式化相关的自动化程序。在IT领域，硬盘格式化通常指的是清除硬盘上的所有数据，并为新的文件系统创建空间。这个过程可能包括初始化...
硬盘低级格式化操作图解.doc
01-05
硬盘低级格式化，简称“低格”，是一种对硬盘存储空间进行基础结构初始化的过程，它直接与硬盘的物理特性相关，涉及到硬盘的扇区、磁道等底层构造。这一操作通常用于解决硬盘出现严重错误或者需要彻底清除硬盘数据的...
获取硬盘分区表的格式--是gpt还是mbr
不才的专栏
03-13 1637
MSDN：DeviceIoControl 与硬件驱动交互时，DeviceIoControl 是常用的windows API。 它把控制码发给制定的硬件驱动，然后获取设备信息或者对设备进行其他操作。 下面是一个小demo #include #include using namespace std; int main() { TCHAR szDiskPos[128] = L"\\\\.\
如何在虚拟机Windows Server 2016上进行动态磁盘划分
qq_74285286的博客
03-08 2566
如何在虚拟机Windows Server 2016上进行动态磁盘划分
Windows 磁盘设备操作控制码大全
Biao
04-30 2274
Windows 磁盘操作，通过DeviceIoControl 函数传递不同的控制码实现磁盘的各种不同的操作。下面表格翻译自Windows官方文档：Disk Management Control Codes 下表列出了在磁盘管理中使用的控制代码。 Control Code Description IOCTL_DISK_ARE_VOLUMES_READY 等待指定磁盘............
硬盘初始化全攻略：分区与格式化
"硬盘的初始化教程，包括硬盘POST自动检测、低级格式化、分区、高级格式化、操作系统安装以及物理坏道处理等步骤。讲解了硬盘分区的类型、原则及常用的分区工具，如FDISK、DM、DISKPART、DISKGEN、F32和PQ分区大师，...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值