初始化和格式化的区别

转载自：https://blog.csdn.net/wuzuyu365/article/details/52881692

新买来的硬盘是未初始化的，以我的理解就是没有引导扇区的，通常是没有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;
	
	
	}
收起
windows下初始化格式化磁盘

2014-04-30工作日志：初始化与格式化的区别

el-date-picker初始化时格式化

json的初始化赋值格式

对象数组的初始化分为静态初始化和动态初始化

jsp页面初始化日期格式

Java 中Date格式初始化和Calendar使用

c#中数组的声明和初始化以及字符串(string)对象基础特征/属性/常用方法/字符串格式化Format

几种常见的ROM,RAM初始化文件格式

数组静态初始化和动态初始化

golang 结构体初始化时赋值格式

【UCOSIII】UCOSIII的初始化和启动

Java中一维数组和二维数组初始化对象数组初始化

数组的初始化两种方式？初始化常见错误

彷徨 | HDFS初始化创建一个新的集群(将原集群格式化)

Java学习笔记-数组的静态初始化和动态初始化

c++构造函数成员初始化中赋值和初始化列表两种方式的区别

Objective-C 中便利初始化方法和指定初始化方法

c语言中数组初始化与未初始化的区别

ros 初始化和关闭

类的初始化和对象的初始化

Swift3.0语言教程使用占位符格式创建和初始化字符串

echarts图表初始化和常用属性

二维数组的定义(动态初始化、静态初始化)、初始化格式及其操作、java中的参数传递方式，面向对象的基本概念

【Java】数组的创建（静态初始化和动态初始化）

初始化和格式化的区别

windows下初始化格式化磁盘

2014-04-30工作日志：初始化与格式化的区别

el-date-picker初始化时格式化

json的初始化赋值格式

对象数组的初始化 分为 静态初始化 和动态初始化

jsp页面初始化日期格式

Java 中Date格式初始化和Calendar使用

c#中数组的声明和初始化以及字符串(string)对象基础特征/属性/常用方法/字符串格式化Format

几种常见的ROM,RAM初始化文件格式

数组静态初始化和动态初始化

golang 结构体初始化时赋值格式

【UCOSIII】UCOSIII的初始化和启动

Java中一维数组和二维数组初始化 对象数组初始化

数组的初始化两种方式？初始化常见错误

彷徨 | HDFS初始化创建一个新的集群(将原集群格式化)

Java学习笔记-数组的静态初始化和动态初始化

c++构造函数成员初始化中赋值和初始化列表两种方式的区别

Objective-C 中便利初始化方法和指定初始化方法

c语言中数组初始化与未初始化的区别

ros 初始化和关闭

类的初始化和对象的初始化

Swift3.0语言教程使用占位符格式创建和初始化字符串

echarts图表初始化和常用属性

二维数组的定义(动态初始化、静态初始化)、初始化格式及其操作、java中的参数传递方式，面向对象的基本概念

【Java】数组的创建（静态初始化和动态初始化）

初始化和格式化的区别

对象数组的初始化分为静态初始化和动态初始化

Java中一维数组和二维数组初始化对象数组初始化
