windows下初始化格式化磁盘

深藏阁楼爱情的钟 2022-05-18 07:44 349阅读 0赞

转载自：[https://blog.csdn.net/wuzuyu365/article/details/52881692][https_blog.csdn.net_wuzuyu365_article_details_52881692]

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

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

![Center][]

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

![Center 1][]

初始化后

![Center 2][]

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

![Center 3][]

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

![Center 4][]

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

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

代码：

CPP：CMDiskManager.cpp

1.  `#include "stdafx.h"`
2.  `#include "CMDiskManager.h"`
3.   
4.  `CMDiskManager::CMDiskManager(){}`
5.   
6.  `//获取磁盘大小,单位是MB`
7.  `int CMDiskManager::GetDiskSize(DWORD vDiskNo)`
8.  `{`
9.  `HANDLE hDevice; // handle to the drive to be examined`
10. `BOOL bResult; // results flag`
11. `DWORD junk; // discard results`
12.  
13. `char diskPath[256]; //磁盘内部路径`
14. `//生成磁盘内部路径`
15. `sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);`
16.  
17. `hDevice = CreateFile(TEXT(diskPath), // drive 或者 用"\\\\.\\PhysicalDrive0" 代表第一块磁盘`
18. `GENERIC_READ, // no access to the drive`
19. `FILE_SHARE_READ | // share mode`
20. `FILE_SHARE_WRITE,`
21. `NULL, // default security attributes`
22. `OPEN_EXISTING, // disposition`
23. `0, // file attributes`
24. `NULL); // do not copy file attributes`
25.  
26. `if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive`
27. `{`
28. `return (FALSE);`
29. `}`
30.  
31. `GET_LENGTH_INFORMATION pdg;`
32. `bResult = DeviceIoControl(hDevice, // device to be queried`
33. `IOCTL_DISK_GET_LENGTH_INFO, // operation to perform`
34. `NULL, 0, // no input buffer`
35. `&pdg, sizeof(pdg), // output buffer`
36. `&junk, // # bytes returned`
37. `(LPOVERLAPPED)NULL); // synchronous I/O`
38.  
39. `CloseHandle(hDevice);`
40.  
41. `/* INT64 nUseSize = disk_len.Length.QuadPart;`
42. `INT64 sizeGB = nUseSize / 1014 / 1024 / 1024;`
43. `CString szSize;`
44. `szSize.Format(L"C盘大小 %I64d GB", sizeGB);`
45. `*/`
46. `int MB = pdg.Length.QuadPart >> 20;`
47. `//CString s;`
48. `//s.Format("C盘大小 %f GB", MB/1024.0);`
49. `//AfxMessageBox(s, 0, MB_OK);`
50. `//float x = (float) MB ;`
51. `return MB ;`
52. `}`
53.  
54.  
55. `/*`
56. `获取磁盘分区个数`
57. `vDiskNo:磁盘序号`
58. `*/`
59. `int CMDiskManager::GetPartNum(DWORD vDiskNo)`
60. `{`
61. `char diskPath[256]; //磁盘内部路径`
62. `//生成磁盘内部路径`
63. `sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);`
64. `HANDLE hDevice; //硬盘句柄 handle to the drive to be examined`
65. `BOOL result; //结果标志 results flag`
66. `DWORD readed; // discard results`
67.  
68. `hDevice = CreateFile(`
69. `diskPath,`
70. `GENERIC_READ | GENERIC_WRITE,`
71. `FILE_SHARE_READ | FILE_SHARE_WRITE,`
72. `NULL, //default security attributes`
73. `OPEN_EXISTING, // disposition`
74. `0, // file attributes`
75. `NULL`
76. `);`
77. `if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive`
78. `{`
79. `fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());`
80. `return int(-1);`
81. `}`
82.  
83. `DRIVE_LAYOUT_INFORMATION_EX* dl;`
84. `DWORD tSize = 0x4000; // sizeof(DRIVE_LAYOUT_INFORMATION_EX) * 10;`
85. `dl = (DRIVE_LAYOUT_INFORMATION_EX*)malloc(tSize);`
86. `if (NULL == dl)`
87. `{`
88. `(void)CloseHandle(hDevice);`
89. `return (int)-2;`
90. `}`
91.  
92. `result = DeviceIoControl(`
93. `hDevice,`
94. `IOCTL_DISK_GET_DRIVE_LAYOUT_EX,`
95. `NULL,`
96. `0,`
97. `dl,`
98. `tSize,`
99. `&readed,`
100. `NULL`
101. `);`
102.  
103. `if (!result)`
104. `{`
105. `fprintf(stderr, "IOCTL_DISK_GET_DRIVE_LAYOUT_EX Error: %ld\n", GetLastError());`
106. `(void)CloseHandle(hDevice);`
107. `return int(-3);`
108. `}`
109.  
110. `CString tPartitionStyle = "RAW";`
111. `switch (dl->PartitionStyle){`
112. `case 0:`
113. `tPartitionStyle = "MBR";`
114. `break;`
115. `case 1:`
116. `tPartitionStyle = "GPT";`
117. `break;`
118. `}`
119.  
120. `//printf("dl->PartitionCount = %d", dl->PartitionCount);`
121. `TRACE("dl->PartitionCount = %d, tPartitionStyle:%s \n", dl->PartitionCount, tPartitionStyle.GetBuffer());`
122.  
123. `//printf("dl->PartitionCount = %d", dl->PartitionCount);`
124. `int tRet = dl->PartitionCount/4;`
125. `//TRACE("dl->PartitionCount tRet = %d", tRet);`
126.  
127. `free(dl);`
128. `(void)CloseHandle(hDevice);`
129.  
130. `return tRet;`
131. `}`
132.  
133. `//读MBR信息`
134. `BOOL CMDiskManager::ReadMBR(int vDiskNo, LPVOID *pBuffer)`
135. `{`
136. `HANDLE hDevice;`
137. `DWORD dwSize;`
138. `DWORD dwOverRead;`
139. `BOOL bRet = TRUE;`
140. `char diskPath[256]; //磁盘内部路径`
141. `//生成磁盘内部路径`
142. `sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);`
143.  
144. `hDevice = CreateFile(TEXT(diskPath),`
145. `GENERIC_READ | GENERIC_WRITE,`
146. `FILE_SHARE_READ | FILE_SHARE_WRITE,`
147. `NULL,`
148. `OPEN_EXISTING,`
149. `0,`
150. `NULL);`
151. `if (hDevice == INVALID_HANDLE_VALUE) {`
152. `TRACE("Open \\\\.\\PhysicalDrive failed. Error=%u\n", GetLastError());`
153. `return FALSE;`
154. `}`
155.  
156. `if (!DeviceIoControl(hDevice, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0, &dwSize, NULL)) {`
157. `CloseHandle(hDevice);`
158. `TRACE("FSCTL_LOCK_VOLUME \\\\.\\PhysicalDrive0 failed. Error=%u\n", GetLastError());`
159. `return FALSE;`
160. `}`
161.  
162. `DISK_GEOMETRY Geometry;`
163. `if (!DeviceIoControl(hDevice, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &Geometry, sizeof(DISK_GEOMETRY), &dwSize, NULL)) {`
164. `bRet = FALSE;`
165. `TRACE("IOCTL_DISK_GET_DRIVE_GEOMETRY \\\\.\\PhysicalDrive0 failed. Error=%u\n", GetLastError());`
166. `goto _out;`
167. `}`
168.  
169. `*pBuffer = (LPVOID)GlobalAlloc(GPTR, Geometry.BytesPerSector);`
170. `if (*pBuffer) {`
171. `if (!ReadFile(hDevice, *pBuffer, Geometry.BytesPerSector, &dwOverRead, NULL)) {`
172. `printf("ReadFile \\\\.\\PhysicalDrive %u bytes failed. Error=%u\n", Geometry.BytesPerSector, GetLastError());`
173. `bRet = FALSE;`
174. `}`
175. `}`
176.  
177. `_out:`
178. `DeviceIoControl(hDevice, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0, &dwSize, NULL);`
179. `CloseHandle(hDevice);`
180. `return bRet;`
181.  
182. `}`
183.  
184.  
185. `/*`
186. `获取磁盘分区信息`
187. `vDiskNo:磁盘序号`
188. `*/`
189. `DWORD CMDiskManager::GetLayoutInfo(DWORD vDiskNo)`
190. `{`
191. `char diskPath[256]; //磁盘内部路径`
192. `//生成磁盘内部路径`
193. `sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);`
194. `HANDLE hDevice; //硬盘句柄 handle to the drive to be examined`
195. `BOOL result; //结果标志 results flag`
196. `DWORD readed; // discard results`
197.  
198. `hDevice = CreateFile(`
199. `diskPath,`
200. `GENERIC_READ | GENERIC_WRITE,`
201. `FILE_SHARE_READ | FILE_SHARE_WRITE,`
202. `NULL, //default security attributes`
203. `OPEN_EXISTING, // disposition`
204. `0, // file attributes`
205. `NULL`
206. `);`
207. `if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive`
208. `{`
209. `fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());`
210. `return DWORD(-1);`
211. `}`
212.  
213. `DRIVE_LAYOUT_INFORMATION_EX* dl;`
214. `DWORD tSize = 0x4000; // sizeof(DRIVE_LAYOUT_INFORMATION_EX) * 10;`
215. `dl = (DRIVE_LAYOUT_INFORMATION_EX*)malloc(tSize);`
216. `if (NULL == dl)`
217. `{`
218. `(void)CloseHandle(hDevice);`
219. `return (WORD)-1;`
220. `}`
221.  
222. `result = DeviceIoControl(`
223. `hDevice,`
224. `IOCTL_DISK_GET_DRIVE_LAYOUT_EX,`
225. `NULL,`
226. `0,`
227. `dl,`
228. `tSize,`
229. `&readed,`
230. `NULL`
231. `);`
232.  
233. `if (!result)`
234. `{`
235. `fprintf(stderr, "IOCTL_DISK_GET_DRIVE_LAYOUT_EX Error: %ld\n", GetLastError());`
236. `(void)CloseHandle(hDevice);`
237. `return DWORD(-1);`
238. `}`
239.  
240. `CString tPartitionStyle = "RAW";`
241. `switch (dl->PartitionStyle){`
242. `case 0:`
243. `tPartitionStyle = "MBR";`
244. `break;`
245. `case 1:`
246. `tPartitionStyle = "GPT";`
247. `break;`
248. `}`
249.  
250. `//printf("dl->PartitionCount = %d", dl->PartitionCount);`
251. `TRACE("dl->PartitionCount = %d, tPartitionStyle:%s", dl->PartitionCount, tPartitionStyle.GetBuffer());`
252.  
253. `free(dl);`
254. `(void)CloseHandle(hDevice);`
255.  
256. `return 0;`
257. `}`
258.  
259. `/*`
260. `初始化磁盘，创建分区`
261. `vDiskNo:磁盘序号，千万要避开系统盘，系统盘一般是0`
262. `vPartNum:分区数，只要1个分区就可以了`
263. `*/`
264. `DWORD CMDiskManager::CreateDisk(DWORD vDiskNo, WORD vPartNum)`
265. `{`
266. `printf("准备CreateDisk, vDiskNo=%d, vPartNum=%d \n", vDiskNo, vPartNum);`
267.  
268. `//第0块磁盘是系统盘，不能格式化掉！！！但不排除某些情况下新插入的移动硬盘会是第0块磁盘`
269. `if (0 == vDiskNo){`
270. `printf("第0块磁盘是系统盘，不能格式化掉\n");`
271. `return 0;`
272. `}`
273.  
274. `HANDLE hDevice; //硬盘句柄 handle to the drive to be examined`
275. `BOOL result; //结果标志 results flag`
276. `DWORD readed; // discard results`
277. `DWORD ret;`
278. `WORD i;`
279. `char diskPath[256]; //磁盘内部路径`
280. `DISK_GEOMETRY pdg;`
281. `DWORD sectorSize; //扇区大小`
282. `DWORD signature; //签名`
283. `LARGE_INTEGER diskSize; //磁盘大小`
284. `LARGE_INTEGER partSize; //分区大小`
285. `BYTE actualPartNum; //实际上的分区数`
286.  
287. `DWORD layoutStructSize; //`
288. `DRIVE_LAYOUT_INFORMATION_EX *dl; //磁盘分区信息`
289. `CREATE_DISK newDisk; //创建磁盘（初始化？）`
290.  
291. `//生成磁盘内部路径`
292. `sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);`
293.  
294. `actualPartNum = 4;`
295. `if (vPartNum > actualPartNum)`
296. `{`
297. `printf("vPartNum > 4\n");`
298. `return (WORD)-1;`
299. `}`
300.  
301. `hDevice = CreateFile(`
302. `diskPath,`
303. `GENERIC_READ | GENERIC_WRITE,`
304. `FILE_SHARE_READ | FILE_SHARE_WRITE,`
305. `NULL, //default security attributes`
306. `OPEN_EXISTING, // disposition`
307. `0, // file attributes`
308. `NULL`
309. `);`
310. `if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive`
311. `{`
312. `fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());`
313. `return DWORD(-1);`
314. `}`
315.  
316. `// Create primary partition MBR`
317. `//创建主分区的MBR`
318. `printf("创建主分区的MBR\n");`
319.  
320. `newDisk.PartitionStyle = PARTITION_STYLE_MBR;`
321. `signature = (DWORD)time(0); // 原为time(NULL), get signature from current time`
322. `newDisk.Mbr.Signature = signature;`
323.  
324. `result = DeviceIoControl(`
325. `hDevice,`
326. `IOCTL_DISK_CREATE_DISK,`
327. `&newDisk,`
328. `sizeof(CREATE_DISK),`
329. `NULL,`
330. `0,`
331. `&readed,`
332. `NULL`
333. `);`
334. `if (!result)`
335. `{`
336. `fprintf(stderr, "IOCTL_DISK_CREATE_DISK Error: %ld\n", GetLastError());`
337. `(void)CloseHandle(hDevice);`
338. `return DWORD(-1);`
339. `}`
340.  
341. `//fresh the partition table`
342. `//刷新分区表`
343. `printf("刷新分区表\n");`
344. `result = DeviceIoControl(`
345. `hDevice,`
346. `IOCTL_DISK_UPDATE_PROPERTIES,`
347. `NULL,`
348. `0,`
349. `NULL,`
350. `0,`
351. `&readed,`
352. `NULL`
353. `);`
354. `if (!result)`
355. `{`
356. `fprintf(stderr, "IOCTL_DISK_UPDATE_PROPERTIES Error: %ld\n", GetLastError());`
357. `(void)CloseHandle(hDevice);`
358. `return DWORD(-1);`
359. `}`
360.  
361. `//Now create the partitions`
362. `//现在创建分区`
363. `ret = GetDriveGeometry(vDiskNo, &pdg);`
364. `if ((DWORD)-1 == ret)`
365. `{`
366. `return ret;`
367. `}`
368.  
369. `//扇区大小`
370. `sectorSize = pdg.BytesPerSector;`
371. `diskSize.QuadPart = pdg.Cylinders.QuadPart * pdg.TracksPerCylinder *`
372. `pdg.SectorsPerTrack * pdg.BytesPerSector; //calculate the disk size;`
373. `partSize.QuadPart = diskSize.QuadPart / vPartNum;`
374.  
375. `//分区结构大小`
376. `layoutStructSize = sizeof(DRIVE_LAYOUT_INFORMATION_EX) + (actualPartNum - 1) * sizeof(PARTITION_INFORMATION_EX);`
377. `dl = (DRIVE_LAYOUT_INFORMATION_EX*)malloc(layoutStructSize);`
378. `if (NULL == dl)`
379. `{`
380. `(void)CloseHandle(hDevice);`
381. `return (WORD)-1;`
382. `}`
383.  
384. `dl->PartitionStyle = (DWORD)PARTITION_STYLE_MBR;`
385. `dl->PartitionCount = actualPartNum;`
386. `dl->Mbr.Signature = signature;`
387.  
388. `//clear the unused partitions`
389. `//清除未用的分区`
390. `printf("清除未用的分区\n");`
391. `for (i = 0; i < actualPartNum; i++){`
392. `dl->PartitionEntry[i].RewritePartition = 1;`
393. `dl->PartitionEntry[i].Mbr.PartitionType = PARTITION_ENTRY_UNUSED;`
394. `}`
395.  
396. `//set the profile of the partitions`
397. `for (i = 0; i < vPartNum; i++){`
398. `dl->PartitionEntry[i].PartitionStyle = PARTITION_STYLE_MBR;`
399. `dl->PartitionEntry[i].StartingOffset.QuadPart =`
400. `(partSize.QuadPart * i) + ((LONGLONG)(pdg.SectorsPerTrack) * (LONGLONG)(pdg.BytesPerSector)); //32256`
401. `dl->PartitionEntry[i].PartitionLength.QuadPart = partSize.QuadPart;`
402. `dl->PartitionEntry[i].PartitionNumber = i + 1;`
403. `dl->PartitionEntry[i].RewritePartition = TRUE;`
404. `dl->PartitionEntry[i].Mbr.PartitionType = PARTITION_IFS;`
405. `dl->PartitionEntry[i].Mbr.BootIndicator = FALSE;`
406. `dl->PartitionEntry[i].Mbr.RecognizedPartition = TRUE;`
407. `dl->PartitionEntry[i].Mbr.HiddenSectors =`
408. `pdg.SectorsPerTrack + (DWORD)((partSize.QuadPart / sectorSize) * i);`
409. `}`
410. `//execute the layout`
411. `result = DeviceIoControl(`
412. `hDevice,`
413. `IOCTL_DISK_SET_DRIVE_LAYOUT_EX,`
414. `dl,`
415. `layoutStructSize,`
416. `NULL,`
417. `0,`
418. `&readed,`
419. `NULL`
420. `);`
421. `if (!result)`
422. `{`
423. `fprintf(stderr, "IOCTL_DISK_SET_DRIVE_LAYOUT_EX Error: %ld\n", GetLastError());`
424. `free(dl);`
425. `(void)CloseHandle(hDevice);`
426. `return DWORD(-1);`
427. `}`
428.  
429. `//fresh the partition table`
430. `printf("刷新分区表\n");`
431. `result = DeviceIoControl(`
432. `hDevice,`
433. `IOCTL_DISK_UPDATE_PROPERTIES,`
434. `NULL,`
435. `0,`
436. `NULL,`
437. `0,`
438. `&readed,`
439. `NULL`
440. `);`
441. `if (!result)`
442. `{`
443. `fprintf(stderr, "IOCTL_DISK_UPDATE_PROPERTIES Error: %ld\n", GetLastError());`
444. `free(dl);`
445. `(void)CloseHandle(hDevice);`
446. `return DWORD(-1);`
447. `}`
448.  
449. `free(dl);`
450. `(void)CloseHandle(hDevice);`
451. `printf("CreateDisk完成\n");`
452. `Sleep(3000); //wait the operations take effect`
453. `return 0;`
454. `}`
455.  
456.  
457. `//获取磁盘几何信息`
458. `BOOL CMDiskManager::GetDriveGeometry(DWORD vDiskNo, DISK_GEOMETRY *pdg)`
459. `{`
460. `HANDLE hDevice; // handle to the drive to be examined`
461. `BOOL bResult; // results flag`
462. `DWORD junk; // discard results`
463.  
464. `char diskPath[256]; //磁盘内部路径`
465. `sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);`
466.  
467. `hDevice = CreateFile(TEXT(diskPath), // drive`
468. `0, // no access to the drive`
469. `FILE_SHARE_READ | // share mode`
470. `FILE_SHARE_WRITE,`
471. `NULL, // default security attributes`
472. `OPEN_EXISTING, // disposition`
473. `0, // file attributes`
474. `NULL); // do not copy file attributes`
475.  
476. `if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive`
477. `{`
478. `return (FALSE);`
479. `}`
480.  
481. `bResult = DeviceIoControl(hDevice, // device to be queried`
482. `IOCTL_DISK_GET_DRIVE_GEOMETRY, // operation to perform`
483. `NULL, 0, // no input buffer`
484. `pdg, sizeof(*pdg), // output buffer`
485. `&junk, // # bytes returned`
486. `(LPOVERLAPPED)NULL); // synchronous I/O`
487.  
488. `CloseHandle(hDevice);`
489.  
490. `return (bResult);`
491. `}`
492.  
493.  
494. `/******************************************************************************`
495. `* Function: delete the partition layout of the disk`
496. `删除磁盘分区信息（恢复出厂设置）`
497. `* input: disk, disk name`
498. `* output: N/A`
499. `* return: Succeed, 0`
500. `* Fail, -1`
501. `******************************************************************************/`
502. `DWORD CMDiskManager::DestroyDisk(DWORD vDiskNo)`
503. `{`
504. `if (0 == vDiskNo){`
505. `//系统盘是0号盘，为了安全，不能删除`
506. `return 0;`
507. `}`
508.  
509. `HANDLE hDevice; // handle to the drive to be examined`
510. `BOOL result; // results flag`
511. `DWORD readed; // discard results`
512. `CHAR diskPath[256];`
513.  
514. `sprintf(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);`
515.  
516. `hDevice = CreateFile(`
517. `diskPath, // drive to open`
518. `GENERIC_READ | GENERIC_WRITE, // access to the drive`
519. `FILE_SHARE_READ | FILE_SHARE_WRITE, //share mode`
520. `NULL, // default security attributes`
521. `OPEN_EXISTING, // disposition`
522. `0, // file attributes`
523. `NULL // do not copy file attribute`
524. `);`
525. `if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive`
526. `{`
527. `fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());`
528. `return DWORD(-1);`
529. `}`
530.  
531. `result = DeviceIoControl(`
532. `hDevice, // handle to device`
533. `IOCTL_DISK_DELETE_DRIVE_LAYOUT, // dwIoControlCode`
534. `NULL, // lpInBuffer`
535. `0, // nInBufferSize`
536. `NULL, // lpOutBuffer`
537. `0, // nOutBufferSize`
538. `&readed, // number of bytes returned`
539. `NULL // OVERLAPPED structure`
540. `);`
541. `if (!result)`
542. `{`
543. `//fprintf(stderr, "IOCTL_DISK_DELETE_DRIVE_LAYOUT Error: %ld\n", GetLastError());`
544. `(void)CloseHandle(hDevice);`
545. `return DWORD(-1);`
546. `}`
547.  
548. `//fresh the partition table`
549. `result = DeviceIoControl(`
550. `hDevice,`
551. `IOCTL_DISK_UPDATE_PROPERTIES,`
552. `NULL,`
553. `0,`
554. `NULL,`
555. `0,`
556. `&readed,`
557. `NULL`
558. `);`
559. `if (!result)`
560. `{`
561. `fprintf(stderr, "IOCTL_DISK_UPDATE_PROPERTIES Error: %ld\n", GetLastError());`
562. `(void)CloseHandle(hDevice);`
563. `return DWORD(-1);`
564. `}`
565.  
566. `(void)CloseHandle(hDevice);`
567. `return 0;`
568. `}`
569.  
570. `/******************************************************************************`
571. `* Function:快速格式化某个磁盘，文件系统NTFS，`
572. `如果在CreateDisk()创建磁盘后，磁盘的文件系统是RAW的话，才需要调用该函数`
573. `* input: disk, disk name`
574. `* output: N/A`
575. `* return: Succeed, 0`
576. `* Fail, 1`
577. `******************************************************************************/`
578. `DWORD CMDiskManager::FormatVolume(CHAR letter)`
579. `{`
580. `DWORD ret;`
581. `CHAR cmd[64];`
582. `sprintf(cmd, "format %c: /FS:NTFS /Q /Y", letter);`
583. `ret = (DWORD)system(cmd);`
584. `return ret;`
585. `}`
586.  
587. `//获取第dwNum个磁盘的信息`
588. `void CMDiskManager::GetDiskInfo(DWORD &dwNum, CString chDriveInfo[])`
589. `{`
590. `DWORD DiskCount = 0;`
591.  
592. `//利用GetLogicalDrives()函数可以获取系统中逻辑驱动器的数量，函数返回的是一个32位无符号整型数据。`
593. `DWORD DiskInfo = GetLogicalDrives();`
594.  
595. `//通过循环操作查看每一位数据是否为1，如果为1则磁盘为真,如果为0则磁盘不存在。`
596. `while (DiskInfo)`
597. `{`
598. `//通过位运算的逻辑与操作，判断是否为1`
599. `Sleep(10);`
600. `if (DiskInfo & 1)`
601. `{`
602. `DiskCount++;`
603. `}`
604. `DiskInfo = DiskInfo >> 1;//通过位运算的右移操作保证每循环一次所检查的位置向右移动一位。*/`
605. `}`
606.  
607. `if (dwNum < DiskCount)`
608. `{`
609. `return;//实际的磁盘数目大于dwNum`
610. `}`
611. `dwNum = DiskCount;//将磁盘分区数量保存`
612.  
613.  
614. `//-------------------------------------------------------------------//`
615. `//通过GetLogicalDriveStrings()函数获取所有驱动器字符串信息长度`
616. `int DSLength = GetLogicalDriveStrings(0, NULL);`
617.  
618. `CHAR* DStr = new CHAR[DSLength];`
619. `memset(DStr, 0, DSLength);`
620.  
621. `//通过GetLogicalDriveStrings将字符串信息复制到堆区数组中,其中保存了所有驱动器的信息。`
622. `GetLogicalDriveStrings(DSLength, DStr);`
623.  
624. `int DType;`
625. `int si = 0;`
626. `BOOL fResult;`
627. `unsigned _int64 i64FreeBytesToCaller;`
628. `unsigned _int64 i64TotalBytes;`
629. `unsigned _int64 i64FreeBytes;`
630.  
631. `//读取各驱动器信息，由于DStr内部数据格式是A:\NULLB:\NULLC:\NULL，所以DSLength/4可以获得具体大循环范围`
632. `for (int i = 0; i<DSLength / 4; ++i)`
633. `{`
634. `Sleep(10);`
635. `CString strdriver = DStr + i * 4;`
636. `CString strTmp, strTotalBytes, strFreeBytes;`
637. `DType = GetDriveType(strdriver);//GetDriveType函数，可以获取驱动器类型，参数为驱动器的根目录`
638. `switch (DType)`
639. `{`
640. `case DRIVE_FIXED:`
641. `{`
642. `strTmp.Format(_T("本地磁盘"));`
643. `}`
644. `break;`
645. `case DRIVE_CDROM:`
646. `{`
647. `strTmp.Format(_T("DVD驱动器"));`
648. `}`
649. `break;`
650. `case DRIVE_REMOVABLE:`
651. `{`
652. `strTmp.Format(_T("可移动磁盘"));`
653. `}`
654. `break;`
655. `case DRIVE_REMOTE:`
656. `{`
657. `strTmp.Format(_T("网络磁盘"));`
658. `}`
659. `break;`
660. `case DRIVE_RAMDISK:`
661. `{`
662. `strTmp.Format(_T("虚拟RAM磁盘"));`
663. `}`
664. `break;`
665. `case DRIVE_UNKNOWN:`
666. `{`
667. `strTmp.Format(_T("虚拟RAM未知设备"));`
668. `}`
669. `break;`
670. `default:`
671. `strTmp.Format(_T("未知设备"));`
672. `break;`
673. `}`
674.  
675. `//GetDiskFreeSpaceEx函数，可以获取驱动器磁盘的空间状态,函数返回的是个BOOL类型数据`
676. `fResult = GetDiskFreeSpaceEx(strdriver,`
677. `(PULARGE_INTEGER)&i64FreeBytesToCaller,`
678. `(PULARGE_INTEGER)&i64TotalBytes,`
679. `(PULARGE_INTEGER)&i64FreeBytes);`
680.  
681. `if (fResult)`
682. `{`
683. `strTotalBytes.Format(_T("磁盘总容量%.2fMB"), (float)i64TotalBytes / 1024 / 1024);`
684. `strFreeBytes.Format(_T("磁盘剩余空间%.2fMB"), (float)i64FreeBytesToCaller / 1024 / 1024);`
685. `}`
686. `else`
687. `{`
688. `strTotalBytes.Format(_T(""));`
689. `strFreeBytes.Format(_T(""));`
690. `}`
691. `chDriveInfo[i] = strTmp + _T("(") + strdriver + _T("):") + strTotalBytes + ", " +strFreeBytes;`
692. `si += 4;`
693. `}`
694. `}`
695.  
696.  
697. `/******************************************************************************`
698.  
699. `* Function: get disk's physical number from its drive letter`
700. `根据逻辑盘符找到物理硬盘号`
701.  
702. `* e.g. C-->0 (C: is on disk0)`
703.  
704. `* input: letter, drive letter`
705.  
706. `* output: N/A`
707.  
708. `* return: Succeed, disk number`
709.  
710. `* Fail, -1`
711.  
712. `******************************************************************************/`
713.  
714. `//根据逻辑盘符找到物理硬盘号`
715. `DWORD CMDiskManager::GetPhysicalDriveFromPartitionLetter(CHAR letter)`
716. `{`
717. `HANDLE hDevice; // handle to the drive to be examined`
718.  
719. `BOOL result; // results flag`
720.  
721. `DWORD readed; // discard results`
722.  
723. `STORAGE_DEVICE_NUMBER number; //use this to get disk numbers`
724.  
725. `CHAR path[256];`
726.  
727. `sprintf(path, "\\\\.\\%c:", letter);`
728.  
729. `hDevice = CreateFile(path, // drive to open`
730.  
731. `GENERIC_READ | GENERIC_WRITE, // access to the drive`
732.  
733. `FILE_SHARE_READ | FILE_SHARE_WRITE, //share mode`
734.  
735. `NULL, // default security attributes`
736.  
737. `OPEN_EXISTING, // disposition`
738.  
739. `0, // file attributes`
740.  
741. `NULL); // do not copy file attribute`
742.  
743. `if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive`
744.  
745. `{`
746.  
747. `fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());`
748.  
749. `return DWORD(-1);`
750. `}`
751.  
752. `result = DeviceIoControl(`
753.  
754. `hDevice, // handle to device`
755.  
756. `IOCTL_STORAGE_GET_DEVICE_NUMBER, // dwIoControlCode`
757.  
758. `NULL, // lpInBuffer`
759.  
760. `0, // nInBufferSize`
761.  
762. `&number, // output buffer`
763.  
764. `sizeof(number), // size of output buffer`
765.  
766. `&readed, // number of bytes returned`
767.  
768. `NULL // OVERLAPPED structure`
769.  
770. `);`
771.  
772. `if (!result) // fail`
773. `{`
774.  
775. `fprintf(stderr, "IOCTL_STORAGE_GET_DEVICE_NUMBER Error: %ld\n", GetLastError());`
776.  
777. `(void)CloseHandle(hDevice);`
778.  
779. `return (DWORD)-1;`
780. `}`
781.  
782. `//printf("%d %d %d\n\n", number.DeviceType, number.DeviceNumber, number.PartitionNumber);`
783.  
784. `(void)CloseHandle(hDevice);`
785.  
786. `return number.DeviceNumber;`
787.  
788. `}`
789.  
790. `/******************************************************************************`
791.  
792. `* Function: get disk's drive letters from physical number`
793. `获取一个物理硬盘上的所有盘符`
794. `* e.g. 0-->{C, D, E} (disk0 has 3 drives, C:, D: and E:)`
795.  
796. `* input: vDiskNo, disk's physical number`
797.  
798. `* output: letters, letters array`
799.  
800. `* return: Succeed, the amount of letters`
801.  
802. `* Fail, -1`
803.  
804. `******************************************************************************/`
805.  
806. `CString CMDiskManager::GetPartitionLetterFromPhysicalDrive(DWORD vDiskNo)`
807. `{`
808. `DWORD mask;`
809. `DWORD driveType;`
810. `DWORD bmLetters;`
811. `DWORD diskNumber;`
812. `CHAR path[256];`
813. `CHAR letter;`
814. `DWORD letterNum;`
815. `WORD i;`
816. `CHAR *p;`
817. `CString tRet = "";`
818.  
819. `bmLetters = GetLogicalDrives();`
820.  
821. `if (0 == bmLetters)`
822. `{`
823. `return "";`
824. `}`
825.  
826. `letterNum = 0;`
827.  
828. `for (i = 0; i < sizeof(DWORD) * 8; i++)`
829. `{`
830. `mask = 0x1u << i;`
831.  
832. `if ((mask & bmLetters) == 0) //get one letter`
833. `{`
834. `continue;`
835. `}`
836.  
837. `letter = (CHAR)(0x41 + i); //ASCII change`
838.  
839. `sprintf(path, "%c:\\", letter);`
840.  
841. `driveType = GetDriveType(path);`
842.  
843. `if (driveType != DRIVE_FIXED)`
844. `{`
845. `bmLetters &= ~mask; //clear this bit`
846. `continue;`
847. `}`
848.  
849. `diskNumber = GetPhysicalDriveFromPartitionLetter(letter);`
850.  
851. `if (diskNumber != vDiskNo)`
852. `{`
853. `bmLetters &= ~mask; //clear this bit`
854.  
855. `continue;`
856. `}`
857.  
858. `letterNum++;`
859. `}`
860.  
861. `//build the result`
862.  
863. `/*letters = (CHAR *)malloc(letterNum);`
864.  
865. `if (NULL == *letters)`
866. `{`
867. `return (DWORD)-1;`
868. `}`
869.  
870. `p = *letters;`
871. `*/`
872. `CString s;`
873. `for (i = 0; i < sizeof(DWORD) * 8; i++)`
874. `{`
875. `mask = 0x1u << i;`
876.  
877. `if ((mask & bmLetters) == 0)`
878. `{`
879. `continue;`
880. `}`
881.  
882. `letter = (CHAR)(0x41 + i); //ASCII change`
883. `s.Format("%c", letter);`
884. `if (!tRet.IsEmpty()){`
885. `tRet += ",";`
886. `}`
887. `tRet += s + ":";`
888.  
889. `}`
890.  
891. `return tRet;`
892. `}`

头文件：CMDiskManager.h

1.  `#include <windows.h>`
2.  `#include <winioctl.h>`
3.  `#include <stdio.h>`
4.  `#include "time.h"`
5.   
6.  `#include <stdlib.h>`
7.  `#include <tchar.h>`
8.   
9.  `#pragma pack(1)`
10.  
11. `#define MAX_MBR_PARTITIONS 4`
12. `#define MBR_DISK_SIGNATURE_OFFSET 440`
13. `#define MBR_DISK_PPT_OFFSET 446`
14. `#define MBR_SIGNATURE_OFFSET 510`
15.  
16. `//`
17. `// MBR Partition Entry`
18. `//`
19. `typedef struct {`
20. `UINT8 BootIndicator;`
21. `UINT8 StartHead;`
22. `UINT8 StartSector;`
23. `UINT8 StartTrack;`
24. `UINT8 OSType;`
25. `UINT8 EndHead;`
26. `UINT8 EndSector;`
27. `UINT8 EndTrack;`
28. `UINT32 StartingLBA;`
29. `UINT32 SizeInLBA;`
30. `} MBR_PARTITION_RECORD;`
31.  
32. `//`
33. `// MBR Partition table`
34. `//`
35. `typedef struct {`
36. `UINT8 BootCode[440];`
37. `UINT32 UniqueMbrSignature;`
38. `UINT16 Unknown;`
39. `MBR_PARTITION_RECORD PartitionRecord[MAX_MBR_PARTITIONS];`
40. `UINT16 Signature;`
41. `} MASTER_BOOT_RECORD;`
42.  
43. `#pragma pack()`
44.  
45. `#define MBR_SIGNATURE 0xAA55`
46. `#define EXTENDED_DOS_PARTITION 0x05`
47. `#define EXTENDED_WINDOWS_PARTITION 0x0F`
48.  
49.  
50. `class CMDiskManager {`
51.  
52. `public:`
53.  
54. `CMDiskManager();`
55.  
56. `//获取磁盘几何`
57. `BOOL GetDriveGeometry(DWORD vDiskNo, DISK_GEOMETRY *pdg);`
58.  
59. `//获取磁盘大小,单位是MB`
60. `int GetDiskSize(DWORD vDiskNo);`
61.  
62. `/*`
63. `获取磁盘分区信息`
64. `vDiskNo:磁盘序号`
65. `*/`
66. `DWORD GetLayoutInfo(DWORD vDiskNo);`
67.  
68. `//读MBR信息`
69. `BOOL ReadMBR(int vDiskNo, LPVOID *pBuffer);`
70.  
71. `/*`
72. `获取磁盘分区个数`
73. `vDiskNo:磁盘序号`
74. `*/`
75. `int GetPartNum(DWORD vDiskNo);`
76.  
77. `/*`
78. `初始化磁盘，创建分区`
79. `vDiskNo:磁盘序号，千万要避开系统盘，系统盘一般是0`
80. `vPartNum:分区数，只要1个分区就可以了`
81. `*/`
82. `DWORD CreateDisk(DWORD vDiskNo, WORD vPartNum);`
83.  
84. `/*`
85. `回复磁盘到空白状态，删除MBR分区信息`
86. `*/`
87. `DWORD DestroyDisk(DWORD vDiskNo);`
88.  
89. `};`

如果CreateDisk之后文件系统格式还是RAW的，那么可以用这个：

1.  `/******************************************************************************`
2.  `* Function:快速格式化某个磁盘，文件系统NTFS`
3.  `* input: disk, disk name`
4.  `* output: N/A`
5.  `* return: Succeed, 0`
6.  `* Fail, 1`
7.  `******************************************************************************/`
8.  `DWORD CMDiskManager::FormatVolume(CHAR letter)`
9.  `{`
10. `DWORD ret;`
11. `CHAR cmd[64];`
12. `sprintf(cmd, "format %c: /FS:NTFS /Q /Y", letter);`
13. `ret = (DWORD)system(cmd);`
14. `return ret;`
15. `}`

[https_blog.csdn.net_wuzuyu365_article_details_52881692]: https://blog.csdn.net/wuzuyu365/article/details/52881692
[Center]: /images/20220518/633da993e669448988fc2e0d7a17916f.png
[Center 1]: /images/20220518/0d121f29ac10414ca4385ac78d962ffa.png
[Center 2]: /images/20220518/23cb10c407d04d779fa1ba8b0019e25a.png
[Center 3]: /images/20220518/299606dc0a714809998345d8deaef587.png
[Center 4]: /images/20220518/22e4bd9ee9bb460eab275a700e8efb4a.png