zoukankan      html  css  js  c++  java

  • 《精通Windows API-函数、接口、编程实例》——第4章文件系统

    第4章文件系统

    4.2 磁盘和驱动器管理

    文件系统的基本概念:
    包括磁盘分区,卷,目录,文件对象,文件句柄,文件映射
    1.磁盘分区:
    物理磁盘,逻辑磁盘
    2.卷:
    也称逻辑驱动器，是NTFS,FAT32等文件系统组织结构的最高层.
    卷是存储设备(硬盘)上由文件系统管理的一块区域，在逻辑上相互隔离的存储单元.

    windows命名规则:
    主文件名+扩展名
    windows中文件系统的长度被限制为260个字符.
    这260个字符包括卷标,路径,主文件名和扩展名,分隔符

    在DOS下的保留设备名不能做文件名或主文件名.如CON,PRN,AUX,NUL,COM1.....

    =================================================================

    磁盘和驱动器管理API
    GetLogicalDrivers       获取主机中所有的逻辑驱动器,以Bit Map的形式返回.
    GetLogicalDriverString    获取主机中所有的逻辑驱动器,以驱动器根路径字符串返回.
    FindFirstVolume     查找主机中的第一个驱动器，返回查找句柄.
    FindNextVolume      根据FindFirstVolume返回句柄,查找主机中后继的逻辑驱动器
    FindVolumeClose     关闭驱动器查找句柄
    GetDriveType      获取驱动器类型
    GetVolumeInformation    获取逻辑驱动器信息
    FindFirstVolumeMountPoint 查找指定卷的第一个挂载点,返回查找句柄
    FindNextVolumeMountPoint 根据FindFirstVolumeMountPoint返回的句柄,查找卷的后继挂载点.
    FindVolumeMountPointClose 关闭挂载点查找句柄
    GetVolumeNameForVolumeMountPoint 根据指定挂载点获取相应的卷设备名
    SetVolumeMountPoint         将指定卷挂载到指定挂载点处
    GetDiskFreeSpace            获取磁盘空间信息,包括每簇的扇区数,每扇区的字节数,簇数量,空闲的簇数量
    GetDiskFreeSpaceEx          获取用户可用的空闲空间的字节数,磁盘总容量的字节数

    文件和目录管理API
    DeleteFile                  删除参数所指定文件
    CopyFile                    复制指定文件为一个新文件
    MoveFile                    将指定文件或目录移动到指定位置
    CreateFile                  新建或打开一个文件,获取文件句柄
    ReadFile                    读取由文件句柄指定文件的内容
    WriteFile                   向由文件句柄指定的文件中写入内容
    GetFileSize                 获取文件大小,返回DWORD中;大小超出DWORD最大值时可指定高32位的DWORD联合存储
    GetFileSizeEx               获取文件大小,存储到一个64位的大整数联合体中.
    CreateDirectory             创建一个目录
    GetCurrentDirectory         获取当前程序所在目录
    SetCurrentDirectory         设置当前程序所在目录
    GetModuleFileName           获取当前模块全路径
    FindFirstFile               查找指定目录下第一个文件句柄或目录,获得查找句柄
    FindNextFile                根据FindFirstFile获得的句柄,循环查找文件或目录
    GetFileAttributes           获取指定文件目录属性,返回一个DWORD值
    GetFileAttributesEx         获取文件或目录属性,存储在WIN32_FILE_ATTRIBUTE_DATA结构体中
    SetFileAttributes           将文件属性设定为指定值
    FileTimeToLocalFileTime     将文件时间转换为本地时间
    FileTimeToSystemTime        将文件转换为系统时间,SYSTEMTIME格式便于显示

    高级文件操作
    CreateFileMapping           创建文件的映射对象
    MapViewOfFile               创建视图,将创建的文件映射对象映射到当前进程的地址空间中
    FlushViewOfFile             将视图中的数据都写入磁盘,对视图的操作都会反映到磁盘上的文件中
    OpenFileMapping             打开已经存在的命名的文件映射对象
    UnmapViewOfFile             取消文件映射
    GetMappedFileName           从映射对象获取被映射文件的文件设备名
    QueryDosDevice              获取MS-DOS设备名

    =================================================================

    2 磁盘和驱动器管理

    ◇使用两种方法来遍历驱动器并获取驱动器属性。
    ◇使用API操作驱动器挂载点。
    ◇判断光驱中是否有光盘。
    ◇获取磁盘剩余空间、扇区信息等。

    4.2.1 遍历卷并获取属性

    用到的API函数：

    (1) GetLogicalDrives。
    获取主机中所有的逻辑驱动器，以BitMap的形式返回，其函数原型如下：

    (2) GetLogicalDriverStrings。
    获取主机中所有驱动器，以驱动器根路径字符串返回，其函数原型如下：

    （3）FindFirstVolume。
    查找主机中的第一个驱动器，返回驱动器设备名，其函数原型如下：

    （4）FindNextVolume
    查找主机中后继的逻辑驱动器，其函数原型如下：

    (5）FindVo1umeClose。
    ＼关闭FindFirstVolume打开的卷遍历句柄，其函数原型如下：

    (6) GetDriveType。
    获取驱动器类型，其函数原型如下：

    (7) GetVolumeInformation。
    获取逻辑驱动器信息，其函数原型如下：

       

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2.  *《精通Windows API》  
    3.  * 示例代码 
    4.  * GetVolumeInfo.c 
    5.  * 4.2.1    遍历驱动器并获取驱动器属性 
    6.  **************************************/  
    7.   
    8. /* 头文件　*/  
    9. #include <windows.h>   
    10. #include <stdlib.h>   
    11. #include <stdio.h>   
    12. #include <string.h>   
    13. /* 预定义　*/  
    14. #define BUFSIZE 1024   
    15. /* 函数申明　*/  
    16. BOOL GetDirverInfo(LPSTR szDrive);  
    17.   
    18. /* ************************************ 
    19.  * 功能   应用程序主函数，遍历驱动器并调用 
    20.  *          GetDirverInfo 获取驱动器属性 
    21.  **************************************/  
    22. void main(void)  
    23. {  
    24.     CHAR szLogicalDriveStrings[BUFSIZE];  
    25.     PCHAR szDrive;  
    26.   
    27.     ZeroMemory(szLogicalDriveStrings,BUFSIZE);  
    28.     // 获取逻辑驱动器卷标名   
    29.     GetLogicalDriveStrings(BUFSIZE - 1,szLogicalDriveStrings);    
    30.     szDrive = (PCHAR)szLogicalDriveStrings;  
    31.     // 循环处理每个卷   
    32.     do  
    33.     {  
    34.         if(!GetDirverInfo(szDrive))  
    35.         {  
    36.             printf("/nGet Volume Information Error: %d", GetLastError());  
    37.         }  
    38.       
    39.       
    40.           
    41.     szDrive += (lstrlen(szDrive)+1);  
    42.     }  
    43.     while(*szDrive!='/x00');  
    44. }  
    45.   
    46. /* ************************************ 
    47.  * BOOL GetDirverInfo(LPSTR szDrive) 
    48.  * 功能   获取驱动器的属性 
    49.  * 参数   LPSTR szDrive 
    50.  *  指明要获取属性的驱动器的根路径 如 C:/ 
    51.  * 返回值 BOOL 是否成功 
    52.  **************************************/  
    53. BOOL GetDirverInfo(LPSTR szDrive)  
    54. {     
    55.   
    56.   
    57.     UINT uDriveType;  
    58.     DWORD dwVolumeSerialNumber;  
    59.     DWORD dwMaximumComponentLength;  
    60.     DWORD dwFileSystemFlags;  
    61.     TCHAR szFileSystemNameBuffer[BUFSIZE];  
    62. printf("/n%s/n",szDrive);  
    63.       
    64.     uDriveType = GetDriveType(szDrive);  
    65.     // 判断类型   
    66.     switch(uDriveType)  
    67.     {  
    68.     case DRIVE_UNKNOWN:  
    69.         printf("The drive type cannot be determined. 未知的磁盘类型  ");  
    70.         break;  
    71.     case DRIVE_NO_ROOT_DIR:  
    72.         printf("The root path is invalid, for example, no volume is mounted at the path. 说明lpRootPathName是无效的  ");  
    73.         break;  
    74.     case DRIVE_REMOVABLE:  
    75.         printf("The drive is a type that has removable media, for example, a floppy drive or removable hard disk. 可移动磁盘 ");  
    76.         break;  
    77.     case DRIVE_FIXED:  
    78.         printf("The drive is a type that cannot be removed, for example, a fixed hard drive. 固定磁盘 ");  
    79.         break;  
    80.     case DRIVE_REMOTE:  
    81.         printf("The drive is a remote (network) drive. 网络磁盘  ");  
    82.         break;  
    83.     case DRIVE_CDROM:  
    84.         printf("The drive is a CD-ROM drive. 光驱 ");  
    85.         break;  
    86.     case DRIVE_RAMDISK:  
    87.         printf("The drive is a RAM disk. ");  
    88.         break;  
    89.     default:  
    90.         break;  
    91.     }  
    92.     if (!GetVolumeInformation(  
    93.         szDrive, NULL, 0,  
    94.         &dwVolumeSerialNumber,  
    95.         &dwMaximumComponentLength,  
    96.         &dwFileSystemFlags,  
    97.         szFileSystemNameBuffer,  
    98.         BUFSIZE  
    99.         ))  
    100.     {  
    101.         return FALSE;  
    102.     }  
    103.     printf ("/nVolume Serial Number is 存储驱动器序列号%u",dwVolumeSerialNumber);  
    104.     printf ("/nMaximum Component Length is 文件系统所支持的文件组成部分的最大值%u",dwMaximumComponentLength);  
    105.     printf ("/nSystem Type is文件系统类 %s/n",szFileSystemNameBuffer);  
    106.   
    107.     if(dwFileSystemFlags & FILE_SUPPORTS_REPARSE_POINTS)  
    108.     {  
    109.         printf ("The file system does not support volume mount points./n");  
    110.     }  
    111.     if(dwFileSystemFlags & FILE_VOLUME_QUOTAS)  
    112.     {  
    113.         printf ("The file system supports disk quotas./n");  
    114.     }  
    115.     if(dwFileSystemFlags & FILE_CASE_SENSITIVE_SEARCH)  
    116.     {  
    117.         printf ("The file system supports case-sensitive file names./n");  
    118.     }  
    119.     //you can use these value to get more informaion   
    120.     //   
    121.     //FILE_CASE_PRESERVED_NAMES   
    122.     //FILE_CASE_SENSITIVE_SEARCH   
    123.     //FILE_FILE_COMPRESSION   
    124.     //FILE_NAMED_STREAMS   
    125.     //FILE_PERSISTENT_ACLS   
    126.     //FILE_READ_ONLY_VOLUME   
    127.     //FILE_SUPPORTS_ENCRYPTION   
    128.     //FILE_SUPPORTS_OBJECT_IDS   
    129.     //FILE_SUPPORTS_REPARSE_POINTS   
    130.     //FILE_SUPPORTS_SPARSE_FILES   
    131.     //FILE_UNICODE_ON_DISK   
    132.     //FILE_VOLUME_IS_COMPRESSED   
    133.     //FILE_VOLUME_QUOTAS   
    134.     printf(".../n");  
    135.     return TRUE;  
    136. }  

      

     4.2.2 操作驱动器挂载点

    一般可以用FindFirstVolumeMountPoint系列的API来找到一个卷的所有挂载点；用
    GetVolumeNameForVolumeMountPoint来获取指定挂载点所指向的卷名，卷名形式为"//?/Volume{GUID}/”;用SetVolumeMountPoint来设置新的挂载点。
    通过系统的磁盘管理功能可以设置卷的挂载点，如图4-2所示。


    ◇“我的电脑”图标右键菜单中选择“管理”。
    ◇弹出“计算机管理”窗口，选择“磁盘管理”。
    ◇选中需要挂载的卷，在右键菜单中选择“更改驱动 器名和路径”。
    ◇在弹出的对话框中单击“添加”按钮，选择“装入 以下空白NTFS文件夹”。
    ◇选择需要将卷挂载入的文件夹（空白），单击“确定”按钮。
    ◇卷就被装入文件夹中，之后就可以和访问文件夹一个访问这个卷了，如图4-3和4-4

    (1）FindFirstVolumeMountPoint.
    获取指定卷的第一个挂载点，函数原型如下：
    以用GetLastError()函数获取更详细的错误信息。
    (2) FindNextVolumeMountPoint
    查找指定卷的后继挂载点，函数原型如下：

    （3）FindVolumeMountPointClose.
    关闭FindVolumeMountPointClose打开的卷句柄，其函数原型如下：
    ◇参数
    hFindVolumeMountPoint:要关闭的挂载点查找句柄。
    ◇返回值
    (4)GetVolumeNameForVolumeMountPoint。
    根据指定的挂载点获取相应的卷设备名，函数原型如下：

    （5）SetVolumeMountPc
    将指定卷挂载到指定挂载点处，函数原型如下：

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2.  *《Windows应用程序开发》  
    3.  * 示例代码 
    4.  * mount.c 
    5.  * 4.2.2    卷挂载点操作 
    6.  **************************************/  
    7. /* 预编译声明 */  
    8. #define _WIN32_WINNT 0x0501   
    9. #include <windows.h>   
    10. #include <stdio.h>   
    11. #include <tchar.h>   
    12. #define BUFSIZE            MAX_PATH   
    13. #define FILESYSNAMEBUFSIZE MAX_PATH   
    14.   
    15. /* ************************************ 
    16.  * ProcessVolumeMountPoint 
    17.  * 功能   列举挂载点 
    18.  **************************************/  
    19. BOOL ProcessVolumeMountPoint (HANDLE hPt,  
    20.                               TCHAR *PtBuf, DWORD dwPtBufSize,  
    21.                               TCHAR *Buf)  
    22. {  
    23.     BOOL bFlag;                 // 结果   
    24.     TCHAR Path[BUFSIZE];    // 全路径   
    25.     TCHAR Target[BUFSIZE];      // 挂载点设备   
    26.   
    27.     printf ("/tVolume mount point found is /"%s/"/n", PtBuf);  
    28.   
    29.     lstrcpy (Path, Buf);  
    30.     lstrcat (Path, PtBuf);  
    31.   
    32.     bFlag = GetVolumeNameForVolumeMountPoint(  
    33.         Path,  Target,  BUFSIZE     );  
    34.   
    35.     if (!bFlag)  
    36.         printf ("/tAttempt to get volume name for %s failed./n", Path);  
    37.     else   
    38.         printf ("/tTarget of the volume mount point is %s./n", Target);  
    39.   
    40.     bFlag = FindNextVolumeMountPoint(  
    41.         hPt,  PtBuf,  dwPtBufSize );  
    42.     return (bFlag);  
    43. }  
    44. /* ************************************ 
    45.  * ProcessVolume 
    46.  * 功能   判断卷类型，列举挂载点 
    47.  **************************************/  
    48. BOOL ProcessVolume (HANDLE hVol, TCHAR *Buf, DWORD iBufSize)  
    49. {  
    50.     BOOL bFlag;           // 返回标志   
    51.     HANDLE hPt;           // 卷句柄   
    52.     TCHAR PtBuf[BUFSIZE]; // 挂载点路径   
    53.     DWORD dwSysFlags;     // 文件系统标记   
    54.     TCHAR FileSysNameBuf[FILESYSNAMEBUFSIZE];  
    55.   
    56.     printf ("Volume found is /"%s/"./n", Buf);  
    57.   
    58.     // 是否NTFS   
    59.     GetVolumeInformation( Buf, NULL, 0, NULL, NULL,  
    60.         &dwSysFlags, FileSysNameBuf,   
    61.         FILESYSNAMEBUFSIZE);  
    62.   
    63.     if (! (dwSysFlags & FILE_SUPPORTS_REPARSE_POINTS))   
    64.     {  
    65.         printf ("/tThis file system does not support volume mount points./n");  
    66.     }   
    67.     else   
    68.     {  
    69.         // 本卷中的挂载点   
    70.         hPt = FindFirstVolumeMountPoint(  
    71.             Buf, // 卷的跟跟踪   
    72.             PtBuf, // 挂载点路径   
    73.             BUFSIZE   
    74.             );  
    75.   
    76.         if (hPt == INVALID_HANDLE_VALUE)  
    77.         {  
    78.             printf ("/tNo volume mount points found!/n");  
    79.         }   
    80.         else   
    81.         {  
    82.             // 处理挂载点   
    83.             bFlag = ProcessVolumeMountPoint (hPt,   
    84.                 PtBuf,   
    85.                 BUFSIZE,   
    86.                 Buf);  
    87.             // 循环   
    88.             while (bFlag)   
    89.                 bFlag =   
    90.                 ProcessVolumeMountPoint (hPt, PtBuf, BUFSIZE, Buf);  
    91.             // 结束   
    92.             FindVolumeMountPointClose(hPt);  
    93.         }  
    94.     }  
    95.   
    96.     // 下一个   
    97.     bFlag = FindNextVolume(  
    98.         hVol, Buf,  iBufSize);  
    99.   
    100.     return (bFlag);   
    101. }  
    102. /* ************************************ 
    103.  * int GetMountPoint(void) 
    104.  * 功能   获取挂载点 
    105.  **************************************/  
    106. int GetMountPoint(void)  
    107. {  
    108.     TCHAR buf[BUFSIZE];     // 卷标识符   
    109.     HANDLE hVol;                    // 卷句柄   
    110.     BOOL bFlag;                 // 结果标志   
    111.   
    112.     printf("Volume mount points info of this computer:/n/n");  
    113.     // 打开卷   
    114.     hVol = FindFirstVolume (buf, BUFSIZE );  
    115.     if (hVol == INVALID_HANDLE_VALUE)  
    116.     {  
    117.         printf ("No volumes found!/n");  
    118.         return (-1);  
    119.     }  
    120.   
    121.     bFlag = ProcessVolume (hVol, buf, BUFSIZE);  
    122.     while (bFlag)   
    123.     {  
    124.         bFlag = ProcessVolume (hVol, buf, BUFSIZE);  
    125.     }  
    126.   
    127.     bFlag = FindVolumeClose(    hVol );  
    128.     return (bFlag);  
    129. }  
    130.   
    131. /* ************************************ 
    132.  * void Usage (PCHAR argv) 
    133.  * 功能   使用方法 
    134.  **************************************/  
    135. void Usage (PCHAR argv)  
    136. {  
    137.     printf( "/n/n/t%s, mount a volume at a mount point./n", argv );  
    138.     printf( "/tFor example, /"mount D://mnt//drives// E:///"/n" );   
    139. }  
    140.   
    141. /* ************************************ 
    142.  *  main 
    143.  * 功能   入口函数 
    144.  **************************************/  
    145. int main( int argc, PCHAR argv[] )  
    146. {  
    147.     BOOL bFlag;  
    148.     CHAR Buf[BUFSIZE];       
    149.   
    150.     if( argc != 3 )   
    151.     {  
    152.         GetMountPoint();  
    153.         Usage( argv[0] );  
    154.         return( -1 );  
    155.     }  
    156.   
    157.     bFlag = GetVolumeNameForVolumeMountPoint(  
    158.         argv[2],        // 输入挂载点或目录   
    159.         Buf,                // 输出卷名   
    160.         BUFSIZE  
    161.         );  
    162.   
    163.     if (bFlag != TRUE)   
    164.     {  
    165.         printf( "Retrieving volume name for %s failed./n", argv[2] );  
    166.         return (-2);  
    167.     }  
    168.   
    169.     printf( "Volume name of %s is %s/n", argv[2], Buf );  
    170.     bFlag = SetVolumeMountPoint(  
    171.         argv[1],    // 挂载点   
    172.         Buf         // 需要挂载的卷   
    173.         );  
    174.   
    175.     if (!bFlag)  
    176.     {  
    177.         printf ("Attempt to mount %s at %s failed. error code is/n",   
    178.             argv[2], argv[1], GetLastError());  
    179.     }  
    180.   
    181.     return (bFlag);  
    182. }  

    4.2.3 判断光驱中是否有光盘

     判断光驱中是否有光盘，仍然可以使用在4.2.1小节介绍的GetDriveType和GetVolumeInformation函数实现。首先使用驱动器根路径作为GetDriveType和参数，如果返回值是DRIVE_CDROM，则说明此驱动器为光驱。然后使用GetVolumeInformation获取信息，如果成功，则说明存光盘已经放入。调用完成后GetVolumeInformation函数的第7个参数LPTSTR lpFileSystemNameBuffer存储的是文件系统的类别字符串，光盘一般是CDFS。如果调用GetVolumeInformation时返回FALSE，并且GetLastError返回21，则说明驱动器中未放入光盘。
    1．关键API
    (1）GetDiskType与GetVolumeInformation。
    这两个API已经在4.2.1小节介绍过，这里不再赘述。
    （2）GetLastError。
    获取在执行中本线程最近的一次错误。本函数是很多系统API返回执行错误原因的方法。可能使用SetLastError函数设置本线程的Last-Error值。GetLastError函数原型如下：
    [cpp] view plaincopyprint?
    1.  * 4.2.3    判断光驱中是否有光盘  
    2.  **************************************/  
    3. /* 头文件　*/  
    4. #include <windows.h>   
    5. #include <stdio.h>   
    6. #include <tchar.h>   
    7. /* 预定义　*/  
    8. #define BUFSIZE            512   
    9.   
    10. /* ************************************ 
    11.  * int main( int argc, PCHAR argv[] ) 
    12.  * 功能   应用程序主函数，根据输入的驱动器 
    13.  *      根路径参数判断是否为光驱，是否放 
    14.  *      入光盘。 
    15.  * 参数   驱动器根路径，比如“D:/”。 
    16.  **************************************/  
    17.   
    18. int main( int argc, PCHAR argv[] )  
    19. {  
    20.     //存储文件系统类别名   
    21.     CHAR szFileSystemNameBuffer[BUFSIZE];  
    22.     DWORD dwLastError;  
    23.     DWORD dwFileSystemFlags;  
    24.   
    25.     //判断是否输入运行时参数   
    26.     if( argc != 2 )   
    27.     {  
    28.         printf("请输入驱动器的根路径，比如： /"D:///"/n");   
    29.         return( -1 );  
    30.     }  
    31.       
    32.     //判断输入的驱动器是否为CD/DVD ROM   
    33.     if(GetDriveType(argv[1])!=DRIVE_CDROM)  
    34.     {  
    35.         printf("驱动器 %s 不是 CD/DVD ROM。/n",argv[1]);  
    36.         return( -1 );  
    37.     }  
    38.       
    39.     //获取卷信息   
    40.     if (!GetVolumeInformation(  
    41.         argv[1], NULL, 0,  
    42.         NULL,NULL,  
    43.         &dwFileSystemFlags,  
    44.         szFileSystemNameBuffer,  
    45.         BUFSIZE  
    46.         ))  
    47.     {  
    48.         dwLastError = GetLastError();  
    49.         if(dwLastError == 21)  
    50.         {  
    51.             printf("设备未就绪,请放入光盘！/n");  
    52.             return 0;  
    53.         }  
    54.         else  
    55.         {  
    56.             printf("GetVolumeInformation 错误 %d/n",dwLastError);  
    57.             return 0;  
    58.         }  
    59.     }  
    60.     printf ("光盘已经放入，文件系统类别 %s。/n",szFileSystemNameBuffer);  
    61.     return 0;  
    62. }  

    4.2.4 获取磁盘分区的总容量、空闲容量、簇、扇区信息

    获取磁盘分区的总容量和空闲空间的容量可以使用GetDiskFreeSpace函数或GetDiskFree SpaceEx函数。GetDiskFreeSpace使用DWORD类型作为输出参数，由于DWOR长度为32位，最大只能表示4GB，而一般的磁盘分区大小都大于4GB，所以，GetDiskFreeSpace并不直接返回磁盘的总容量和空闲空间的容量，而是使用总簇数、空闲的簇数、每簇的扇区数、每扇区的字节数来表示。用户在编程时，可以使用它们的乘积来获得最终结果。而GetDiskFreeSpaceEx使用ULARGE_INTEGER (DWORD64)类型的数据来存储磁盘空间总空间和剩余空间，所以可以直接获得结果。DWORD64可以表示约16777216TB的数据量(DWORD64最大可表示2Byte，lTB=2Byte，

    (2）GetDiskFreeSpacEX。
    获取驱动器根路径作为输入，获取用户可用的空闲空间的字节数、空闲空间的字节数、磁盘总容量的字节数，其函数原型如下：

    2．关键数据结构
    GetDiskFreeSpaceEx函数使用到了数据结构ULARGE_INTEGER，数据类型PULARGE
    INTEGER是指向它的指针。ULARGE__ INTEGER的定义如下，此数据结构使用两个DWORD来表
    示64位数据。低位存储于前，高位存储于后，与DWORD64的存储形式是一致的，所以可以直接强制类型转换为DOWRD64类型。也可以直接使用QuadPart成员，QuadPart成员是ULONGLONG形数据结构，在一般32位主机上，与DWORD64具有同样的长度。

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2.  *《精通Windows API》  
    3.  * 示例代码 
    4.  * diskspace.c 
    5.  * 4.2.4    获取磁盘空间信息 
    6.  **************************************/  
    7.   
    8. /* 头文件　*/  
    • #include <windows.h>   
    • #include <stdio.h>   
    •   
    • /* ************************************ 
    •  * BOOL GetDiskSpaceInfo(LPCSTR pszDrive 
    •  * 功能   根据输入的驱动器，获取磁盘总容量 
    •  *          空闲空间、簇数量等磁盘信息 
    •  * 参数   驱动器根路径，比如“D:/”。 
    •  **************************************/  
    • BOOL GetDiskSpaceInfo(LPCSTR pszDrive)  
    • {  
    •     DWORD64 qwFreeBytesToCaller, qwTotalBytes, qwFreeBytes;  
    •     DWORD dwSectPerClust, dwBytesPerSect, dwFreeClusters,  dwTotalClusters;  
    •     BOOL bResult;  
    •       
    •     //使用GetDiskFreeSpaceEx获取磁盘信息并打印结果   
    •     bResult = GetDiskFreeSpaceEx (pszDrive,  
    •         (PULARGE_INTEGER)&qwFreeBytesToCaller,  
    •         (PULARGE_INTEGER)&qwTotalBytes,  
    •         (PULARGE_INTEGER)&qwFreeBytes);  
    •   
    •     if(bResult)   
    •     {  
    •         printf("使用GetDiskFreeSpaceEx获取磁盘空间信息/n");  
    •         printf("可获得的空闲空间（字节）: /t%I64d/n", qwFreeBytesToCaller);  
    •         printf("空闲空间（字节）: /t/t%I64d/n", qwFreeBytes);  
    •         printf("磁盘总容量（字节）: /t/t%I64d/n", qwTotalBytes);  
    •     }  
    •   
    •     //使用GetDiskFreeSpace获取磁盘信息并打印结果   
    •     bResult = GetDiskFreeSpace (pszDrive,   
    •         &dwSectPerClust,   
    •         &dwBytesPerSect,  
    •         &dwFreeClusters,   
    •         &dwTotalClusters);  
    •   
    •     if(bResult)   
    •     {  
    •         printf("/n使用GetDiskFreeSpace获取磁盘空间信息/n");  
    •         printf("空闲的簇数量 : /t/t/t%d/n",dwFreeClusters);  
    •         printf("总簇数量 : /t/t/t%d/n",dwTotalClusters);  
    •         printf("每簇的扇区数量 : /t/t%d/n",dwSectPerClust);  
    •         printf("每扇区的容量（字节）: /t/t%d/n",dwBytesPerSect);  
    •         printf("空闲空间（字节）: /t/t%I64d/n",   
    •             (DWORD64)dwFreeClusters*  
    •             (DWORD64)dwSectPerClust*(DWORD64)dwBytesPerSect);  
    •         printf("磁盘总容量（字节）: /t/t%I64d",  
    •             (DWORD64)dwTotalClusters*  
    •             (DWORD64)dwSectPerClust*(DWORD64)dwBytesPerSect);  
    •     }  
    •     return bResult;  
    • }  
    •   
    • /* ************************************ 
    •  * int main( int argc, PCHAR argv[] ) 
    •  * 功能   应用程序主函数，根据输入参数 
    •  *          调用GetDiskSpaceInfo函数获取 
    •  *          磁盘空间信息 
    •  * 参数   驱动器根路径，比如“D:/”。 
    •  **************************************/  
    • int main(int argc, PCHAR argv[])  
    • {  
    •     GetDiskSpaceInfo (argv[1]);  
    • }  

    4.3 文件和目录管理


    文件和目录管理是Windows系统编程最为基本的内容，几乎所有的应用程序都会使用到文件和目录的操作。本节将向读者演示如何创建目录、遍历目录、创建文件、打开文件、读写文件、移动复制删除文件等。本节通过以下多个实例来讲解Windows API对文件和目录的管理。
    ◇删除、复制、重命名、移动文件。
    ◇创建、打开、读写文件。
    ◇创建、打开目录。
    ◇获取当前目录、获取程序所在的目录、获取模块路径。
    ◇查找文件、遍历目录下的文件和子目录。
    ◇递归遍历目录树。

    ◇获取、设置文件属性和时间。


    4.3.1 删除、复制、重命名、移动文件


    Windows系统为文件的删除、复制、重命名或移动文件提供了相应的API函数。删除文件使用DeleteFile函数；复制文件使用CopyFile函数；重命名文件和移动文件实际是一个操作，使用MoveFile函数。这几个函数的使用都非常简单，下面分别介绍。
    1．关键API
    (1) DeleteFile。

    DeleteFile的功能是删除文件。以文件路径作为输入，指向需要删除的文件。文件路径可以是类似于“c：/files/delete.txt”的绝对路径，也可以是类似于“./delete.txt”的相对路径，二相对于可执行文件所在的路径。

    (2) CopyFile。
    CopyFile的功能是复制文件。通过参数输入复制文件和源路径和目的路径，路径可以是绝对路径也可以是相对路径，还可以通过参数指明如果目的路径已经存在文件，是否覆盖。可以使用CopyFileEx函数进行更为高级的操作，比如在复制进行过程中取消复制等。CopyFileEx可以指定
    一个回调函数来处理文件复制中所可能发生的各种情况。

    3) MoveFile。
    MoveFile的功能是移动、重命名文件和目录。通过参数输入源路径和目的路径，路径可以是绝对路径也可以是相对路径，如果目的路径的文件或目录已经存在，则返回失败。可以使用MoveFileEx函数来指定更多的选项，如果已经存在是否替换等。还可以使用MoveFileWithProgress指定一个回调函数来处理文件移动中所可能发生的各种情况。函数原型如下：

    (4) CopyFileEx、MoveFileEx以及MoveFileWithProgreSS.
    这3个API函数功能更丰富，但是限于篇幅这里不再做详细介绍，读者可以使用SDK文档学习它们的使用方法。

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2. *《精通Windows API》  
    3. * 示例代码 
    4. * wr.c 
    5. * 4.3.2 创建、打开、读写文件，获取文件大小 
    6. **************************************/  
    7.   
    8. /* 头文件　*/  
    • #include <windows.h>   
    • #include <stdio.h>   
    •   
    • /* ************************************ 
    • * DWORD ReadFileContent(LPSTR szFilePath) 
    • * 功能    获取文件大小 
    • *       读取文件内容，并以16进制的形式打印出来 
    • * 参数    LPSTR szFilePath 
    • *       文件路径 
    • **************************************/  
    • DWORD ReadFileContent(LPSTR szFilePath)  
    • {  
    •     //文件大小   
    •     HANDLE hFileRead;  
    •     //保存文件大小   
    •     LARGE_INTEGER liFileSize;  
    •     //成功读取的文件数据大小   
    •     DWORD dwReadedSize;  
    •     //累加计算已经读取数据的大小   
    •     LONGLONG liTotalRead = 0;  
    •     //文件数据缓存   
    •     BYTE lpFileDataBuffer[32];  
    •   
    •     //打开已经存在的文件，读取内容。      
    •     hFileRead = CreateFile(szFilePath,// 要打开的文件名   
    •         GENERIC_READ,              // 以读方式打开   
    •         FILE_SHARE_READ,           // 可共享读   
    •         NULL,                      // 默认安全设置   
    •         OPEN_EXISTING,             // 只打开已经存在的文件   
    •         FILE_ATTRIBUTE_NORMAL,     // 常规文件属性   
    •         NULL);                     // 无模板   
    •   
    •     //打开文件是否成功。   
    •     if(hFileRead==INVALID_HANDLE_VALUE)  
    •     {  
    •         printf("打开文件失败：%d",GetLastError());  
    •     }  
    •   
    •     if(!GetFileSizeEx(hFileRead,&liFileSize))  
    •     {  
    •         printf("获取文件大小失败：%d",GetLastError());  
    •     }  
    •     else  
    •     {  
    •         printf("文件大小为：%d/n",liFileSize.QuadPart);  
    •     }  
    •   
    •     //循环读取并打印文件内容   
    •     while(TRUE)  
    •     {  
    •         DWORD i;  
    •   
    •         if(!ReadFile(hFileRead, //读文件的句柄   
    •             lpFileDataBuffer,   //存储读取的文件内容   
    •             32,                 //读的大小（字节）   
    •             &dwReadedSize,      //实际读取的大小   
    •             NULL))              //不使用Overlapped   
    •         {  
    •             printf("读文件错误：%d/n",GetLastError());  
    •             break;  
    •         }  
    •         printf("读取了%d字节，文件内容是：",dwReadedSize);  
    •           
    •         for(i=0; i<dwReadedSize; i++)  
    •         {  
    •             printf("0x%x ",lpFileDataBuffer[i]);  
    •         }  
    •         printf("/n");  
    •         liTotalRead += dwReadedSize;  
    •         if(liTotalRead == liFileSize.QuadPart)  
    •         {  
    •             printf("读文件结束/n");  
    •             break;  
    •         }  
    •     }  
    •     CloseHandle(hFileRead);  
    •     return 0;  
    • }  
    •   
    • /* ************************************ 
    • *  SaveDataToFile 
    • * 功能    将数据存储到文件末尾 
    • * 参数    LPSTR szFilePath    文件路径 
    • *       LPVOID lpData       需存储的数据 
    • *       DWORD dwDataSize    数据大小（字节） 
    • **************************************/  
    • DWORD SaveDataToFile(  
    •                      LPSTR szFilePath,  
    •                      LPVOID lpData,  
    •                      DWORD dwDataSize)  
    • {  
    •     //文件句柄   
    •     HANDLE hFileWrite;  
    •     //成功写入的数据大小   
    •     DWORD dwWritedDateSize;  
    •   
    •     //打开已经存在的文件，读取内容。      
    •     hFileWrite = CreateFile(szFilePath, // 要打开的文件名   
    •         GENERIC_WRITE,          // 以写方式打开   
    •         0,                      // 可共享读   
    •         NULL,                   // 默认安全设置   
    •         OPEN_ALWAYS,            // 打开已经存在的文件，没用则创建   
    •         FILE_ATTRIBUTE_NORMAL,  // 常规文件属性   
    •         NULL);                  // 无模板   
    •       
    •     //判断是否打开成功   
    •     if(hFileWrite==INVALID_HANDLE_VALUE)  
    •     {  
    •         printf("打开文件失败：%d/n",GetLastError());  
    •     }  
    •   
    •     //设置文件指针到文件尾   
    •     SetFilePointer(hFileWrite,0,0,FILE_END);  
    •   
    •     //将数据写入文件   
    •     if(!WriteFile(hFileWrite,lpData,dwDataSize,&dwWritedDateSize,NULL))  
    •     {  
    •         printf("写文件失败：%d/n",GetLastError());  
    •     }  
    •     else  
    •     {  
    •         printf("写文件成功，写入%d字节。/n",dwWritedDateSize);  
    •     }  
    •     CloseHandle(hFileWrite);  
    •     return 0;  
    • }  
    •   
    • /* ************************************ 
    • * int main(void) 
    • * 功能    演示使用SaveDataToFile和ReadFileContent函数 
    • **************************************/  
    • int main(void)  
    • {  
    •     LPSTR szFileData = "这是一个例子";  
    •     SaveDataToFile("C://show.txt",szFileData,lstrlen(szFileData));  
    •     ReadFileContent("C://show.txt");  
    •     return 0;  
    • }  

    4.3.2 创建、打开、读写文件，获取文件大小

    在Windows系统中，创建和打开文件都是使用API函数CreateFile，CreateFile通过指定不同的参数来表示是新建一个文件，打开已经存在的文件，还是重新建立文件等。读写文件最为直接的方式是使用ReadFile和WriteFile函数，也可以使用文件镜像，获取文件大小一般使用GetFileSize函数，也可以使用GetFileAttributesEx等函数（在4.3.7节介绍）。读写文件、获取文件大小之前都需要使用CreateFile创建或打开的文件，获得文件句柄。
    在文件操作中，文件句柄是一个关键的概念。文件句柄惟一标识了一个文件，ReadFile、
    WriteFile、GetFileSize等函数是使用文件句柄作为参数来表示，用户需要读、写、获取大小的文件是哪一个文件。在对文件进行操作前，都必须要使用CreateFile获得文件句柄。

    1．关键API
    （1）CreateFile
    CreateFile是文件操作中最主要的一个函数。几乎所有的文件操作都需要使用到文件句柄。而CreateFile函数为这些操作建立文件句柄。CreateFile函数定义如下：

    （2）ReadFile。

    ReadFile动能是从文件中读出数据。需要使用CreateFile所返回的文件句柄。函数原型如下：

    （3）WriteFile。
    WriteFile函数的功能是将数据写入到文件中，写入到文件指针所在的位置，写入操作完成后，文件指针会移动到写入的数据之后，函数原型如下：

    （4）GetFileSize、GetFileSizeEX.
    GetFileSize、GetFileSizeEX的功能是一致的，都是获取文件大小，函数原型分别如下。

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2.  *《精通Windows API》  
    3.  * 示例代码 
    4.  * files.c 
    5.  * 4.3.1    删除、复制、重命名、移动文件 
    6.  **************************************/  
    7.   
    8. /* 头文件　*/  
    9. #include <windows.h>   
    10. #include <stdio.h>   
    11.   
    12. /* ************************************ 
    13.  * int main( int argc, PCHAR argv[] ) 
    14.  * 功能   应用程序主函数，根据输入参数 
    15.  *      删除、复制、重命名文件 
    16.  * 
    17.  * 参数   删除文件： 
    18.  *          -d 文件路径 
    19.  *      将文件路径1的文件复制到文件路径2： 
    20.  *          -c 文件路径1 文件路径2 
    21.  *      将文件路径1的文件移动、重命名为文件路径2的文件 
    22.  *          -m 文件路径1 文件路径2 
    23.  **************************************/  
    24. int main(int argc, PCHAR argv[])  
    25. {  
    26.     LPSTR y="c:/2.bat";  
    27. LPSTR x="c:/1.bat";  
    28.     //-d参数，删除文件。   
    29.     if(0==lstrcmp("-d",argv[1]) && argc==3)  
    30.     {  
    31.         if(!DeleteFile(argv[2]))  
    32.         {  
    33.             printf("删除文件错误：%x/n",GetLastError());  
    34.         }  
    35.         else  
    36.         {  
    37.             printf("删除成功！/n");  
    38.         }  
    39.     }  
    40.     //-c参数，复制文件。   
    41.     //如果文件存在，询问用户是否覆盖   
    42.     else if(0==lstrcmp("-c",argv[1]) && argc==4)  
    43.     {  
    44.         //复制，不覆盖已经存在的文件   
    45.         if(!CopyFile(argv[2],argv[3],TRUE))  
    46.         {  
    47.             //LastError == 0x50，文件存在。   
    48.             if(GetLastError() == 0x50)  
    49.             {  
    50.                 printf("文件%s已经存在，是否覆盖？y/n：",argv[3]);  
    51.                 if('y'==getchar())  
    52.                 {  
    53.                     //复制，覆盖已经存在的文件。   
    54.                     if(!CopyFile(argv[2],argv[3],FALSE))  
    55.                     {  
    56.                         printf("复制文件错误，%d/n",GetLastError());  
    57.                     }  
    58.                     else  
    59.                     {  
    60.                         printf("复制成功！/n");  
    61.                     }  
    62.                 }  
    63.                 else  
    64.                 {  
    65.                     return 0;  
    66.                 }  
    67.             }  
    68.         }  
    69.         else  
    70.         {  
    71.             printf("复制成功！/n");  
    72.         }  
    73.     }  
    74.     //-m参数，移动、重命名文件。   
    75.     else if(0==lstrcmp("-m",argv[1]) && argc==4)  
    76.     {  
    77.         if(!MoveFile( x,y))  
    78.         {  
    79.             printf("移动文件错误：%d/n",GetLastError());  
    80.         }  
    81.         else  
    82.         {  
    83.             printf("移动文件成功！/n");  
    84.         }  
    85.     }  
    86.     else  
    87.     {  
    88.         printf("参数错误！/n");  
    89.     }  
    90. }  

     4.3.3 创建目录

    编程实现创建目录是非常简单的，只要使用API函数CreateDirectory即可。
    1． 关键API
    （1） Createdirectory
    函数原型如下：
    ◇参数
    lpPathName:输入参数，所要创建的目录名或路径。
    lpSecurityAttributes:输入参数，设置为NULL。
    ◇返回值
    返回BOOL值，表示是否成功。
    ◇使用说明
    如果程序返回失败，可以使用GetLastError函数获取错误信息。可能的值包括ERROR
    ALREADY EXISTS（文件夹已经存在）和ERROR PATH NOT FOUND（路径不存在）。

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2. *《精通Windows API》  
    3. * 示例代码 
    4. * dir.c 
    5. * 4.3.3 创建目录 
    6. **************************************/  
    7.   
    8. /* 头文件　*/  
    9. #include <windows.h>   
    10. #include <stdio.h>   
    11.   
    12. /* ************************************ 
    13. * int main(void) 
    14. * 功能    演示使用CreateDirectory创建目录 
    15. **************************************/  
    16. int main(void)  
    17. {  
    18.     //在程序的当前目录下创建“sub_dir”子目录   
    19.     LPSTR szDirPath = "sub_dir";  
    20.     if (!CreateDirectory(szDirPath, NULL))   
    21.     {   
    22.         printf("创建目录 %s 错误。/n",szDirPath);   
    23.         return 1;  
    24.     }  
    25.   
    26.     //在C盘下创建目录“example_dir”   
    27.     szDirPath = "C://example_dir";  
    28.     if (!CreateDirectory(szDirPath, NULL))   
    29.     {   
    30.         printf("创建目录 %s 错误。/n",szDirPath);   
    31.         return 1;  
    32.     }   
    33.     printf("成功/n");   
    34.   
    35.     return 0;  
    36. }  

     4.3.4 获取程序所在的目录、程序模块路径，获取和设置当前目录


    Windows系统提供一组API实现对程序运行时相关目录的获取和设置。用户可以使用
    GetCurrentDirectory和SetCurrentDirectory获取程序的当前目录，获取模块的路径使用
    GetModuleFileName，如果以NULL参数调用GetModuleFileName，将会返回当前模块的路径。如果在程序主模块(exe)中获取当前模块路径，便可以从当前模块的路径中提取出程序运行时所在的路径。
    1．关键API
    （1）GetCurrentDirectory。
    获取进程的当前目录，函数原型如下：

     （2）SetCurrentDirectory。
    设置进程的当前目录，函数原型如下：

    (3)GetModuleFileName。
    获取模块文件名，当第一个参数为NULL时获取当前模块路径，函数原型如下：

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2. *《精通Windows API》  
    3. * 示例代码 
    4. * cur_mod_dir.c 
    5. * 4.3.4 获取当前目录、获取程序所在的目录、获取模块路径 
    6. **************************************/  
    7.   
    8. /* 头文件　*/  
    9. #include <windows.h>   
    10. #include <stdio.h>   
    11.   
    12. /* ************************************ 
    13. * int main(void) 
    14. * 功能    演示使用设置获取当前路径 
    15. *       演示获取模块路径 
    16. **************************************/  
    17. int main(void)  
    18. {  
    19.     //用于存储当前路径   
    20.     CHAR szCurrentDirectory[MAX_PATH];  
    21.     //用于存储模块路径   
    22.     CHAR szMoudlePath[MAX_PATH];  
    23.     //Kernel32文件名与句柄   
    24.     LPSTR szKernel32 = "kernel32.dll";  
    25.     HMODULE hKernel32;  
    26.     //当前路径的长度，也用于判断获取是否成功   
    27.     DWORD dwCurDirPathLen;  
    28.       
    29.     //获取进程当前目录   
    30.     dwCurDirPathLen =   
    31.         GetCurrentDirectory(MAX_PATH,szCurrentDirectory);  
    32.     if(dwCurDirPathLen == 0)  
    33.     {  
    34.         printf("获取当前目录错误。/n");   
    35.         return 0;  
    36.     }  
    37.     printf("进程当前目录为 %s /n",szCurrentDirectory);   
    38.       
    39.     //将进程当前目录设置为“C:/”   
    40.     lstrcpy(szCurrentDirectory, "C://");  
    41.     if(!SetCurrentDirectory(szCurrentDirectory))  
    42.     {  
    43.         printf("设置当前目录错误。/n");   
    44.         return 0;  
    45.     }  
    46.     printf("已经设置当前目录为 %s /n",szCurrentDirectory);   
    47.   
    48.     //在当前目录下创建子目录“current_dir”   
    49.     //运行完成后C:盘下将出现文件夹“current_dir”   
    50.     CreateDirectory("current_dir", NULL);  
    51.   
    52.     //再次获取系统当前目录   
    53.     dwCurDirPathLen =   
    54.         GetCurrentDirectory(MAX_PATH,szCurrentDirectory);  
    55.     if(dwCurDirPathLen == 0)  
    56.     {  
    57.         printf("获取当前目录错误。/n");   
    58.         return 0;  
    59.     }  
    60.     printf("GetCurrentDirectory获取当前目录为 %s /n",  
    61.         szCurrentDirectory);   
    62.   
    63.     //使用NULL参数，获取本模块的路径。   
    64.     if(!GetModuleFileName(NULL,szMoudlePath,MAX_PATH))  
    65.     {  
    66.         printf("获取模块路径录错误。/n");   
    67.         return 0;  
    68.     }  
    69.     printf("本模块路径 %s /n",szMoudlePath);  
    70.   
    71.     //获取Kernel32.dll的模块句柄。   
    72.     hKernel32 = LoadLibrary(szKernel32);  
    73.   
    74.     //使用Kernel32.dll的模块句柄，获取其路径。   
    75.     if(!GetModuleFileName(hKernel32,szMoudlePath,MAX_PATH))  
    76.     {  
    77.         printf("获取模块路径错误。/n");   
    78.         return 0;  
    79.     }  
    80.     printf("kernel32模块路径 %s /n",szMoudlePath);   
    81.   
    82.     return 0;  
    83. }  

    4.3.5 查找文件、遍历指定目录下的文件和子目录

    Windows API中，有一组专门的函数和结构，用于遍历目录，它们是FindFirstFile函数、
    FindNextFile函数和WIN32_FIND_DATA结构。使用FindFirstFile和FindNextFile函数并与do-while循环结合，可以完成遍历目录的任务，详见实例4-10。
    值得一提的是，FindFirstFile输入参数的路径需使用通配符，也就是用户可以根据一些条件来对查找的文件作简单的过滤。实例4-10讲解查找特定目录下的所有文件和文件夹。读者可根据自己的需要，指定查找文件的条件。
    1．关键API
    （1）FindFirstFile。
    查找第一个目录或文件，获取查找句柄，函数原型如下：

    （2）FindNextFile
    对文件、文件夹进行循环查找，函数原型如下：

    2．关键结构
    WIN32_FIND_DATA结构用于表示找到的文件，结构中包括文件、目录的名字，创建、最后访问和最后写入时间，文件大小、文件属性等。

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2. *《精通Windows API》  
    3. * 示例代码 
    4. * sub_dir.c 
    5. * 4.3.5 遍历目录下的文件和子目录 
    6. **************************************/  
    7.   
    8. /* 头文件　*/  
    9. #include <windows.h>   
    10. #include <stdio.h>   
    11.   
    12. /* ************************************ 
    13. * DWORD EnumerateFileInDrectory(LPSTR szPath) 
    14. * 功能    遍历目录下的文件和子目录，将显示文件的 
    15. *       文件和文件夹隐藏、加密的属性 
    16. * 参数    LPTSTR szPath，为需遍历的路径 
    17. * 返回值   0代表执行完成，1代码发生错误 
    18. **************************************/  
    19. DWORD EnumerateFileInDrectory(LPSTR szPath)  
    20. {  
    21.     WIN32_FIND_DATA FindFileData;  
    22.     HANDLE hListFile;  
    23.     CHAR szFilePath[MAX_PATH];  
    24.       
    25.     //构造代表子目录和文件夹路径的字符串，使用通配符“*”   
    26.     lstrcpy(szFilePath, szPath);      
    27.     //注释的代码可以用于查找所有以“.txt结尾”的文件。   
    28.     //lstrcat(szFilePath, "//*.txt");   
    29.     lstrcat(szFilePath, "//*");  
    30.     //查找第一个文件/目录，获得查找句柄   
    31.     hListFile = FindFirstFile(szFilePath,&FindFileData);  
    32.     //判断句柄   
    33.     if(hListFile==INVALID_HANDLE_VALUE)  
    34.     {  
    35.         printf("错误：%d",GetLastError());  
    36.         return 1;  
    37.     }  
    38.     else  
    39.     {         
    40.         do  
    41.         {  
    42.             /*  如果不想显示代表本级目录和上级目录的“.”和“..”，  
    43.                 可以使用注释部分的代码过滤。  
    44.             if(lstrcmp(FindFileData.cFileName,TEXT("."))==0||  
    45.                 lstrcmp(FindFileData.cFileName,TEXT(".."))==0)  
    46.             {  
    47.                 continue;  
    48.             }  
    49.             */  
    50.             //打印文件名、目录名   
    51.             printf("%s/t/t",FindFileData.cFileName);  
    52.             //判断文件属性，加密文件或文件夹   
    53.             if(FindFileData.dwFileAttributes&FILE_ATTRIBUTE_ENCRYPTED)  
    54.             {  
    55.                 printf("<加密> ");  
    56.             }  
    57.             //判断文件属性，隐藏文件或文件夹   
    58.             if(FindFileData.dwFileAttributes&FILE_ATTRIBUTE_HIDDEN)  
    59.             {  
    60.                 printf("<隐藏> ");  
    61.             }  
    62.             //判断文件属性，目录   
    63.             if(FindFileData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)  
    64.             {  
    65.                 printf("<DIR> ");  
    66.             }  
    67.             //读者可根据文件属性表中的内容自行添加判断文件属性。   
    68.             printf("/n");  
    69.         }  
    70.         while(FindNextFile(hListFile, &FindFileData));  
    71.     }  
    72.     return 0;  
    73. }  
    74.   
    75. /* ************************************ 
    76. * int main(int argc, PCHAR argv[]) 
    77. * 功能    调用ListFileInDrectory 
    78. *       遍历目录下的文件和子目录 
    79. * 参数    argv[1]为需遍历的路径，如果为空则获取 
    80. *       当前路径 
    81. **************************************/  
    82. int main(int argc, PCHAR argv[])  
    83. {     
    84.     if(argc == 2)  
    85.     {  
    86.         EnumerateFileInDrectory(argv[1]);  
    87.     }  
    88.     else   
    89.     {  
    90.         CHAR szCurrentPath[MAX_PATH];  
    91.         GetCurrentDirectory(MAX_PATH,szCurrentPath);  
    92.         EnumerateFileInDrectory(szCurrentPath);  
    93.     }  
    94.     return 0;  
    95. }  

     4.3.6 递归遍历目录树

    在实例4-10的基础上稍加改造，进行循环递归调用，采用树形结构深度遍历的方法。可以遍历指定目录中的所有文件、包括子目录中的文件。代码实现如实例4-11所示。

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2. *《精通Windows API》  
    3. * 示例代码 
    4. * tree.c 
    5. * 4.3.6 递归遍历目录树 
    6. * 2007年10月 
    7. **************************************/  
    8.   
    9. /* 头文件　*/  
    10. #include <windows.h>   
    11. #include <stdio.h>   
    12.   
    13. /* 预处理申明 */  
    14. #pragma comment (lib, "User32.lib")   
    15.   
    16. /* 函数申明　*/  
    17. DWORD ListAllFileInDrectory(LPSTR szPath);  
    18.   
    19. /* 全局变量　*/  
    20. //记录所有的文件和目录数   
    21. DWORD dwTotalFileNum = 0;  
    22.   
    23.   
    24. /* ************************************ 
    25. * DWORD ListAllFileInDrectory(LPSTR szPath) 
    26. * 功能    遍历目录及所有子目录，打印路径 
    27. * 
    28. * 参数    LPTSTR szPath，为需遍历的目录 
    29. * 
    30. * 返回值   0代表执行完成，1代码发生错误 
    31. **************************************/  
    32. DWORD ListAllFileInDrectory(LPSTR szPath)  
    33. {  
    34.     CHAR szFilePath[MAX_PATH];  
    35.   
    36.     WIN32_FIND_DATA FindFileData;  
    37.     HANDLE hListFile;  
    38.     CHAR szFullPath[MAX_PATH];  
    39.   
    40.     //构造代表子目录和文件夹路径的字符串，使用通配符“*”   
    41.     lstrcpy(szFilePath, szPath);  
    42.     lstrcat(szFilePath, "//*");  
    43.     //查找第一个文件/目录，获得查找句柄   
    44.     hListFile = FindFirstFile(szFilePath,&FindFileData);  
    45.   
    46.     if(hListFile==INVALID_HANDLE_VALUE)  
    47.     {  
    48.         printf("错误：%d",GetLastError());  
    49.         return 1;  
    50.     }  
    51.     else  
    52.     {         
    53.         do  
    54.         {  
    55.             //  过滤“.”和“..”，不需要遍历   
    56.             if(lstrcmp(FindFileData.cFileName,TEXT("."))==0||  
    57.                 lstrcmp(FindFileData.cFileName,TEXT(".."))==0)  
    58.             {  
    59.                 continue;  
    60.             }  
    61.             //构造成全路径   
    62.             wsprintf(szFullPath,"%s//%s",  
    63.                 szPath,FindFileData.cFileName);  
    64.             dwTotalFileNum++;  
    65.             //打印   
    66.             printf("/n%d/t%s/t",dwTotalFileNum,szFullPath);  
    67.   
    68.             //如果是目录，则递归调用，列举下级目录   
    69.             if(FindFileData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)  
    70.             {  
    71.                 printf("<DIR>");  
    72.                 ListAllFileInDrectory(szFullPath);  
    73.             }             
    74.         }  
    75.         while(FindNextFile(hListFile, &FindFileData));  
    76.     }  
    77.     return 0;  
    78. }  
    79.   
    80.   
    81. /* ************************************  
    82. * int main(int argc, PCHAR argv[])  
    83. * 功能    调用ListAllFileInDrectory  
    84. *       遍历目录下的文件和子目录  
    85. *  
    86. * 参数    argv[1]为需遍历的路径，如果为空则获取  
    87. *       当前路径  
    88. *  
    89. * 2007年10月  
    90. *  
    91. **************************************/  
    92. int main(int argc, PCHAR argv[])  
    93. {     
    94.     if(argc == 2)  
    95.     {  
    96.         ListAllFileInDrectory(argv[1]);  
    97.     }  
    98.     else   
    99.     {  
    100.         CHAR szCurrentPath[MAX_PATH];  
    101.         GetCurrentDirectory(MAX_PATH,szCurrentPath);  
    102.         ListAllFileInDrectory(szCurrentPath);  
    103.     }  
    104.     return 0;  
    105. }  

    4.3.7 获取、设置文件属性和时间


    为了获取文件属性，用户可以使用GetFileAttributes与GetFileAttributesEx函数。
    GetFileAttributesEx函数除了返回文件属性外，还返回文件时间信息、文件大小等。
    GetFileAttributesEx将返回结果保存在WIN32_FILE_ATTRIBUTE DATA结构中。
    获取的文件时间是以FILETIME格式存在的，如果要正确显示，还需要对其时区进行调整，调整为本地时区，然后转换为系统时间格式，便于显示。
    前面在获取文件大小时已经介绍，NTFS文件系统使用了64位数据来表示文件大小。因为32位的数据最多只能表示4GB的大小。Windows将其分为了高32位和低32位，两个都需要使用到，这一点尤其要在对大于4GB的文件操作时注意。
    1．关键API
    (1)GetFileAttributeS。
    获取文件或目录的属牲-函数原型如下：

    （2）GetFileAttributesEx。
    获取文件或目录的属性、时间、大小，以WIN32_FILE ATTRIBUTE_DATA结构的形式返回
    结果，函数原型如下：

    (3) SetFileAttributes.
    设置文件或目录的属性，函数原型如下：

    （4）FileTimeToLocalFileTime。
    把文件时间转换为本地的文件时间，函数原型如下：

    5）FileTimeToSystemTime
    将文件时间转换为系统时间（SYSTEMTIME格式），便于显示，函数原型如下：

    2．关键数据结构
    (1) FILETIM。
    此结构用最小的数据量表示的时间，但是不便于用户查看和显示。通过API获取的系统时间都是这种格式的。如果要使用显示，可以使用FileTimeToSystemTime转换为便于显示的SYSTEMTIME结构。

    (2) SYSTEMTIME。
    此结构使用了较为直观的方式表示时间。

    (3) WIN32_FILE ATTRIBUTE_DATA。
    GetFileAttributesEx使用这个结构表示返回结果，包括文件属性、文件创建时间、文件最后访问时间、文件最后写入时间和文件大小。

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2.  *《精通Windows API》  
    3.  * 示例代码 
    4.  * attr.c 
    5.  * 4.3.7  获取、设置文件属性和时间 
    6.  **************************************/  
    7.   
    8. /* 头文件　*/  
    • #include <windows.h>   
    • #include <stdio.h>   
    •   
    • /* 函数申明　*/  
    • DWORD ShowFileTime(PFILETIME lptime);  
    • DWORD ShowFileSize(DWORD dwFileSizeHigh,DWORD dwFileSizeLow);  
    • DWORD ShowFileAttrInfo(DWORD dwAttribute);  
    • DWORD SetFileHiddenAndReadonly(LPSTR szFileName);  
    •   
    • /* ************************************ 
    •  * DWORD ShowFileAttributes(LPSTR szPath) 
    •  * 功能   获取并显示文件属性， 
    •  *      调用ShowFileTime、ShowFileSize和 
    •  *      ShowFileAttrInfo函数 
    •  * 
    •  * 参数   LPTSTR szPath，获取并显示此文件的属性 
    •  * 
    •  * 返回值  0代表执行完成，1代码发生错误 
    •  **************************************/  
    • DWORD ShowFileAttributes(LPSTR szPath)  
    • {  
    •     //文件属性结构   
    •     WIN32_FILE_ATTRIBUTE_DATA wfad;  
    •     printf("文件：%s/n",szPath);  
    •     //获取文件属性   
    •     if(!GetFileAttributesEx(szPath,  
    •         GetFileExInfoStandard,  
    •         &wfad))  
    •     {  
    •         printf("获取文件属性错误：%d/n",GetLastError());  
    •         return 1;  
    •     }  
    •     //显示相关时间   
    •     printf("创建时间：/t");  
    •     ShowFileTime(&(wfad.ftCreationTime));  
    •     printf("最后访问时间：/t");  
    •     ShowFileTime(&(wfad.ftLastAccessTime));  
    •     printf("最后修改时间：/t");  
    •     ShowFileTime(&(wfad.ftLastWriteTime));  
    •     //显示文件大小   
    •     ShowFileSize(wfad.nFileSizeHigh,wfad.nFileSizeLow);  
    •     //显示文件属性   
    •     ShowFileAttrInfo(wfad.dwFileAttributes);  
    •   
    •     return 0;  
    • }  
    •   
    • /* ************************************ 
    •  * DWORD ShowFileAttrInfo(DWORD dwAttribute) 
    •  * 功能   打印将文件属性 
    •  * 
    •  * 参数   DWORD dwAttribute，文件属性 
    •  * 
    •  * 返回值 0 
    •  **************************************/  
    • DWORD ShowFileAttrInfo(DWORD dwAttribute)  
    • {  
    •     //依次判断属性，并显示。   
    •     printf("文件属性：/t");  
    •     if(dwAttribute&FILE_ATTRIBUTE_ARCHIVE)  
    •         printf("<ARCHIVE> ");  
    •     if(dwAttribute&FILE_ATTRIBUTE_COMPRESSED)  
    •         printf("<压缩> ");  
    •     if(dwAttribute&FILE_ATTRIBUTE_DIRECTORY)  
    •         printf("<目录> ");  
    •     if(dwAttribute&FILE_ATTRIBUTE_ENCRYPTED)  
    •         printf("<加密> ");  
    •     if(dwAttribute&FILE_ATTRIBUTE_HIDDEN)  
    •         printf("<隐藏> ");  
    •     if(dwAttribute&FILE_ATTRIBUTE_NORMAL)  
    •         printf("<NORMAL> ");  
    •     if(dwAttribute&FILE_ATTRIBUTE_OFFLINE)  
    •         printf("<OFFLINE> ");  
    •     if(dwAttribute&FILE_ATTRIBUTE_READONLY)  
    •         printf("<只读> ");  
    •     if(dwAttribute&FILE_ATTRIBUTE_SPARSE_FILE)  
    •         printf("<SPARSE> ");  
    •     if(dwAttribute&FILE_ATTRIBUTE_SYSTEM)  
    •         printf("<系统文件> ");  
    •     if(dwAttribute&FILE_ATTRIBUTE_TEMPORARY)  
    •         printf("<临时文件> ");  
    •   
    •     printf("/n");  
    •   
    •     return 0;  
    • }  
    • /* ************************************ 
    •  * DWORD ShowFileSize(DWORD dwFileSizeHigh, DWORD dwFileSizeLow) 
    •  * 功能   打印文件大小信息 
    •  * 
    •  * 参数   DWORD dwFileSizeHigh，文件大小高32位 
    •  *      DWORD dwFileSizeLow，文件大小低32位 
    •  * 
    •  * 返回值 0 
    •  **************************************/  
    • DWORD ShowFileSize(DWORD dwFileSizeHigh, DWORD dwFileSizeLow)  
    • {  
    •     ULONGLONG liFileSize;  
    •     liFileSize = dwFileSizeHigh;  
    •   
    •     //高们移动32位   
    •     liFileSize <<= sizeof(DWORD)*8;  
    •     liFileSize += dwFileSizeLow;  
    •     printf("文件大小：/t%I64u 字节/n",liFileSize);  
    •     return 0;  
    • }  
    •   
    • /* ************************************ 
    •  *DWORD ShowFileTime(PFILETIME lptime) 
    •  * 功能   轮换文件时间，将打印 
    •  * 
    •  * 参数   PFILETIME lptime，指向文件时间的指针 
    •  * 
    •  * 返回值 0 
    •  **************************************/  
    • DWORD ShowFileTime(PFILETIME lptime)  
    • {  
    •     //文件时间结构   
    •     FILETIME ftLocal;  
    •     //系统时间结构   
    •     SYSTEMTIME st;  
    •     //调整为系统所在时区的时间   
    •     FileTimeToLocalFileTime(  
    •         lptime,  
    •         &ftLocal  
    •         );  
    •     //将文件时间转换为SYSTEMTIME格式，便于显示。   
    •     FileTimeToSystemTime(  
    •         &ftLocal,  
    •         &st  
    •         );  
    •     //显示时间信息字符串   
    •     printf("%4d年%.2d月%#02d日，%.2d:%.2d:%.2d/n",  
    •         st.wYear,st.wMonth,st.wDay,st.wHour,st.wMinute,st.wSecond);  
    •   
    •     return 0;  
    • }  
    •   
    • /* ************************************ 
    •  * DWORD SetFileHiddenAndReadonly(LPSTR szFileName) 
    •  * 功能   将指定的文件设置为隐藏和只读 
    •  * 
    •  * 参数   LPSTR szFileName，文件路径 
    •  * 
    •  * 返回值 0 
    •  **************************************/  
    • DWORD SetFileHiddenAndReadonly(LPSTR szFileName)  
    • {  
    •     //获取原来的文件属性   
    •     DWORD dwFileAttributes = GetFileAttributes(szFileName);  
    •     //将只读和隐藏属性附加到原来的文件属性上   
    •     dwFileAttributes |= FILE_ATTRIBUTE_READONLY;  
    •     dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN;  
    •     //设置文件属性，并判断是否成功。   
    •     if(SetFileAttributes(szFileName, dwFileAttributes))  
    •     {  
    •         printf("文件%s的隐藏和属性设置成功/n",szFileName);  
    •     }  
    •     else  
    •     {  
    •         printf("属性设置; %d/n",GetLastError());  
    •     }  
    •     return 0;  
    • }  
    •   
    • /* ************************************ 
    •  * int main(int argc, PCHAR argv[]) 
    •  * 功能   设置和获取文件属性等 
    •  * 
    •  * 参数   显示第一个参数指定文件的属性、时间、大小 
    •  *      将第二个参数的属性设置为隐藏、只读。 
    •  * 
    •  * 返回值  0代表执行完成，1代码发生错误 
    •  **************************************/  
    • int main(int argc, PCHAR argv[])  
    • {     
    •     if(argc != 3)  
    •     {  
    •         printf("请输入参数/n");  
    •         printf("显示第一个参数指定文件的属性、时间、大小；/n");  
    •         printf("将第二个参数的属性设置为隐藏、只读。");  
    •         return 1;  
    •     }  
    •     ShowFileAttributes(argv[1]);  
    •     SetFileHiddenAndReadonly(argv[2]);  
    •     return 0;  
    • }  

     

     4.4 内存映射文件


    本节介绍Mapping File、文件句柄等较高级操作。本节将通过以下几个实例来讲解高级文件系统操作的API。
    ◇ 使用Mapping File提高文件读写的效率。
    ◇通过Mapping File在进程间共享内存。
    ◇通过文件句柄获得文件路径。
    4.4.1 使用Mapping File提高文件读写的效率
    文件映射( mapping)是一种在将文件内容映射到进程的虚拟地址空间的技术。视图(View)是一段虚拟地址空间，进程可以通过View来存取文件的内容，视图是一段内存，可以使用指针来操作视图。使用的文件映射之后，读写文件就如同对读写内存一样简单。在使用文件映射时需要创建映射对象，映射对象分为命名的和未命名的。映射对象还存取权限。
    使用文件映射至少有3个好处，一是因为文件是存储于硬盘上的，而文件视图是一段内存，使用文件映射操作时更方便；二是效率更高；三是可以在不同的进程间共享数据。
    文件映射依赖于系统虚拟内存管理的分页机制。
    本节将演示如何使用文件映射，下一节将演示如何使用文件映射来进行内存共享。
    1． 关键API
    （1）GetSystemInfo
    获取系统信息，在实例 4-14中用于获取系统内存分配粒度。有关内存分配粒度的概念参见第5章和虚拟内存管理相关章节。
    （2）CreateFileMapping。
    创建mapping对象，函数原型如下

    （3）MapViewOfFile。
    创建视图，将文件mapping映射到当前进程内存虚拟地址空间。函数原型如下：

     （4）FlushViewOfFile。
    将视图中的文件数据写入到磁盘上。调用此参数后，对映射视图的内存操作将会及时反映到硬件中的文件。函数原型如下：

    ◇使用说明
    如果不调用此函数，数据最终也会写回到硬盘，调用此函数后，数据会立刻写回到硬盘。
    (5) FillMemory、CopyMemory。内存操作函数，分别为填充内存和复制内存，详见第5章

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2. *《精通Windows API》  
    3. * 示例代码 
    4. * file_map.c 
    5. * 4.4.1  使用Mapping File提高文件读写的效率 
    6. **************************************/  
    7.   
    8. /* 头文件　*/  
    9. #include <windows.h>   
    10. #include <stdio.h>   
    11. /* 预处理申明　*/  
    12. #define BUFFSIZE 1024                   // 内存大小   
    13. #define FILE_MAP_START 0x28804          // 文件映射的起始的位置   
    14. /* 全局变量　*/  
    15. LPTSTR lpcTheFile = TEXT("test.dat");   // 文件名   
    16.   
    17. /* ************************************ 
    18. * int main(void) 
    19. * 功能    演示使用文件mapping 
    20. * 
    21. * 参数    无 
    22. * 
    23. * 返回值   0代表执行完成，1代表发生错误 
    24. **************************************/  
    25. int main(void)  
    26. {  
    27.     HANDLE hMapFile;      // 文件内存映射区域的句柄   
    28.     HANDLE hFile;         // 文件的句柄   
    29.     DWORD dBytesWritten;  // 写入的字节数   
    30.     DWORD dwFileSize;     // 文件大小   
    31.     DWORD dwFileMapSize;  // 文件映射的大小   
    32.     DWORD dwMapViewSize;  // 视图（View）的大小   
    33.     DWORD dwFileMapStart; // 文件映射视图的起始位置   
    34.     DWORD dwSysGran;      // 系统内存分配的粒度   
    35.     SYSTEM_INFO SysInfo;  // 系统信息   
    36.     LPVOID lpMapAddress;  // 内在映射区域的起始位置   
    37.     PCHAR pData;            // 数据   
    38.     INT i;                // 循环变量   
    39.     INT iData;  
    40.     INT iViewDelta;  
    41.     BYTE cMapBuffer[32];  // 存储从mapping中计出的数据   
    42.   
    43.     // 创建一个文件   
    44.     hFile = CreateFile(lpcTheFile,   
    45.         GENERIC_READ | GENERIC_WRITE,  
    46.         0,   
    47.         NULL,  
    48.         CREATE_ALWAYS,   
    49.         FILE_ATTRIBUTE_NORMAL,   
    50.         NULL);  
    51.     //判断文件是否创建成功   
    52.     if (hFile == INVALID_HANDLE_VALUE)  
    53.     {  
    54.         printf("CreateFile error/n",GetLastError);  
    55.         return 1;  
    56.     }  
    57.     // 依次写入整数，一共写入65535个整数   
    58.     // 在32位平台下，大小为65535*32   
    59.     for (i=0; i<65535; i++)   
    60.     {  
    61.         WriteFile (hFile, &i, sizeof (i), &dBytesWritten, NULL);  
    62.     }  
    63.     // 查看写入完成后的文件大小   
    64.     dwFileSize = GetFileSize(hFile,  NULL);  
    65.     printf("文件大小: %d/n", dwFileSize);  
    66.   
    67.     //获取系统信息，内存分配粒度   
    68.     //获取分配粒度，进行下面的几个计算，   
    69.     //目的是为了映射的数据与系统内存分配粒度对齐，提高内存访问效率   
    70.     GetSystemInfo(&SysInfo);  
    71.     dwSysGran = SysInfo.dwAllocationGranularity;  
    72.   
    73.     //计算mapping的起始位置   
    74.     dwFileMapStart = (FILE_MAP_START / dwSysGran) * dwSysGran;  
    75.     // 计算mapping view的大小   
    76.     dwMapViewSize = (FILE_MAP_START % dwSysGran) + BUFFSIZE;  
    77.     // 计算mapping的大小   
    78.     dwFileMapSize = FILE_MAP_START + BUFFSIZE;  
    79.     // 计算需要读取的数据的偏移   
    80.     iViewDelta = FILE_MAP_START - dwFileMapStart;  
    81.   
    82.     // 创建File mapping   
    83.     hMapFile = CreateFileMapping( hFile,          // 需要映射的文件的句柄   
    84.         NULL,           // 安全选项：默认   
    85.         PAGE_READWRITE, // 可读，可写   
    86.         0,              // mapping对象的大小，高位   
    87.         dwFileMapSize,  // mapping对象的大小，低位   
    88.         NULL);          // mapping对象的名字   
    89.     if (hMapFile == NULL)   
    90.     {  
    91.         printf("CreateFileMapping error: %d/n", GetLastError() );  
    92.         return 1;  
    93.     }  
    94.   
    95.     // 映射view   
    96.     lpMapAddress = MapViewOfFile(hMapFile,            // mapping对象的句柄   
    97.         FILE_MAP_ALL_ACCESS, // 可读，可写   
    98.         0,                   // 映射的文件偏移，高32位   
    99.         dwFileMapStart,      // 映射的文件偏移，低32位   
    100.         dwMapViewSize);      // 映射到View的数据大小   
    101.     if (lpMapAddress == NULL)   
    102.     {  
    103.         printf("MapViewOfFile error: %d/n", GetLastError());  
    104.         return 1;  
    105.     }  
    106.   
    107.     printf ("文件map view相对于文件的起始位置： 0x%x/n",  
    108.         dwFileMapStart);  
    109.     printf ("文件map view的大小：0x%x/n",     dwMapViewSize);  
    110.     printf ("文件mapping对象的大小：0x%x/n", dwFileMapSize);  
    111.     printf ("从相对于map view 0x%x 字节的位置读取数据，", iViewDelta);  
    112.   
    113.     // 将指向数据的指针偏移，到达我们关心的地方   
    114.     pData = (PCHAR) lpMapAddress + iViewDelta;  
    115.     // 读取数据，赋值给变量   
    116.     iData = *(PINT)pData;  
    117.     // 显示读取的数据   
    118.     printf ("为：0x%.8x/n", iData);  
    119.   
    120.     // 从mapping中复制数据，32个字节，并打印   
    121.     CopyMemory(cMapBuffer,lpMapAddress,32);  
    122.     printf("lpMapAddress起始的32字节是：");  
    123.     for(i=0; i<32; i++)  
    124.     {  
    125.         printf("0x%.2x ",cMapBuffer[i]);  
    126.     }  
    127.     // 将mapping的前32个字节用0xff填充   
    128.     FillMemory(lpMapAddress,32,(BYTE)0xff);  
    129.     // 将映射的数据写回到硬盘上   
    130.     FlushViewOfFile(lpMapAddress,dwMapViewSize);  
    131.     printf("/n已经将lpMapAddress开始的32字节使用0xff填充。/n");  
    132.   
    133.     // 关闭mapping对象   
    134.     if(!CloseHandle(hMapFile))   
    135.     {  
    136.         printf("/nclosing the mapping object error %d!",  
    137.             GetLastError());  
    138.     }  
    139.     //关闭文件   
    140.     if(!CloseHandle(hFile))   
    141.     {  
    142.         printf("/nError %ld occurred closing the file!",  
    143.             GetLastError());  
    144.     }  
    145.   
    146.     return 0;  
    147. }  

    4.4.2 通过Mapping File在进程间传递和共享数据
    进程间通信、共享数据有很多种方法，文件映射是常用的一种方法。因为mapping对象
    系统中是全局的，一个进程创建的Mapping对象可以从另外一个进程中打开，映射视图就
    进程间共享的内存了。一般在共享的内存数据量比较大时，选择使用文件映射进行共享。
    1．关键API
    （1）OpenFileMapping。
    打开已经存在的文件映射，函数原型如下：

    (2) UnmapViewO伍ile。
    取消文件映射，函数原型如下：

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2. *《精通Windows API》 
    3. * 示例代码 
    4. * pro_s1.c 
    5. * 4.4.2  通过Mapping File在进程间共享内存 
    6. **************************************/  
    7. /* 头文件　*/  
    8. #include <windows.h>   
    9. #include <stdio.h>   
    10. #include <conio.h>   
    11. /* 预处理申明　*/  
    12. #define BUF_SIZE 256   
    13. /* 全局变量　*/  
    14. LPTSTR szName = TEXT("SharedFileMappingObject");  
    15. LPTSTR szMsg = TEXT("进程的消息");  
    16.   
    17. /* ************************************ 
    18. * int main(void) 
    19. * 功能    演示文件mapping共享内存，写入数据到共享内存 
    20. * 
    21. * 参数    无 
    22. * 
    23. * 返回值   0代表执行完成，代表发生错误 
    24. **************************************/  
    25. void main(int argc, PCHAR argv[])  
    26. {  
    27.     //文件映射句柄   
    28.     HANDLE hMapFile;  
    29.     //共享数据缓冲区指针   
    30.     LPTSTR pBuf;  
    31.     //创建命名的文件映射，不代表任务硬盘上的文件   
    32.     hMapFile = CreateFileMapping(  
    33.         INVALID_HANDLE_VALUE,  
    34.         NULL,   
    35.         PAGE_READWRITE,  
    36.         0,  
    37.         BUF_SIZE,   
    38.         szName);  
    39.     if (hMapFile == NULL || hMapFile == INVALID_HANDLE_VALUE)   
    40.     {   
    41.         printf("CreateFileMapping error: %d/n", GetLastError());  
    42.         return;  
    43.     }  
    44.     //创建View   
    45.     pBuf = (LPTSTR) MapViewOfFile(hMapFile,  
    46.         FILE_MAP_ALL_ACCESS,  
    47.         0,                     
    48.         0,                     
    49.         BUF_SIZE);  
    50.     if (pBuf == NULL)   
    51.     {   
    52.         printf("MapViewOfFile error %d/n",  GetLastError());   
    53.         return;  
    54.     }  
    55.     //将共享数据复制到文件映射中，如果运行时输入了参数则使用参数   
    56.     if(argc==1)  
    57.     {  
    58.         CopyMemory((PVOID)pBuf, szMsg, strlen(szMsg));  
    59.     }  
    60.     else  
    61.     {  
    62.         DWORD dwCopyLen = (lstrlen(argv[1])<BUF_SIZE) ? lstrlen(argv[1]): BUF_SIZE;  
    63.         CopyMemory((PVOID)pBuf, argv[1], dwCopyLen);  
    64.     }  
    65.     printf("运行程序，完成运行后，按任意键退出。");  
    66.     _getch();  
    67.     //取消映射，退出   
    68.     UnmapViewOfFile(pBuf);  
    69.     CloseHandle(hMapFile);  
    70. }  

    ．实例4-15读取并显示共享数据
    本实例代码从实例4-14共享的Mapping对象中读取数据，并将数据显示出来。实例4-14与实例4-15是两个进程，实现了进程间数据的共享。这两个进程可以通过各自的指针，对同一段内存进行读写。
    本实例先打开指定对象名的Mapping对象（与实例4-14中使用的CreateFileMapping创建的Mapping对象需有一样的对象名），然后创建视图，从视图中读取数据。

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2. *《精通Windows API》 
    3. * 示例代码 
    4. * pro_s2.c 
    5. * 4.4.2  通过Mapping File在进程间共享内存 
    6. **************************************/  
    7. #include <windows.h>   
    8. #include <stdio.h>   
    9. #include <conio.h>   
    10. /* 预处理申明*/  
    11. #pragma comment (lib, "User32.lib")   
    12. #define BUF_SIZE 256   
    13. /* 全局变量　*/  
    14. TCHAR szName[]=TEXT("SharedFileMappingObject");  
    15.   
    16. /* ************************************ 
    17. * int main(void) 
    18. * 功能    演示文件mapping共享内存，从共享数据中读信息 
    19. * 
    20. * 参数    无 
    21. * 
    22. * 返回值   0代表执行完成，代表发生错误 
    23. **************************************/  
    24. void main()  
    25. {  
    26.     HANDLE hMapFile;  
    27.     LPTSTR pBuf;  
    28.     //打开文件mapping   
    29.     hMapFile = OpenFileMapping(  
    30.         FILE_MAP_ALL_ACCESS,  
    31.         FALSE,  
    32.         szName);   
    33.     if (hMapFile == NULL)   
    34.     {   
    35.         printf("OpenFileMapping error: %d./n",  GetLastError());  
    36.         return;  
    37.     }   
    38.     //映射   
    39.     pBuf = MapViewOfFile(hMapFile,  
    40.         FILE_MAP_ALL_ACCESS,  
    41.         0,                      
    42.         0,                      
    43.         BUF_SIZE);    
    44.     if (pBuf == NULL)   
    45.     {   
    46.         printf("MapViewOfFile error %d/n", GetLastError());   
    47.         return;  
    48.     }  
    49.     //消息得到的共享数据   
    50.     MessageBox(NULL, pBuf, TEXT("Process2"), MB_OK);  
    51.     //取消mapping，关闭句柄，返回   
    52.     UnmapViewOfFile(pBuf);  
    53.     CloseHandle(hMapFile);  
    54. }  

    4.4.3 通过文件句柄获得文件路径
    Windows系统提供了一个名为GetMappedFileName的API函数，这个函数可以实现从
    mapping对象的句柄得到被映射文件的路径。但是路径是以设备名的形式给出的，如类似于
    “/Device/HarddiskVolume3/1.TXT”的形式。
    将设备名转换为路径名需要使用到一个API函数-QueryDosDevice，这个函数可以将驱动器的根路径转换为设备名，然后进行循环比较，可得文件路径。
    1．关键API
    (1)GetMappedFileName。
    从映射对象获取被映射文件的文件设备名，函数原型如下：

    (2)QueryDosDevice
    获取MS_DOS设备名，函数原型如下：

    ◇返回值返回DWORD值，如果成功，则返回值为lpTargetPath指向字符串的长度，如果失败为0。
    2．实例4-16通过文件句柄获取文件路径
    GetFileNameFromHandle通过参数输入的句柄创建mapping对象，然后调用GetMapped
    FileName函数，获得对象所映射的文件的设备名，然后使用QueryDosDevice函数循环判断
    驱动器设备名与路径的关系，在找到正确的驱动器路径后，构造好文件路径并输出。

    [cpp] view plaincopyprint?
    1. /* ************************************ 
    2. *《精通Windows API》 
    3. * 示例代码 
    4. * handle_path.cpp 
    5. * 4.4.3 通过文件句柄获取文件路径 
    6. **************************************/  
    7. /* 头文件*/  
    8. #include <windows.h>   
    9. #include <stdio.h>   
    10. #include <tchar.h>   
    11. #include <string.h>   
    12. #include <psapi.h>   
    13. /* 预处理申明*/  
    14. #pragma comment (lib, "Psapi.lib")   
    15. #define BUFSIZE 512   
    16. /* 函数申明*/  
    17. BOOL GetFileNameFromHandle(HANDLE hFile) ;  
    18.   
    19. /* ************************************ 
    20. * BOOL GetFileNameFromHandle(HANDLE hFile)  
    21. * 功能    从文件句柄获取文件路径 
    22. * 
    23. * 参数    ANDLE hFile，需要获得路径的文件句柄 
    24. * 
    25. * 返回值BOOL 是否成功。 
    26. **************************************/  
    27. BOOL GetFileNameFromHandle(HANDLE hFile)   
    28. {  
    29.     TCHAR pszFilename[MAX_PATH+1];  
    30.     HANDLE hFileMap;  
    31.     PVOID pMem;  
    32.   
    33.     // 获得文件大小,并决断是否为   
    34.     DWORD dwFileSizeHigh = 0;  
    35.     DWORD dwFileSizeLow = GetFileSize(hFile, &dwFileSizeHigh);   
    36.     if( dwFileSizeLow == 0 && dwFileSizeHigh == 0 )  
    37.     {  
    38.         printf("不能map文件大小为的文件./n");  
    39.         return FALSE;  
    40.     }  
    41.     // 创建mapping对象   
    42.     hFileMap = CreateFileMapping(hFile,   
    43.         NULL,   
    44.         PAGE_READONLY,  
    45.         0,   
    46.         1,  
    47.         NULL);  
    48.     if (!hFileMap)   
    49.     {  
    50.         printf("CreateFileMapping error: %d",GetLastError());  
    51.         return FALSE;  
    52.     }  
    53.   
    54.     pMem = MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, 1);  
    55.     if (!pMem)   
    56.     {  
    57.         printf("MapViewOfFile error: %d",GetLastError());  
    58.         return FALSE;  
    59.     }  
    60.     // 从mapping对象获得文件名   
    61.     if (0 == GetMappedFileName (GetCurrentProcess(),   
    62.         pMem,   
    63.         pszFilename,  
    64.         MAX_PATH))  
    65.     {  
    66.         printf("GetMappedFileName error: %d",GetLastError());  
    67.         return FALSE;  
    68.     }  
    69.     // 将设备名转换为路径   
    70.     TCHAR szTemp[BUFSIZE] = {0};  
    71.     if (0 == GetLogicalDriveStrings(BUFSIZE-1, szTemp))   
    72.     {  
    73.         printf("GetLogicalDriveStrings error: %d",GetLastError());  
    74.         return FALSE;  
    75.     }  
    76.     TCHAR szName[MAX_PATH];  
    77.     TCHAR szDrive[3] = {0};  
    78.     BOOL bFound = FALSE;  
    79.     PTCHAR p = szTemp;  
    80.     do   
    81.     {  
    82.         CopyMemory(szDrive,p,2*sizeof(TCHAR));  
    83.         // 通过路径查找设备名   
    84.         if (!QueryDosDevice(szDrive, szName, BUFSIZE))  
    85.         {  
    86.             printf("QueryDosDevice error: %d",GetLastError());  
    87.             return FALSE;  
    88.         }  
    89.         UINT uNameLen = lstrlen(szName);  
    90.         if (uNameLen < MAX_PATH)   
    91.         {  
    92.             //比较驱动器的设备名与文件设备名是否匹配   
    93.             bFound = strncmp(pszFilename, szName,uNameLen) == 0;  
    94.             if (bFound)   
    95.             {  
    96.                 //如果匹配，说明已经找到，构造路径。   
    97.                 TCHAR szTempFile[MAX_PATH];  
    98.                 wsprintf(szTempFile,  
    99.                     TEXT("%s%s"),  
    100.                     szDrive,  
    101.                     pszFilename+uNameLen);  
    102.                 lstrcpy(pszFilename, szTempFile);  
    103.             }  
    104.         }  
    105.         // 循环到下一个NULL   
    106.         while (*p++);  
    107.     } while (!bFound && *p);  
    108.   
    109.     UnmapViewOfFile(pMem);  
    110.     CloseHandle(hFileMap);  
    111.     printf("File path is %s/n", pszFilename);  
    112.     return TRUE;  
    113. }  
    114.   
    115. /* ************************************ 
    116. * int main() 
    117. * 功能    查找第一个目录中第一个txt文件 
    118. *       打开文件，并根据文件句柄获得文件路径。 
    119. * 
    120. * 参数    未使用 
    121. * 
    122. * 返回值0表示成功，表示失败。 
    123. **************************************/  
    124. int main()  
    125. {  
    126.     HANDLE hFile;  
    127.     HANDLE hFind;  
    128.     WIN32_FIND_DATA wfd;  
    129.     hFind = FindFirstFile("*.txt",&wfd);  
    130.     if(hFind == INVALID_HANDLE_VALUE)  
    131.     {  
    132.         printf("can not find a file");  
    133.         return 1;  
    134.     }  
    135.     //CloseHandle(hFind);   
    136.     printf("find %s at current dir/n",wfd.cFileName);  
    137.     hFile = CreateFile(wfd.cFileName,   
    138.         GENERIC_READ | GENERIC_WRITE,  
    139.         0,   
    140.         NULL,  
    141.         OPEN_EXISTING,   
    142.         FILE_ATTRIBUTE_NORMAL,   
    143.         NULL);  
    144.     if(hFile == INVALID_HANDLE_VALUE)  
    145.     {  
    146.         printf("create file error, %d",GetLastError());  
    147.     }  
    148.     else  
    149.     {  
    150.         GetFileNameFromHandle(hFile) ;  
    151.     }  
    152.     CloseHandle(hFile);  
    153.     return 0;  
    154. }  
  • 相关阅读:
    Javascript 创建对象的三种方法及比较【转载+整理】
    Firebug Console Panel 控制台详解【转载+整理】
    解剖 CPU（另）
    解剖 CPU
    关于 URL 编码及 JavaScript 编码函数【转载+整理】
    基于用户投票的 6 个排名算法【转载+整理】
    奥巴马筹款网站的制作过程【转载+整理】
    CentOS 7.0关闭默认firewall防火墙启用iptables防火墙
    mybatis-generator 代码自动生成工具
    Linux中启动和停止jar包的运行
  • 原文地址：https://www.cnblogs.com/xiaogui9527/p/3269067.html
Copyright © 2011-2022 走看看