精华内容
下载资源
问答
  • 在本篇内容里小编整理了关于易语言初始化的方法和步骤,有需要的朋友们可以参考下。
  • 初始化即是最初的出厂状态。格式化就是把一张空白的盘划分成一个个小的区域,并编号,供计算机储存,读取数据。没有这个工作的话,计算机就不知道在哪写,从哪读。
    初始化即是最初的出厂状态。格式化就是把一张空白的盘划分成一个个小的区域,并编号,供计算机储存,读取数据。没有这个工作的话,计算机就不知道在哪写,从哪读。
    展开全文
  • 初始化日期格式

    2019-09-29 20:09:17
    Application.UpdateFormatSettings := ... //保证格式运行中不变。//目前,这行,只支持 VCL。 with FormatSettings do begin ShortDateFormat := 'yyyy-mm-dd'; LongDateFormat := 'yyyy-mm-dd'; ShortTimeFormat :...

    Application.UpdateFormatSettings := False; //保证格式运行中不变。//目前,这行,只支持 VCL。
    with FormatSettings do
    begin
    ShortDateFormat := 'yyyy-mm-dd';
    LongDateFormat := 'yyyy-mm-dd';
    ShortTimeFormat := 'hh:nn:ss';
    LongTimeFormat := 'hh:nn:ss';
    DateSeparator := '-';
    TimeSeparator := ':';
    end;

    转载于:https://www.cnblogs.com/maweiwei/p/11265970.html

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

    万次阅读 2016-10-21 11:38:29
    新买来的硬盘是未初始化的,以我的理解就是没有引导扇区的,通常是没有MBR,如下图磁盘1,右边有大小,但显示“未分配”, 左边显示“没有初始化”, 点鼠标右键就可以【初始化磁盘】。 初始化时可以...

    新买来的硬盘是未初始化的,以我的理解就是没有引导扇区的,通常是没有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;
    }







    展开全文
  • 初始化并不等同于格式化,但是初始化格式化都会清除磁盘数据。在对磁盘进行初始化格式化之前,我们都需要先进行数据的备份。 初始化格式化的异同 初始化一般会清除目标分区中的文件,一般是指在导入或激活...

    初始化并不等同于格式化,但是初始化和格式化都会清除磁盘数据。在对磁盘进行初始化和格式化之前,我们都需要先进行数据的备份。

    在这里插入图片描述

    初始化和格式化的异同

    初始化一般会清除目标分区中的文件,一般是指在导入或激活硬盘中清除磁盘或者磁盘中的分区。
    在日常生活中,格式化硬盘中的格式化是高级格式化。低级格式化也被称为初始化,硬盘制造商把低级格式化看作是创造硬盘扇区的操作,这种操作让硬盘具有储存能力,是一种损耗性的操作,会影响硬盘的使用寿命。

    一块可以正常使用的硬盘经历了初始化、分区和格式化,基本上在出厂售卖前就完成了,可以让我们直接分区使用,硬盘在使用过程中也可能需要初始化。
    而硬盘的主引导记录损坏、硬盘盒的主控出现了问题、硬盘出现坏道等其它物理故障、数据线或USB接口接触不良、电脑供电不足等原因都会导致需要初始化的硬盘提示。

    在这里插入图片描述

    磁盘初始化后的数据如何恢复

    当您的磁盘发生了未知未初始化的问题,可行的办法是先进行初始化,再利用第三方硬盘恢复软件恢复。数据蛙数据恢复专家软件擅长恢复恢复初始化的硬盘,同时保护您的数据,做到安全地数据恢复。
    使用合适的数据线将外置移动硬盘驱动器连接至计算机,如果您的硬盘是内部驱动器就可以省略这一步操作。下载安装好数据蛙数据恢复专家软件后,在主界面进行磁盘数据恢复。
    如果您的磁盘数据丢失是快速格式化、分区或删除引起的,可以切换到【丢失文件分区】,在扫描后检查结果。

    硬盘读取不了需要格式化?本文给你讲解了一下格式化和初始化的异同,相信你有一定的收获。

    展开全文
  • el-date-picker初始化格式化

    千次阅读 2020-06-29 15:56:27
    上代码: <el-form-item :label="$g('开始时间')"> <el-date-picker v-model="condition.s_eddt" type="datetime" :placeholder="$g('开始时间')" value-format="yyyy-MM-dd HH:mm:ss" default-time="00...
  • 使用字符串初始化DateString dateString = “2018-02-23”;Date date= new SimpleDateFormat(“yyyy-MM-dd”).parse(dateString);使用时间戳初始化Date date = new Date(时间戳);计算两个日期相差天数long day = ...
  • 学习过程中 , 有时候我们的集群存储空间会满 , 这时候我们可以一个一个删除文件 , 也可以直接格式化集群 , 这样比较方便 , 下面详细介绍个格式化集群的步骤方法: 第一步:先将集群关闭 第二步:删除datanode ...
  • 在很多情况下,机器或设备要求某种或某一格式初始化参数,以便它能进入基本准备状态。每次用手输入这些数据是很慢的,而且容易出错。本文介绍的是机器设备通电时的PLC控制系统自动初始化
  • matlab将图片自动转化为Altera的rom的初始化文件MIF格式,用于FPGA图像处理
  • 数组的概念:是一种容器可以同时存储多个数据值 ...1、动态初始化数组的格式: 数据类型[]数组名称 = new 数据类型[数组长度]; 注意:左右两侧的数据类型需要保持一致 静态初始化数组的格式: 数据类型[]数组名称 = ne
  • //第一种初始化方式:【注意使用这种初始化的时候如果是png格式的可以不给后缀名,根据屏幕的的分辨率去匹配图片】 UIImage *image = [UIImage imageNamed:@v_red_heart_selected]; //第二种初始化方式:【必须拼接...
  • 文章目录【Java语言基础】初始化块使用初始化块静态初始化块总结代码 【Java语言基础】初始化初始化块又称为代码块。属于类中的第四大成员。本质上是一个方法,它也有方法体,但没有方法名,没有参数,没有返回,...
  • rk瑞芯微的基于Android的mipi初始化序列化转为dts格式的文档,该文档经过rk Android8.1调试测试过。
  • 一、我的问题是关于初始化C++类成员的。我见过许多这样的代码: CSomeClass::CSomeClass() { x=0; y=1; } 而在别的什么地方则写成下面的样子: CSomeClass::CSomeClass() : x(0), y(1) { } 我的...
  • java实现数组初始化的方法:1、动态初始化,格式...java实现数组初始化的方法:1、静态初始化2、动态初始化格式:1、动态初始化格式:数据类型 [ ] 数组名称 = new 数据类型[数组长度]2、静态初始化格式:数据类型 [...
  • 解决三菱触摸屏编程软件GT Designer2.79装在64位系统下,不能启动,不能初始化字体管理器问题。本人亲测Win7 64位可用。
  • 一般用于正版软件和数据的外接加密硬件,形状和普通的U盘差不多,应用的时把他插在USB接口上,他的作用就是如果要运行这种带加密狗的软件,就必须要把加密狗插到电脑上 , 说白了 就是软件密钥 接码器
  • 在刚开始学习c语言的时候,会遇到数组是否初始化的情况,若初始化数组的一些元素,则其他元素为0,参见以下程序编译运行就知道他们的区别何在 #include &lt;stdio.h&gt;//数组初始化与初始化的比较 void ...
  • 2、格式化对磁盘或磁盘中的分区(partition)进行初始化的一种操作,这种操作通常会导致现有的磁盘或分区中所有的文件被清除。格式化通常分为低级格式化和高级格式化。如果没有特别指明,对硬盘的格式化通常是指高级...
  • VSCode设置初始化模板

    2020-12-18 20:54:40
    // Example: "Print to console": { "prefix": "ccc", //入口,即输入指令 "body": [ //主体,即整个代码片的「布局控制」 "#include ", "using namespace std;\n$1\n", // $1 为第一个指针所在位置,以此类推,...
  • 本文详细讨论了基于FPGA的mif文件创建使用,对于mif...mif文件具有固定格式,而对mif文件使用主要就是对mif。文件beginend之间的内容进行修改。本文以四位二进制加法查找表的实现为例,给出了m(Matlab)语言源程序。
  • C++构造函数的初始化列表

    千次阅读 2018-12-05 17:30:41
    构造函数的初始化列表 当一个类的成员变量是另一个类的对象时 例: #include&lt;iostream&gt; using namespace std; class A{ public: A() { cout&lt;&lt;"A()"&lt;&lt;endl;...
  • 一、认识硬盘格式化格式化”这个词对于一个电脑用户而言绝对不应该陌生。当我们在进行一个全新的WINDOWS安装时,或是对一个硬盘上的所有数据进行“干净”的处理时,往往都会祭出“格式化”这招“杀手锏”,来...
  • 什么是实例化,实例化、声明、初始化区别

    千次阅读 多人点赞 2020-04-26 21:40:29
    实例(instantiate)是指在面向对象的编程中,把用...在面向对象的编程中,通常把用类创建对象的过程称为实例,其格式如下: 如 Date date=new Date();就是用日期类创建了一个日期的对象,就叫对象的实例。 ...
  • U盘完全格式化工具

    2018-07-16 15:39:42
    运行选择完全格式化,就可以把U盘初始化,跟出厂设置相似。
  • C++中类初始值列表类内初始化

    千次阅读 2020-09-22 12:18:56
    类的构造函数的作用是对其成员进行初始化。而在构造函数中可以使用初始值列表为新创建的对象的成员进行赋值。 1 初始值列表 在类的构造函数名之后紧跟着冒号,冒号后面是要初始化的成员名,之后是圆括号或者花括号...
  • Java类的 初始化 和 实例化区别

    千次阅读 2020-09-23 17:13:30
    类的初始化:是完成程序执行前的准备工作。在这个阶段,静态的(变量,方法,代码块)会被执行。同时在会开辟一块存储空间用来存放静态的数据。初始化只在类加载的时候执行一次。类的实例化:是指创建一个对象的过程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,027,803
精华内容 411,121
关键字:

初始化与格式化的区别