精华内容
下载资源
问答
  • 介绍一些格式化磁盘方法,某些程序可能会创建一些自己的盘符,分区的创建涉及到驱动开发。 一般会在使用分区前进行格式化,这个可以用API实现。 下面介绍2种格式化磁盘方法,一种是弹出平常我们右键盘符选择格式...

    1,目的


    介绍一些格式化磁盘的方法,某些程序可能会创建一些自己的盘符,分区的创建涉及到驱动开发,这里不作介绍。

    一般会在使用分区前进行格式化,这个是可以用API实现的。

    下面介绍2种格式化磁盘的方法,一种是弹出平常我们右键盘符选择格式化时的对话框,如下:


    第二种是一种“偷偷”地格式化,完全没有任何界面提示,如果你不想让用户知道你在格式化的话。

    但是,格式化磁盘是需要不少时间的,可能要好几秒到十几秒以上。

    这个方法花了我不少时间,搜集多个地方总结出来的。



    2,原理及实现


    一,Windows标准界面格式化

    使用到Shell32.dll 中的一个函数:SHFormatDrive。

    首先定义这个函数指针:

    typedef DWORD (WINAPI *PFNSHFORMATDRIVE)(HWND hwnd,UINT drive,UINT fmtID,UINT options); 
    参数说明:

    hWnd:当前窗口句柄。我们可以就传NULL。
    Drive:要格式的分区序号(例:A盘是0,C盘是2)
    fmtID:一般设置为SHFMT_ID_DEFAULT
    Options:选项,有如下几个可选值:
    SHFMT_OPT_SYSONLY:快速格式化
    SHFMT_OPT_FULL :正常(非快速)格式化
    封装好的格式化函数 FormatDisk :(传入磁盘盘符的字符)
    void FormatDisk(WCHAR cDisk)
    {
    	HINSTANCE hDll=LoadLibraryW(L"Shell32.dll"); 
    	if(hDll==NULL)
    		return;  
    	PFNSHFORMATDRIVE pFnSHFormatDrive=(PFNSHFORMATDRIVE)GetProcAddress(hDll,"SHFormatDrive"); 
    	if(pFnSHFormatDrive==NULL) 
    	{ 
    		FreeLibrary(hDll); 
    		return; 
    	} 
    	pFnSHFormatDrive(NULL,cDisk-L'A',SHFMT_ID_DEFAULT,0);
    	FreeLibrary(hDll);
    }

    二,静默格式化

    可能有人熟悉,用cmd命令 “format” 可以进行格式化。
    但是,会有如下这个选择的界面,需要输入Y/N:

    如果我们调用cmd.exe并让其隐藏执行的话,执行到这里就通不过去了,经测试,结果也并没有实现格式化。

    经过搜索,和在论坛的询问,最后加上自己的猜测,我给启动cmd的参数后加入了"\Y",一试,嘿嘿,果然通过了这个确认选项。
    封装函数如下:
    void FormatDisk(WCHAR cDisk)
    {
    	SHELLEXECUTEINFO sei;  
    	SecureZeroMemory(&sei, sizeof(SHELLEXECUTEINFO));  
    	sei.cbSize = sizeof(SHELLEXECUTEINFO);  
    	sei.lpVerb = L"open";  
    	CString strCmdPath = L"C:\\Windows\\system32\\cmd.exe";
    	sei.lpFile = strCmdPath.GetString();  
    	sei.fMask = SEE_MASK_NOCLOSEPROCESS;  
    	CString strCmd = CString(L"/c format ")+ CString(cDisk) + CString(L": /fs:ntfs /q /y");
    	sei.lpParameters = strCmd.GetString();
    	sei.nShow = SW_HIDE;  
    	ShellExecuteEx( &sei );
    	WaitForSingleObject(sei.hProcess,INFINITE); 
    }

    "/c"命令代表cmd执行完成后退出
    "/fs:ntfs"指定格式化后的文件系统类型
    "/q"是快速格式化
    “/y”是我猜测的确认格式化参数

    sei.nShow = SW_HIDE; 代表cmd进程隐藏窗口执行。
    WaitForSingleObject(sei.hProcess,INFINITE); 是阻塞直到cmd进程有信号,这里是可以等待到其完成。

    这里工程是Unicode环境。测试,格式化有效,而且无任何界面出现。


    展开全文
  • windows下初始化格式化磁盘

    千次阅读 2016-10-21 11:38:29
    #include "stdafx.h" #include "CMDiskManager.h" ...获取磁盘分区信息 vDiskNo:磁盘序号 */ DWORD CMDiskManager::GetLayoutInfo(DWORD vDiskNo) { char diskPath[256]; //磁盘内部路径 //生成

    新买来的硬盘是未初始化的,以我的理解就是没有引导扇区的,通常是没有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 创建和格式化硬盘 (12T) 分区 - 失败记录 若要在硬盘上创建分区或卷,必须以管理员身份登录,并且硬盘上必须有未分配的磁盘空间或者在硬盘上的扩展分区内必须有可用空间。 如果没有任何未分配的磁盘空间,则...

    Windows 创建和格式化硬盘 (12T) 分区 - 失败记录

    若要在硬盘上创建分区或卷,必须以管理员身份登录,并且硬盘上必须有未分配的磁盘空间或者在硬盘上的扩展分区内必须有可用空间。

    如果没有任何未分配的磁盘空间,则可以通过收缩现有分区、删除分区或使用第三方分区程序创建一些空间。

    当在基本磁盘上创建新分区时,会将前三个分区格式化为主分区。从第四个分区开始,每一个分区会配置为扩展分区内的逻辑驱动器。

    不能格式化当前正在使用的磁盘或分区 (包括内含 Windows 的分区)。

    执行快速格式化选项将创建新的文件表,但不会完全覆盖或擦除卷。与会完全擦除卷上所有现有数据的正常格式化相比,快速格式化的速度较快。

    1. 计算机管理

    计算机 -> 鼠标右键 -> 管理

    在这里插入图片描述

    2. 查看新添加硬盘

    存储 -> 磁盘管理

    在这里插入图片描述

    3. 新建简单卷

    在这里插入图片描述

    在这里插入图片描述

    4. 指定卷大小

    在这里插入图片描述

    5. 分配驱动器号和路径

    在这里插入图片描述

    6. 格式化分区

    在这里插入图片描述

    7. 正在完成新建简单卷向导

    在这里插入图片描述

    8. 磁盘上没有足够的空间完成此操作

    在这里插入图片描述

    9. DiskPart

    在这里插入图片描述

    10. 磁盘转换成动态磁盘

    操作系统中的可用是指磁盘空间剩余量,这里的可用是指没有分配的磁盘空间。

    Microsoft DiskPart 版本 6.1.7601
    Copyright (C) 1999-2008 Microsoft Corporation.
    在计算机上: FS-PC
    
    DISKPART> list disk
    
      磁盘 ###  状态           大小     可用     Dyn  Gpt
      --------  -------------  -------  -------  ---  ---
      磁盘 0    联机              119 GB      0 B
      磁盘 1    联机              931 GB  1024 KB
      磁盘 2    联机               10 TB  2047 GB
    
    DISKPART>
    
    DISKPART> list disk
    
      磁盘 ###  状态           大小     可用     Dyn  Gpt
      --------  -------------  -------  -------  ---  ---
      磁盘 0    联机              119 GB      0 B
      磁盘 1    联机              931 GB  1024 KB
      磁盘 2    联机               10 TB  2047 GB
    
    DISKPART>
    
    DISKPART> select disk 2
    
    磁盘 2 现在是所选磁盘。
    
    DISKPART>
    
    DISKPART> convert dynamic
    
    虚拟磁盘服务错误:
    只可以使用大型 MBR 磁盘上的首个 2TB。无法创建 2TB 标记外的分区,
    也无法将磁盘转换为动态。
    
    
    DISKPART>
    

    11. Windows 创建和格式化硬盘 (12T) 分区未能成功,将在 Ubuntu 上完成任务 (parted)

    展开全文
  • 提示“磁盘未被格式化,是否格式化”的解决方法 [适用] 1、典型地,台式机硬盘、笔记本盘、移动硬盘、U盘、数码卡、MP3; 2、普通硬盘; 3、很少的,盘阵等采用WINDOWS系统的存储; [症状] 1、突然袭断电、移动硬盘或U盘...
  • 如何在Windows DOS环境下格式化硬盘

    万次阅读 2015-07-02 18:30:22
    Windows环境下格式化硬盘方法比较多,本文介绍如何在DOS环境下彻底格式化硬盘。该方法主要适合于未分区或里面已经有不同操作系统的硬盘,因为这类盘插在电脑上,在设备管理器里面可以看到,但你在系统里找不到...

             在Windows环境下格式化硬盘的方法比较多,本文介绍如何在DOS环境下彻底格式化某硬盘。该方法主要适合于未分区或里面已经有不同操作系统的硬盘,因为这类盘插在电脑上,在设备管理器里面可以看到,但你在系统里找不到该盘符是无法识别的,这时你如果想彻底格式化该硬盘,可以在DOS环境下操作。以下是详细操作说明。

    step1. 插上你的硬盘,确保设备管理器里面有此东东,如图1所示;

    图 1

    step2. 键盘window+ R,输入cmd,进入DOS窗口;

    图 2


    step3. 输入命令:diskpart,DOS弹出另一个窗口,图3所示;

    图 3

    step4. 在弹出的DOS窗口,输入:list disk, 盘符显示;输入要格式化的盘符,输入:select disk 1,注意空格;再输入clean,回车       确认,格式化完成;输入exit退出该DOS窗口,关闭主DOS窗口;


    图 4

    step5. 右键“我的电脑”,选择“管理”,在“存储”选项中设置格式化后的硬盘命名。

    综上,操作完成。

              





    展开全文
  • 转换磁盘格式需要清空磁盘中的所有分区和数据,在操作前,保存好磁盘中所有重要数据。 1.使用Win7光盘或者U盘引导,进入系统安装界面。 2.按Shift + F10打开命令提示符。 3.输入”Diskpart”(不用输入引号,下同)...
  • 关于U盘变成RAW格式 windows无法格式化的解决方法

    万次阅读 多人点赞 2016-07-14 16:22:20
    网上有很多人说是U盘坏了,其实不是这样。这个问题是可以解决的,解决方法也是在...但是点格式化以后又跳出windows无法格式化。 造这个原因是因为我将U盘插在一台需要分区的新电脑上而导致的。 网上有很多人说
  • USB磁盘linux挂载windows格式化的问题

    千次阅读 2013-09-26 14:49:48
    先说说windows格式化吧, 工作需要, 测试U盘格式化为其他格式做测试。我的U盘是FAT32的, 在windows中操作右键格式化,发现只有fat32, fat, exfat, 没有看到ntfs啊, 以前格式化没这出啊。不想到处找电脑试。  直
  • 有块日立硬盘,2.5英寸,500g容量,有些坏道,采用DiskGenius修复坏道两天两夜未能如愿。 不得已,采用低级格式化办法。 注意:低级格式化不要随便使用,这是...2、低级格式化磁盘;3、高级格式化磁盘。 一、下载和...
  • Linux Ubuntu16挂载新硬盘并格式化硬盘方法教程笔记 查看硬盘 查看方法一 查看/dev 下面的设备文件 Linux 硬盘识别: 2.6 kernel 以后,linux会将识别到的硬件设备,在/dev/下建立相应的设备文件. 如: sda 表示第...
  • 本案例由Windows 10 系统下进行。 使用命令行模式清理U盘/磁盘内文件,是将U盘内的系统卷删除掉。 第一步: 查看U盘的基本配置 方式:我的电脑 右键—管理—磁盘管理 第二步: 打开cmd命令行模式(以管理员模式下打开...
  • windows7下FAT32格式化硬盘

    千次阅读 2014-05-07 16:16:12
    管理员方式运行cmd,输入命令:FORMAT 盘符(F:/)FS:格式(FAT32) 例如:FORMAT F:/FS:FAT32 如果不是管理员会: 管理员则: 输入Y,然后回车,就等待吧!
  • 如何在windows下把硬盘格式化成EXT3格式?MiNi tool软件 MiNi tool软件 在装Minix、Linux、QNX、安卓X86的双系统时,我遇到了”如何在windows下把硬盘格式成EXT3格式“的问题 1.在百度中搜索”MiNi tool“后,打开...
  • Windows下无法格式化U盘问题解决方法

    千次阅读 2018-01-29 11:30:20
    百度上的方法 第一种:用cmd命令行输入 ...用Windows自带的磁盘管理格式化U盘 Windows10是右键点击左下角那个小图标,再点击磁盘管理如下图  再右键点击你要格式化的U盘 如果以上两种方法都无效,那就只
  • 一. 问题描述 现在的u盘种类繁多,价格和质量都参差不齐,自己32G的U盘装完系统之后,显示只有3M,无法...1.重新插入U盘,打开U盘显示如图,点击格式化磁盘。 2.开始格式化,但出现Windows无法完成格式化。 ...
  • 格式化成exfat格式 支持4g以上大文件且mac和windows都支持读写 方法: 法1:Mac中操作 Mac中运行 实用工具->磁盘工具,左侧选择磁盘,然后在抹掉栏中...系统提示确认是否格式化,点是就开始格式化硬盘了。 ...
  • 在Mac 下,打开右下角应用程序-实用工具-磁盘工具,里面选取你的移动硬盘,然后进行格式化,设置成EXFat格式就可以了。EXFat是唯一一个同时支持Mac和Windows读取的磁盘格式。 mac如何格式化参考:...
  • 有个蛋疼的需求,客户想在windows操作系统下把移动硬盘格式化成ext3文件系统格式的,而且要求必须格1T的硬盘控制在5min内, 但是尝试了一下其他的工具,以下是两款实现比较快的软件工具的测试, Paragon Partition...
  • 腾讯玄武实验室负责人,人称TK教主的于旸通过微博科普了如何使用Format命令安全删除整个分区的方法。据悉,使用这种方法删除的数据不可能被恢复,安全性佳。 用Windows自带命令擦除整个分区 Windows的Format命令...
  • Linux格式化硬盘

    千次阅读 2016-11-28 10:55:45
    格式化硬盘是指初始化硬盘的文件系统。文件储存在硬盘上,硬盘的最小存储单位叫做”扇区”(Sector)。每个扇区储存512字节(相当于0.5KB)。 linux上的常见的文件系统 ext2 ext3 ext4。1 inode每个文件对应一个...
  • 一句话来说,就是Windows自己的格式化和DiskGenius的都失败的时候,可以试一试用Linux;另一个点在于,在失败的时候要格外注意是不是硬盘的问题,因为可能是接口或者数据线或者供电不稳定等因素导致,别因为其他原因...
  • 之前硬盘用于过linux,格式化过,重新插入到windows下,格式化之后,发现写入非常非常慢。 后面尝试不用快速格式化格式化时候把快速格式化勾去掉,此过程格式化非常慢,需要好几个小时,格式化完成之后,发现写入...
  • 通常Ubuntu下格式化磁盘Windows系统下差不多;先找到U盘图标,右击就有格式化了。但是有一种情况就比较揪心,就是当分区出现问题而不能识别的时候,这时在Win下要专业的工具才能格式化,而在Ubuntu下可以借助命令...
  • windows无法完成格式化U盘与U盘修复对几种解决方法 U盘由于种种不同的原因而格式化失败,提示如“windows无法完成格式化”之类。但是这并不就是意味着U盘就此要废弃了,试一试如下的方法(不过对于不长玩电脑的人...
  • 最近在装系统,U盘弄成了系统盘,但是格式化的时候一直格式化不了,这就很难受啊。偶尔在网上查到了怎么格式化,但是没有记住,又浪费时间去找,这次干脆记录在自己的博客里面。 一、右键点击系统桌面左下角的...
  • Win10怎么把磁盘格式化成exfat格式_使用命令格式化磁盘为exfat的方法 发布时间:2020-03-10 14:24发布者:系统城-liumei浏览数:1100 exFAT是Microsoft在Windows Embeded 5.0以上中引入的一种适合于闪存的文件系统,...
  • windows 命令行进行分区和格式化

    万次阅读 2019-01-25 13:04:11
     台式机, 硬盘931G, 下面是分区计划 ...未分配空间: 231G, 用来安装Linux系统(Linux系统磁盘格式和window不同, 需保留为未分配) 基本步骤 在已经进入操作系统时, win + r -&gt; cmd 进入dos 在...
  • 2、在cmd界面下输入chkdsk K:/f 回车后,硬盘自动修复完成,K为移动硬盘盘符。 //------------------修复完成后还是提示无法访问执行如下------------------ 1、右键移动硬盘,属性--安全,看“组和用户名”,是否...
  • 使用 diskpart 工具格式化硬盘 步骤 1.按 win + r ,输入 diskpart 回车 2. 输入 list disk 找打自己的固态 3. 输入 select disk 2 选择需要格式化硬盘或U盘,2是对应的编号 4. 输入 clean 清理硬盘 5.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 166,603
精华内容 66,641
关键字:

windows格式化磁盘的方法