C++博客-天狼啸月-文章分类-文件及文件夹操作

移动文件、复制文件、新建目录源码

烈焰之光 — Fri, 23 Dec 2011 01:52:00 GMT

#include"iostream"
#include "windows.h"
#include "cstdlib"
using namespace std;
int main()
{
    CreateDirectoryA("D:\\test",0);
    CreateFileA("D:\\new.txt",GENERIC_WRITE,FILE_SHARE_WRITE,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
    CopyFileA("D:\\file.txt","D:\\new.txt",FALSE);
    CreateFileA("D:\\test\\new1.txt",GENERIC_WRITE,FILE_SHARE_WRITE,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
    MoveFile("D:\\file.txt","D:\\test\\new1.txt");
    DeleteFileA("D:\\file.txt");
    return 0;
}

烈焰之光 2011-12-23 09:52 发表评论

文件输入源码

烈焰之光 — Fri, 23 Dec 2011 01:51:00 GMT

#include
#include
#include
#include
using namespace std;
int main()
{
ofstream in;
in.open("a.txt",ios::out);
int i;
char a='a';
char b[10];
for(i=1;i<26;i++)
{
  char *c=itoa(i,b,10);
  if(i<10)
  {
   in<<"0"<   a++;
  }
  else
  {
   in<   a++;
  }
}
in.close();
return 0;
}

烈焰之光 2011-12-23 09:51 发表评论

统计文件行数源码

烈焰之光 — Fri, 23 Dec 2011 01:46:00 GMT

#include
#include
#include
using namespace std;
int CountLines(char *filename)
{
ifstream ReadFile;
int n=0;
char line[512];
string temp;
ReadFile.open(filename,ios::in);
if(ReadFile.fail())
  return 0;
else
{
  while(getline(ReadFile,temp))
   n++;
  return n;
}
ReadFile.close();
}
void main()
{
cout<<"a.txt的行数为："< cin.get();
}

烈焰之光 2011-12-23 09:46 发表评论

读取文件数据到数组源码

烈焰之光 — Fri, 23 Dec 2011 01:45:00 GMT

#include
#include
#include
using namespace std;
int CountLines(char *filename)                              //获取文件行数
{
ifstream ReadFile;
int n=0;
string temp;
ReadFile.open(filename,ios::in);                        //表示以只读方式方式读取文件
if(ReadFile.fail())
  return 0;
else                                                     //文件存在，返回文件行数
{
  while(getline(ReadFile,temp))
  {
   n++;
  }
  return n;
}
ReadFile.close();
}
void main()
{
ifstream file;
int LINES;
char filename[512];
cout<<"请输入要打开的文件名："< cin>>filename;
file.open(filename,ios::in);
if(file.fail())
{
  cout<<"文件不存在"<  file.close();
  cin.get();
}
else                                                         //文件存在
{
  LINES=CountLines(filename);

  int *tc=new int[LINES];
  char *t=new char[LINES];
  int i=0;
  while(!file.eof())                                        //读取数据到数组
  {
   file>>tc[i];
   file>>t[i];
   i++;
   cout<  }
  file.close();
   cout<  for(i=0;i   cout<   cin.get();
   cin.get();
}
}

烈焰之光 2011-12-23 09:45 发表评论

读取文件源码（读取某一行）

烈焰之光 — Fri, 23 Dec 2011 01:43:00 GMT

#include
#include
#include
using namespace std;
int CountLines(char *filename)
{
ifstream ReadFile;
int n=0;
string tmp;
ReadFile.open(filename,ios::in);
if(ReadFile.fail())
{
  return 0;
}
else
{
  while(getline(ReadFile,tmp))
  {
   n++;
  }
  return n;
}
ReadFile.close();
}
string ReadLine(char *filename,int line)
{
int lines,i=0;
string temp;
fstream file;
file.open(filename,ios::in);
lines=CountLines(filename);
if(lines<=0)
{
  return"Error 1:行数错误，不能为零或负数。";
}
if(file.fail())
{
  return"Error 2:文件不存在";
}
if(line>lines)
{
  return "Error 3:行数超出文件长度";
}
while(getline(file,temp)&&i {
  i++;
}
file.close();
return temp;
}
void main()
{
int l;
char filename[256];
cout<<"请输入文件名："< cin>>filename;
cout<<"\n请输入要读取的行数："< cin>>l;
cout< cin.get();
cin.get();
}

烈焰之光 2011-12-23 09:43 发表评论

读出文件放在数组中源码

烈焰之光 — Fri, 23 Dec 2011 01:41:00 GMT

#include
#include
using namespace std;
int main()
{
ifstream infile;
ofstream outfile;
int ch;
int row=1;
int column=1;
infile.open("a.txt");
while((ch=infile.get())!=EOF)
{
  column++;
  if(ch==10)
   row++;
}
column=column=column/2/row;
infile.close();
infile.clear();
infile.open("a.txt");
int **a=new int *[row];
for(int i=0;i  a[i]=new int[column];
int m=0;
int n=0;
while(infile>>a[m][n])
{
  ++n;
  if(n%3==0)
  {
   ++m;
   n=0;
  }
}
infile.close();
outfile.open("c.txt");
for(i=0;i {
  for(int j=0;j   outfile<  outfile< }
for(i=0;i  delete [] a[i];
delete []a;
a=NULL;
return 0;
}

烈焰之光 2011-12-23 09:41 发表评论

读出文件源码（按字节读出）

烈焰之光 — Fri, 23 Dec 2011 01:40:00 GMT

#include
#include
using namespace std;
int main()
{
char buffer[256];
fstream out;
out.open("1.html",ios::in);
cout<<"12.txt的内容如下："< int i=0;
while(!out.eof())
{
  out.getline(buffer,256,'\n');
  cout<  i++;
  if(i==5)
   break;
}
out.close();
}

烈焰之光 2011-12-23 09:40 发表评论

读出文件源码（按行读出）

烈焰之光 — Fri, 23 Dec 2011 01:37:00 GMT

#include<iostream>
#include<fstream>
using namespace std;
int main()
{
    char buffer[256];
    fstream out;
    out.open("1.html",ios::in);
    cout<<"12.txt的内容如下："<<endl;
    int i=0;
    while(!out.eof())
    {
        out.getline(buffer,256,'\n');
        cout<<buffer<<endl;
        i++;
        if(i==5)
            break;
    }
    out.close();
}

烈焰之光 2011-12-23 09:37 发表评论

遍历文件夹源码

烈焰之光 — Fri, 23 Dec 2011 01:34:00 GMT

#include <iostream>
#include <string>
#include <io.h>
#include <stdlib.h>
#include <string.h>
#include <fstream>

using namespace std;

int search_dir(string prefix,int i)
{
    ofstream in;
    in.open("a.txt",ios::out);
    string root = prefix + "*";
    _finddata_t data;

    long handle = _findfirst(root.c_str(), &data);
    if (handle == -1)
    {
        cerr << "error" << endl;
        exit(1);
    }

    if (data.attrib == _A_SUBDIR && strcmp(data.name, ".") && strcmp(data.name, ".."))
    {
        cout << data.name << endl;
        i=search_dir(prefix + data.name + "\\",i);
    }
    else
    {
        cout << data.name << endl;
        in<<data.name<<"\n";
        i++;
    }

    while (_findnext(handle, &data) != -1)
    {
        if (data.attrib == _A_SUBDIR && strcmp(data.name, ".") && strcmp(data.name, ".."))
        {
            cout << data.name << endl;
            i=search_dir(prefix + data.name + "\\",i);
        }
        else
        {
            cout << data.name << endl;
            in<<data.name<<"\n";
            i++;
        }
    }

    _findclose(handle);
    return(i);
}

int main()
{
    int i=0;
    const string root = "D:\\result1\\";
    i=search_dir(root,i);
    cout<<"i="<<i<<endl;
    return 0;
}

烈焰之光 2011-12-23 09:34 发表评论

fstream打开文件

烈焰之光 — Fri, 23 Dec 2011 01:29:00 GMT

fstream提供的三个类：
ifstream             从已有文件读
ofstream             向文件写内容
fstream              打开文件供读写
文件打开模式：
ios::in              读
ios::out             写
ios::app             从文件末尾开始写
ios::binary          二进制模式
ios::nocreate        打开一个文件时，如果文件不存在，不创建文件
ios::noreplace       打开一个文件时，如果文件不存在，创建该文件
ios::trun            打开一个文件，然后清空内容
ios::ate             打开一个文件，将位置移动到文件尾
文件指针位置在c++中的用法：
ios::beg             文件头
ios::end             文件尾
ios::cur             当前位置
例子：
file.seekg(0,ios::beg)             让文件指针定位到文件开头
file.seekg(0,ios::end)             让文件指针定位到文件末尾
file.seekg(10,ios::cur)            让文件指针从当前位置向文件尾方向移动10个字节
file.seekg(-10,ios::cur)           让文件指针从当前位置向文件开始方向移动10个字节
file.seekg(10,ios::beg)            让文件指针定位代理文件开头10个字节的位置

烈焰之光 2011-12-23 09:29 发表评论

windows中提供的对于文件进行操作的API函数及功能

烈焰之光 — Fri, 23 Dec 2011 01:28:00 GMT

下面是windows中提供的对于文件进行操作的API函数及其功能:

CloseHandle 关闭一个内核对象。其中包括文件、文件映射、进程、线程、安全和同步对象等。涉及文件处理时，这个函数通常与vb的close命令相似。应尽可能的使用close，因为它支持vb的差错控制。注意这个函数使用的文件句柄与vb的文件编号是完全不同的
CompareFileTime 根据FILETIME结构的信息，对比两个文件的时间
CopyFile 复制文件。与vb的filecopy命令相似
CreateFile 这是一个全功能的函数，可打开和创建文件、管道、邮槽、通信服务、设备以及控制台
DeleteFile 删除指定文件
FindClose 关闭由FindFirstFile函数创建的一个搜索句柄
FindFirstFile 根据文件名查找文件
FindNextFile 根据调用FindFirstFile函数时指定的一个文件名查找下一个文件
FlushFileBuffers 针对指定的文件句柄，刷新内部文件缓冲区
GetBinaryType 判断文件是否可以执行
GetFileAttributes 判断指定文件的属性
GetFileInformationByHandle 这个函数提供了获取文件信息的一种机制——在一个BY_HANDLE_FILE_INFORMATION结构中装载与文件有关的信息
GetFileSize 判断文件长度
GetFileTime 取得指定文件的时间信息
GetFileType 在给出文件句柄的前提下，判断文件类型
GetFileVersionInfo 从支持版本标记的一个模块里获取文件版本信息
GetFileVersionInfoSize 针对包含了版本资源的一个文件，判断容纳文件版本信息需要一个多大的缓冲区
GetShortPathName 获取指定文件的短路径名
GetTempFileName 这个函数包含了一个临时文件的名字，它可由应用程序使用
lclose 关闭指定的文件，请参考CloseHandle函数，了解进一步的情况
lcreat 创建一个文件。如文件已经存在，就会将其缩短成零长度，并将其打开，以便读写
llseek 设置文件中进行读写的当前位置。该函数与vb的seek语句类似。如果用vb的open命令打开了一个文件，那么不要再对这个文件使用llseek函数
LockFile 在windows中，文件可用共享模式打开——在这种情况下，多个进程可同时访问该文件。利用这个函数，要对文件进行读写的一个应用程序可将文件的某一部分锁定起来，使其不能由其他应用程序访问。这样便避免了同时读写时发生的冲突
LockFileEx 与LockFile相似，只是它提供了更多的功能
lopen 以二进制模式打开指定的文件
lread 将文件中的数据读入内存缓冲区
lwrite 将数据从内存缓冲区写入一个文件
MoveFile, MoveFileEx 移动文件。如dwFlags设为零，则MoveFile完全等价于MoveFileEx
OpenFile 这个函数能执行大量不同的文件操作。和这个函数相比，请优先考虑win32的CreateFile函数（它能打开命名管道和控制Unicode文件名，同时不受128个字符的路径名称的限制）
ReadFile 从文件中读出数据。与lread函数相比，这个函数要明显灵活的多。该函数能够操作通信设备、管道、套接字以及邮槽
ReadFileEx 与ReadFile相似，只是它只能用于异步读操作，并包含了一个完整的回调
SearchPath 查找指定文件
SetEndOfFile 针对一个打开的文件，将当前文件位置设为文件末尾
SetFileAttributes 设置文件属性
SetFilePointer 在一个文件中设置当前的读写位置
SetFileTime 设置文件的创建、访问及上次修改时间
UnlockFile 解除对一个文件的锁定
UnlockFileEx 解除对一个文件的锁定
WriteFile 将数据写入一个文件。该函数比lwrite函数要灵活的多。也可将这个函数应用于对通信设备、管道、套接字以及邮槽的处理
WriteFileEx 与WriteFile类似，只是它只能用于异步写操作，并包括了一个完整的回调

　　让我们通过几个例子来详细的了解一下其中主要的几个函数及其用法:

　　1、CreateFile

　　作用：这是一个全功能的例程，可打开和创建文件、管道、邮槽、通信服务、设备以及控制台

　　声明形式：

Declare Function CreateFile Lib "kernel32" Alias "CreateFileA" (ByVal lpFileName As String, ByVal dwDesiredAccess As Long, ByVal dwShareMode As Long, lpSecurityAttributes As SECURITY_ATTRIBUTES, ByVal dwCreationDisposition As Long, ByVal dwFlagsAndAttributes As Long, ByVal hTemplateFile As Long) As Long

　　说明：

　　此函数的返回值类型为Long，如执行成功，则返回文件句柄。INVALID_HANDLE_VALUE表示出错，会设置GetLastError。即使函数成功，但若文件存在，且指定了CREATE_ALWAYS 或 OPEN_ALWAYS，GetLastError也会设为ERROR_ALREADY_EXISTS

　　打开一个通信端口时（如COM1），无论如何都要设置成 OPEN_EXISTING。

　　这个函数代替了lOpen 和 lCreate函数，应该是我们的首选

　　参数说明：
lpFileName：String，要打开的文件的名字

dwDesiredAccess：Long，如果为 GENERIC_READ 表示允许对设备进行读访问；如果为 GENERIC_WRITE 表示允许对设备进行写访问（可组合使用）；如果为零，表示只允许获取与一个设备有关的信息

dwShareMode ：Long，零表示不共享； FILE_SHARE_READ 和/或 FILE_SHARE_WRITE 表示允许对文件进行共享访问

lpSecurityAttributes：SECURITY_ATTRIBUTES，指向一个SECURITY_ATTRIBUTES结构的指针，定义了文件的安全特性（如果操作系统支持的话）

dwCreationDisposition：Long，下述常数之一：
CREATE_NEW 创建文件；如文件存在则会出错
CREATE_ALWAYS 创建文件，会改写前一个文件
OPEN_EXISTING 文件必须已经存在。由设备提出要求
OPEN_ALWAYS 如文件不存在则创建它
TRUNCATE_EXISTING 讲现有文件缩短为零长度

dwFlagsAndAttributes：Long，一个或多个下述常数
FILE_ATTRIBUTE_ARCHIVE 标记归档属性
FILE_ATTRIBUTE_COMPRESSED 将文件标记为已压缩，或者标记为文件在目录中的默认压缩方式
FILE_ATTRIBUTE_NORMAL 默认属性
FILE_ATTRIBUTE_HIDDEN 隐藏文件或目录
FILE_ATTRIBUTE_READONLY 文件为只读
FILE_ATTRIBUTE_SYSTEM 文件为系统文件
FILE_FLAG_WRITE_THROUGH 操作系统不得推迟对文件的写操作
FILE_FLAG_OVERLAPPED 允许对文件进行重叠操作
FILE_FLAG_NO_BUFFERING 禁止对文件进行缓冲处理。文件只能写入磁盘卷的扇区块
FILE_FLAG_RANDOM_ACCESS 针对随机访问对文件缓冲进行优化
FILE_FLAG_SEQUENTIAL_SCAN 针对连续访问对文件缓冲进行优化
FILE_FLAG_DELETE_ON_CLOSE 关闭了上一次打开的句柄后，将文件删除。特别适合临时文件
也可在Windows NT下组合使用下述常数标记：
SECURITY_ANONYMOUS， SECURITY_IDENTIFICATION， SECURITY_IMPERSONATION， SECURITY_DELEGATION， SECURITY_CONTEXT_TRACKING， SECURITY_EFFECTIVE_ONLY

hTemplateFile：Long，如果不为零，则指定一个文件句柄。新文件将从这个文件中复制扩展属性

　　示例如下:

long hfile= CreateFile(“c:\\test.txt”,GENERIC_READ,

FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,

OPEN_EXISTING,FILE_ELAG_OVERLAPPED,NULL)

　　2、lcreat

　　作用：创建一个文件。如文件已经存在，就会将其缩短成零长度，并将其打开，以便读写

　　声明形式：

Declare Function lcreat Lib "kernel32" Alias "_lcreat" (ByVal lpPathName As String, ByVal iAttribute As Long) As Long

　　说明：此函数的返回值类型为Long，如执行成功，返回打开文件的句柄。如果出错，则返回HFILE_ERROR

　　该函数会打开已由其他应用程序打开的文件，所以使用它时要小心。win32的CreateFile函数已取代了这个函数。这个函数与vb的open语句作用相同

　　参数说明：

lpPathName：String，欲创建的文件的名字
iAttribute：Long，下述值之一：
　0——文件能够读写
　1——创建只读文件
　2——创建隐藏文件
　3——创建系统文件

　　例如下面的语句打开c：\test.txt文件

lcreat “c:\test.txt”,0

　　3、lopen

　　作用：以二进制模式打开指定的文件

　　声明形式：

Declare Function lopen Lib "kernel32" Alias "_lopen" (ByVal lpPathName As String, ByVal iReadWrite As Long) As Long

　　说明：此函数的返回值类型为Long，如执行成功，返回打开文件的句柄。HFILE_ERROR表示出错。会设置GetLastError

　　CreateFile函数在win32下提供了更多的功能：

　　参数说明：

lpPathName ：String，欲打开文件的名字

iReadWrite： Long，访问模式和共享模式常数的一个组合，如下所示：
1、访问模式
READ 打开文件，读取其中的内容
READ_WRITE 打开文件，对其进行读写
WRITE 打开文件，在其中写入内容
2、共享模式（参考OpenFile函数的标志常数表）
OF_SHARE_COMPAT， OF_SHARE_DENY_NONE， OF_SHARE_DENY_READ， OF_SHARE_DENY_WRITE， OF_SHARE_EXCLUSIVE

　　4、GetFileTime

　　作用：取得指定文件的时间信息

　　声明形式：

Declare Function GetFileTime Lib "kernel32" Alias "GetFileTime" (ByVal hFile As Long, lpCreationTime As FILETIME, lpLastAccessTime As FILETIME, lpLastWriteTime As FILETIME) As Long

　　说明：Long，非零表示成功，零表示失败。会设置GetLastError

　　如果不需要特定的信息，那么lpCreationTime，lpLastAccessTime，lpLastWriteTime都可以设置为零（用ByVal As Long）。这个函数返回的文件时间采用UTC格式

　　参数说明：

hFile： Long，文件的句柄
lpCreationTime： FILETIME，用于装载文件的创建时间
lpLastAccessTime： FILETIME，用于装载文件上一次访问的时间（FAT文件系统不支持这一特性）
lpLastWriteTime： FILETIME，用于装载文件上一次修改的时间

　　示例代码如下：

‘函数声明

Private Declare Function GetFileTime Lib "kernel32" (ByVal hFile As Long, lpCreationTime As FileTime, lpLastAccessTime As FileTime, lpLastWriteTime As FileTime) As Long

Private Declare Function lopen Lib "kernel32" Alias "_lopen" (ByVal lpPathName As String, ByVal iReadWrite As Long) As Long

‘定义变量

Dim file As Long
Dim CreationTime As FileTime
Dim lastaccesstime As FileTime
Dim lastaccesstime As FileTime

‘定义结构

Private Type FileTime
　dwLowDateTime As Long
　dwHighDateTime As Long

End Type

Private Sub Form_Load()
　str1 = "c:\text.txt"
　file = lopen(str1, READ_WRITE) ‘打开文件
　temp = GetFileTime(file, CreationTime, lastaccesstime, lastwritetime)’得到文件相关信息
　MsgBox CreationTime ‘显示信息

End Sub

　　以上代码显示文件的创建时间

　　5、CopyFile

　　作用：复制文件。与vb的filecopy命令相似

　　声明形式：

Declare Function CopyFile Lib "kernel32" Alias "CopyFileA" (ByVal lpExistingFileName As String, ByVal lpNewFileName As String, ByVal bFailIfExists As Long) As Long

　　说明：Long，非零表示成功，零表示失败。会设置GetLastError

　　参数说明：

lpExistingFileName： String，源文件名
lpNewFileName： String，目标文件名
bFailIfExists： Long，如果设为TRUE（非零），那么一旦目标文件已经存在，则函数调用会失败。否则目标文件被改写

　　示例代码如下：

‘函数声明

Private Declare Function CopyFile Lib "kernel32" Alias "CopyFileA" (ByVal lpExistingFileName As String, ByVal lpNewFileName As String, ByVal bFailIfExists As Long) As Long

Private Sub Form_Load()

　CopyFile "c:\test1.txt", "c:\test2.txt", 1

End Sub

　　以上代码将c:\test1.txt 拷贝到c:\test2.txt
6、MoveFile, MoveFileEx

　　作用：移动文件。如dwFlags设为零，则MoveFile完全等价于MoveFileEx

　　声明形式：

Declare Function MoveFile& Lib "kernel32" Alias "MoveFileA" (ByVal lpExistingFileName As String, ByVal lpNewFileName As String)

Declare Function MoveFileEx& Lib "kernel32" Alias "MoveFileExA" (ByVal lpExistingFileName As String, ByVal lpNewFileName As String, ByVal dwFlags As Long)

　　说明：Long，非零表示成功，零表示失败。会设置GetLastError

　　这两个函数通常不能将文件从一个卷移动到另一个卷。但如设置了MOVEFILE_COPY_ALLOWED标记，MoveFileEx可以做到这一点.

　　参数说明：

lpExistingFileName： String，欲移动的文件名

lpNewFileName： String，新文件名

dwFlags： Long，一个或多个下述常数
MOVEFILE_REPLACE_EXISTING 如目标文件存在，则将其替换
MOVEFILE_COPY_ALLOWED 如移动到一个不同的卷，则复制文件并删除原来的文件
MOVEFILE_DELAY_UNTIL_REBOOT 移动操作在系统下次重新启动时正式进行。这样便可在Windows NT中改换系统文件

　　示例代码如下：

‘定义结构

Private Const MOVEFILE_COPY_ALLOWED = &H2
Private Const MOVEFILE_DELAY_UNTIL_REBOOT = &H4
Private Const MOVEFILE_REPLACE_EXISTING = &H1

‘函数声明

Private Declare Function MoveFile& Lib "kernel32" Alias "MoveFileA" (ByVal lpExistingFileName As String, ByVal lpNewFileName As String)

Private Declare Function MoveFileEx& Lib "kernel32" Alias "MoveFileExA" (ByVal lpExistingFileName As String, ByVal lpNewFileName As String, ByVal dwFlags As Long)

Private Sub Form_Load()
　MoveFile "c:\test.txt", "d:\test1.txt" ‘移动文件
　MoveFileEx "d:\test1.txt", "c:\test.txt", MOVEFILE_REPLACE_EXISTING ‘再一次移动
End Sub

　　以上代码实现了文件的移动，两次移动後，文件不变

　　7、DeleteFile

　　作用：删除指定文件

　　声明形式：

Declare Function DeleteFile Lib "kernel32" Alias "DeleteFileA" (ByVal lpFileName As String) As Long

　　说明：Long，非零表示成功，零表示失败。会设置GetLastError

　　与vb的kill语句相似，在windows 95下使用这个函数要小心——即使文件当前正由一个应用程序打开，该函数也会将其删除.

　　参数说明：

参数类型及说明
lpFileName String，欲删除文件的名字

　　示例代码如下：

‘函数声明

Private Declare Function DeleteFile Lib "kernel32" Alias "DeleteFileA" (ByVal lpFileName As String) As Long

Private Sub Form_Load()

　DeleteFile "c:\test.txt"

End Sub

　　以上代码删除了c:\test.txt文件

　　写了这没多，真的很累了，所以更希望自己的辛苦没有白费，VB虽然是一个RAD类的工具,并让很多人不屑使用,但实事求是得说,VB的功能的确强大,尤其是人性化的设计,让人爱不释手,希望对喜爱VB的爱好者能够对vb能产生一个新的认识，而不仅仅停留在对其提供的现有控件的使用。

烈焰之光 2011-12-23 09:28 发表评论

CFile操作详解

烈焰之光 — Fri, 23 Dec 2011 01:13:00 GMT

各种关于文件的操作在程序设计中是十分常见，如果能对其各种操作都了如指掌，就可以根据实际情况找到最佳的解决方案，从而在较短的时间内编写出高效的代码，因而熟练的掌握文件操作是十分重要的。本文将对Visual C++中有关文件操作进行全面的介绍，并对在文件操作中经常遇到的一些疑难问题进行详细的分析。
　　1．文件的查找
　　当对一个文件操作时，如果不知道该文件是否存在，就要首先进行查找。MFC中有一个专门用来进行文件查找的类CFileFind，使用它可以方便快捷地进行文件的查找。下面这段代码演示了这个类的最基本使用方法。
　　CString strFileTitle;
　　CFileFind finder;
　　BOOL bWorking = finder.FindFile("C://windows//sysbkup//*.cab");
　　while(bWorking)
　　{
　　bWorking=finder.FindNextFile();
　　strFileTitle=finder.GetFileTitle();
　　}
　　2．文件的打开/保存对话框
　　让用户选择文件进行打开和存储操作时，就要用到文件打开/保存对话框。MFC的类CFileDialog用于实现这种功能。使用CFileDialog声明一个对象时，第一个BOOL型参数用于指定文件的打开或保存，当为TRUE时将构造一个文件打开对话框，为FALSE时构造一个文件保存对话框。
　　在构造CFileDialog对象时，如果在参数中指定了OFN_ALLOWMULTISELECT风格，则在此对话框中可以进行多选操作。此时要重点注意为此CFileDialog对象的m_ofn.lpstrFile分配一块内存，用于存储多选操作所返回的所有文件路径名，如果不进行分配或分配的内存过小就会导致操作失败。下面这段程序演示了文件打开对话框的使用方法。
　　CFileDialog mFileDlg(TRUE,NULL,NULL,
　　OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_ALLOWMULTISELECT,
　　"All Files (*.*)|*.*||",AfxGetMainWnd());
　　CString str(" ",10000);
　　mFileDlg.m_ofn.lpstrFile=str.GetBuffer(10000);
　　str.ReleaseBuffer();
　　POSITION mPos=mFileDlg.GetStartPosition();
　　CString pathName(" ",128);
　　CFileStatus status;
　　while(mPos!=NULL)
　　{
　　pathName=mFileDlg.GetNextPathName(mPos);
　　CFile::GetStatus( pathName, status );
　　}
　　3．文件的读写
　　文件的读写非常重要，下面将重点进行介绍。文件读写的最普通的方法是直接使用CFile进行，如文件的读写可以使用下面的方法：
　　//对文件进行读操作
　　char sRead[2];
　　CFile mFile(_T("user.txt"),CFile::modeRead);
　　if(mFile.GetLength()<2)
　　return;
　　mFile.Read(sRead,2);
　　mFile.Close();
　　//对文件进行写操作
　　CFile mFile(_T("user.txt "), CFile::modeWrite|CFile::modeCreate);
　　mFile.Write(sRead,2);
　　mFile.Flush();
　　mFile.Close();
　　虽然这种方法最为基本，但是它的使用繁琐，而且功能非常简单。我向你推荐的是使用CArchive，它的使用方法简单且功能十分强大。首先还是用CFile声明一个对象，然后用这个对象的指针做参数声明一个CArchive对象，你就可以非常方便地存储各种复杂的数据类型了。它的使用方法见下例。
　　//对文件进行写操作
　　CString strTemp;
　　CFile mFile;
　　mFile.Open("d://dd//try.TRY",CFile::modeCreate|CFile::modeNoTruncate|CFile::modeWrite);
　　CArchive ar(&mFile,CArchive::store);
　　ar<<　　ar.Close();
　　mFile.Close();
　　//对文件进行读操作
　　CFile mFile;
　　if(mFile.Open("d://dd//try.TRY",CFile::modeRead)==0)
　　return;
　　CArchive ar(&mFile,CArchive::load);
　　ar>>strTemp;
　 ar.Close();
　　mFile.Close();
　　CArchive的 << 和>> 操作符用于简单数据类型的读写，对于CObject派生类的对象的存取要使用ReadObject()和WriteObject()。使用CArchive的ReadClass()和WriteClass()还可以进行类的读写，如：
　　//存储CAboutDlg类
　　ar.WriteClass(RUNTIME_CLASS(CAboutDlg));
　　//读取CAboutDlg类
　　CRuntimeClass* mRunClass=ar.ReadClass();
　　//使用CAboutDlg类
　　CObject* pObject=mRunClass->CreateObject();
　　((CDialog* )pObject)->DoModal();
　　虽然VC提供的文档/视结构中的文档也可进行这些操作，但是不容易理解、使用和管理，因此虽然很多VC入门的书上花费大量篇幅讲述文档/视结构，但我建议你最好不要使用它的文档。关于如何进行文档/视的分离有很多书介绍，包括非常著名的《Visual C++ 技术内幕》。
　　如果你要进行的文件操作只是简单的读写整行的字符串，我建议你使用CStdioFile，用它来进行此类操作非常方便，如下例。
　　CStdioFile mFile;
　　CFileException mExcept;
　　mFile.Open( "d://temp//aa.bat", CFile::modeWrite, &mExcept);
　　CString string="I am a string.";
　　mFile.WriteString(string);
　　mFile.Close();
　4．临时文件的使用

　　正规软件经常用到临时文件，你经常可以会看到C:/Windows/Temp目录下有大量的扩展名为tmp的文件，这些就是程序运行是建立的临时文件。临时文件的使用方法基本与常规文件一样，只是文件名应该调用函数GetTempFileName()获得。它的第一个参数是建立此临时文件的路径，第二个参数是建立临时文件名的前缀，第四个参数用于得到建立的临时文件名。得到此临时文件名以后，你就可以用它来建立并操作文件了，如：
　　char szTempPath[_MAX_PATH],szTempfile[_MAX_PATH];
　　GetTempPath(_MAX_PATH, szTempPath);
　　GetTempFileName(szTempPath,_T ("my_"),0,szTempfile);
　　CFile m_tempFile(szTempfile,CFile:: modeCreate|CFile:: modeWrite);
　　char m_char='a';
　　m_tempFile.Write(&m_char,2);
　　m_tempFile.Close();
　　5．文件的复制、删除等
　　MFC中没有提供直接进行这些操作的功能，因而要使用SDK。SDK中的文件相关函数常用的有CopyFile()、CreateDirectory()、DeleteFile()、MoveFile()。它们的用法很简单，可参考MSDN。

1,判断文件是否存在
access(filename,mode);
2,对于不同用途又不同的文件操作,其中API函数CreateFile()也是比较有用处理方式,对于巨型文件很合适的其他的楼上的大都说了,不重复了.

[1]显示对话框，取得文件名

CString FilePathName;
CFileDialog dlg(TRUE);///TRUE为OPEN对话框，FALSE为S***E AS对话框
if (dlg.DoModal() == IDOK)
FilePathName=dlg.GetPathName();

相关信息：CFileDialog 用于取文件名的几个成员函数：
假如选择的文件是C:/WINDOWS/TEST.EXE
则(1)GetPathName();取文件名全称，包括完整路径。取回C:/WINDOWS/TEST.EXE
(2)GetFileTitle();取文件全名：TEST.EXE
(3)GetFileName();取回TEST
(4)GetFileExt();取扩展名EXE

[2]打开文件
CFile file("C:/HELLO.TXT",CFile::modeRead);//只读方式打开
//CFile::modeRead可改为 CFile::modeWrite(只写),
//CFile::modeReadWrite(读写),CFile::modeCreate(新建)
例子：
{
CFile file;
file.Open("C:/HELLO.TXT",CFile::modeCreate|Cfile::modeWrite);
.
.
.
}

[3]移动文件指针
file.Seek(100,CFile::begin);///从文件头开始往下移动100字节
file.Seek(-50,CFile::end);///从文件末尾往上移动50字节
file.Seek(-30,CFile::current);///从当前位置往上移动30字节
file.SeekToBegin();///移到文件头
file.SeekToEnd();///移到文件尾

[4]读写文件
读文件：
char buffer[1000];
file.Read(buffer,1000);
写文件：
CString string("自强不息");
file.Write(string,8);

[5]关闭文件
file.Close();

烈焰之光 2011-12-23 09:13 发表评论

VC_CFile类和文件操作API

烈焰之光 — Fri, 23 Dec 2011 01:11:00 GMT

在VC中，操作文件的方法有两种，一是利用一些API函数来创建，打开，读写文件，另外一个是利用MFC的CFile类，CFile封装了对文件的一般操作。下面主要介绍如何利用这两种方法操作文件。

一．创建或打开一个文件
1、 API函数CreateFile可打开和创建文件、管道、邮槽、通信服务、设备以及控制台，但是在此时只是介绍用这个函数怎么实现创建和打开一个文件。

HANDLE CreateFile(
LPCTSTR lpFileName, // 要打开的文件名
DWORD dwDesiredAccess, // 文件的操作属性
DWORD dwShareMode, // 文件共享属性
LPSECURITY_ATTRIBUTES lpSecurityAttributes,// 文件安全特性
DWORD dwCreationDisposition, //文件操作
DWORD dwFlagsAndAttributes, // 文件属性
HANDLE hTemplateFile // 如果不为零，则指定一个文件句柄。新文件将从这个文件中复制扩展属性
);

文件的操作属性：
如果为零，表示只允许获取与一个设备有关的信息;
GENERIC_READ 表示允许对设备进行读访问；
如果为GENERIC_WRITE 表示允许对设备进行写访问（可组合使用）；

文件的共享属性：
零表示不共享；
FILE_SHARE_READ 或 FILE_SHARE_WRITE 表示允许对文件进行读/写共享访问

文件的操作有：
CREATE_NEW：创建文件；如文件存在则会出错
CREATE_ALWAYS：创建文件，会改写前一个文件
OPEN_EXISTING：文件必须已经存在。由设备提出要求
OPEN_ALWAYS：如文件不存在则创建它
TRUNCATE_EXISTING：将现有文件缩短为零长度

文件属性有：
FILE_ATTRIBUTE_ARCHIVE：标记归档属性
FILE_ATTRIBUTE_COMPRESSED：将文件标记为已压缩，或者标记为文件在目录中的默认压缩方式
FILE_ATTRIBUTE_NORMAL：默认属性
FILE_ATTRIBUTE_HIDDEN：隐藏文件或目录
FILE_ATTRIBUTE_READONLY：文件为只读
FILE_ATTRIBUTE_SYSTEM：文件为系统文件
FILE_FLAG_WRITE_THROUGH：操作系统不得推迟对文件的写操作
FILE_FLAG_OVERLAPPED：允许对文件进行重叠操作
FILE_FLAG_NO_BUFFERING：禁止对文件进行缓冲处理。文件只能写入磁盘卷的扇区块
FILE_FLAG_RANDOM_ACCESS：针对随机访问对文件缓冲进行优化
FILE_FLAG_SEQUENTIAL_SCAN：针对连续访问对文件缓冲进行优化
FILE_FLAG_DELETE_ON_CLOSE：关闭了上一次打开的句柄后，将文件删除。

特别适合临时文件可以组合的属性有：FILE_FLAG_WRITE_THROUGH，FILE_FLAG_OVERLAPPED，FILE_FLAG_NO_BUFFERING，FILE_FLAG_RANDOM_ACCESS，FILE_FLAG_SEQUENTIAL_SCAN，FILE_FLAG_DELETE_ON_CLOSE，FILE_FLAG_BACKUP_SEMANTICS，FILE_FLAG_POSIX_SEMANTICS，FILE_FLAG_OPEN_REPARSE_POINT，FILE_FLAG_OPEN_NO_RECALL

如果成功返回一个打开文件得句柄，如果调用函数之前文件存在，文件操作属性为：CREATE_ALWAYS 或 OPEN_ALWAYS，使用GetLastError函数返回的是ERROR_ALREADY_EXISTS（包括函数操作成功），如果之前函数不存在，则返回0。使用失败返回INVALID_HANDLE_VALUE，要取得更多的信息，使用GetLastError函数。

文件的关闭用： BOOL CloseHandle( HANDLE hObject // handle to object to close );

例子1
在当前目录下面创建一个文件：

HANDLE handle; DWORD Num; handle= ::CreateFile("new.tmp",GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_ALWAYS,FILE_FLAG_DELETE_ON_CLOSE,NULL); if(INVALID_HANDLE_VALUE!= handle )
{
::SetFilePointer(handle,0,0,FILE_BEGIN);
char Buffer[] = "这是个刚创建的文件";
::WriteFile(handle,Buffer,sizeof(Buffer),&Num,NULL);
ZeroMemory(Buffer,sizeof(Buffer));
::SetFilePointer(handle,0,0,FILE_BEGIN);
::ReadFile(handle,Buffer,sizeof(Buffer),&Num,NULL);
MessageBox(Buffer);
::CloseHandle(handle);
}
可以改变上面的创建文件的属性和操作看下不同效果。

CFile创建和打开一个文件：
创建文件和打开文件的方法有很多种，下面简单介绍下几个构造函数：
CFile( LPCTSTR lpszFileName, UINT nOpenFlags );
throw( CFileException );
CFile( );
BOOL Open( LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError = NULL );
lpszFileName:文件名称，可以是相对路径，绝对路径或网络路径

nOpenFlags：打开方式，有：
CFile::modeCreate 调用构造函数构造一个新文件，如果文件已存在，则长度变成0。
CFile::modeNoTruncate 此值与modeCreate组合使用。如果所创建的文件已存在则其长度不变为0。因而此文件被打开，或者作为一个新文件或者作为一个已存在的文件。这将是很有用的，例如当打开一个可能存在也可能不存在的文件时。
CFile::modeRead 打开文件仅供读。
CFile::modeReadWrite 打开文件供读写。
CFile::modeWrite 打开文件仅供写。
CFile::modeNoInherit 阻止文件被子进程继承。
CFile::ShareDenyNone 不禁止其它进程读或写访问，打开文件。如果文件已被其它进程以兼容模式打开，则Create失败。
CFile::ShareDenyRead 打开文件，禁止其它进程读此文件。如果文件已被其它进程以兼容模式打开，或被其它进程读，则Create失败
CFile::ShareDenyWrite 打开文件，禁止其它进程写此文件。如果文件已被其它进程以兼容模式打开，或被其它进程写，则Create失败。
CFile::ShareExclusive 以独占模式打开文件，禁止其它进程对文件的读写。如果文件已经以其它模式打开读写（即使被当前进程），则构造失败。 CFile::ShareCompat 此标志在32位MFC中无效。此标志在使用CFile:: Open时映射为CFile::ShareExclusive。
CFile::typeText 对回车换行设置特殊进程（仅用于派生类）。 CFile::typeBinary 设置二进制模式（仅用于派生类）。
下面给出MSDN中的一个例子：
char* pFileName = "test.dat";
TRY
{
CFile f( pFileName, CFile::modeCreate | CFile::modeWrite );
}
CATCH( CFileException, e )
{
#ifdef _DEBUG afxDump << "File could not be opened " << e->m_cause << "\n"; #endif
}
END_CATCH
CFile fileTest;
char* pFileName = "test.dat";
TRY
{
fileTest.Open(pFileName, CFile::modeCreate |CFile::modeWrite);
}
CATCH_ALL(e)
{ fileTest.Abort( );
THROW_LAST ( );
}
END_CATCH_ALL

二．文件的读写定位：
（一）定位文件中的数据是很重要的，这决定了写入的数据在文件中的位置。

1、API函数 DWORD SetFilePointer(
HANDLE hFile, //文件的句柄
LONG lDistanceToMove, //字节偏移量r
PLONG lpDistanceToMoveHigh, //指定一个长整数变量，其中包含了要使用的一个高双字偏移（一般用来操作大型文件）。可设为零，表示只使用lDistanceToMove DWORD dwMoveMethod //文件定位
);

dwMoveMethod文件定位的方式有三种：
FILE_BEGIN：从文件开始处。
FILE_CURRENT：从当前位置。
FILE_END：从文件的末尾。
此函数可以用来定位大型文件，lpDistanceToMoveHigh是高32位，lDistanceToMove是低32位。如果lpDistanceToMoveHigh为NULL时，函数操作成功，返回的是当前文件数据的偏移量，如果lpDistanceToMoveHigh不NULL，则返回数据的偏移量高32位放在lpDistanceToMoveHigh中，函数调用失败返回的是0xffffffff.
BOOL SetEndOfFile( HANDLE hFile //文件的句柄 );

2、CFile类的文件数据定位函数有：
LONG Seek(LONG lOff,UINT nFrom);
throw(CFileException);
如果要求的位置合法，则Seek返回从文件开始起的新字节偏移量
lOff：指针移动的字节数。
nFrom：指针移动的模式。可以是CFile::begin，CFile::current，CFile::end
void SeekToBegin( );
DWORD SeekToEnd( );//返回文件长度（字节数）。
下面是一个读取位图文件的信息的例子：
CFile file;
BITMAPINFOHEADER bmpinfo;
try
{
file.Open("D:\\ToolBar.bmp",CFile::modeRead);
file.Seek(sizeof(BITMAPFILEHEADER),CFile::begin);
file.Read(&bmpinfo,sizeof(BITMAPINFOHEADER ));
CString str;
str.Format("位图文件的长是%d,高%d",bmpinfo.biWidth,bmpinfo.biHeight);
MessageBox(str);
file.Close();
}
catch(CFileException *e)
{
CString str;
str.Format("读取数据失败的原因是:%d",e->m_cause);
MessageBox("str");
file.Abort();
e->Delete();
}

（二）读取数据：

1、BOOL ReadFile(
HANDLE hFile, //文件的句柄
LPVOID lpBuffer, //用于保存读入数据的一个缓冲区
DWORD nNumberOfBytesToRead, //要读入的字符数
LPDWORD lpNumberOfBytesRead, //从文件中实际读入的字符数
LPOVERLAPPED lpOverlapped //如文件打开时指定了FILE_FLAG_OVERLAPPED，那么必须，用这个参数引用一个特殊的结构。该结构定义了一次异步读取操作。否则，应将这个参数设为NULL
);

2、CFile的成员函数有： UINT Read (void* lpBuf,UINT nCount); throw(CFileException);// 返回值是传输到缓冲区的字节数。

（三）写入数据：

1、BOOL WriteFile(
HANDLE hFile, //文件的句柄
LPCVOID lpBuffer, //要写入的一个数据缓冲区
DWORD nNumberOfBytesToWrite, //要写入数据的字节数量。如写入零字节，表示什么都不写入，但会更新文件的“上一次修改时间”。
LPDWORD lpNumberOfBytesWritten, //实际写入文件的字节数量
LPOVERLAPPED lpOverlapped // OVERLAPPED，倘若在指FILE_FLAG_OVERLAPPED的前提下打开文件，这个参数就必须引用一个特殊的结构。该结构定义了一次异步写操作。否则，该参数应置为NULL
);

2、
void Write(const void* lpBuf,UINT nCount);
throw (CFileException);
lpBuf：指向用户提供的缓冲区，包含将写入文件中的数据
nCount：从缓冲区内传输的字节数。
对文本模式的文件，回车换行作为一个字符。
下面是象一个文件中写入数据的例子：
CFile file;
try
{
file.Open("d:/my.dat",CFile::modeCreate|CFile::modeWrite);
file.SeekToBegin();
char Data[] = "111111111\n1111111111";
file.Write(Data,sizeof(Data));
file.Flush();
file.Close();
}
catch(CFileException *e)
{
CString str;
str.Format("读取数据失败的原因是:%d",e->m_cause);
MessageBox("str");
file.Abort();
e->Delete();
}

三．取得和设置文件的创建时间、最后访问时间、最后写时间

BOOL GetFileTime(
HANDLE hFile, // 文件句柄
LPFILETIME lpCreationTime, // 创建时间
LPFILETIME lpLastAccessTime, // 最后访问时间
LPFILETIME lpLastWriteTime // 最后写时间
);

BOOL SetFileTime(
HANDLE hFile,
CONST FILETIME *lpCreationTime,
CONST FILETIME *lpLastAccessTime,
CONST FILETIME *lpLastWriteTime
);
typedef struct _FILETIME {
DWORD dwLowDateTime;
DWORD dwHighDateTime;
}
FILETIME; 取得三个参数都是FILETIME结构，得到的都是UTC时间，可以通过API函数FileTimeToLocalFileTime（）和FileTimeToSystemTime()将他们转换为本地时间和系统时间格式，也可以通过LocalFileTimeToFileTime和SystemTimeToFileTime()转换回来，通过SetFileTime设置文件的创建时间、最后访问时间、最后写时间。

由于使用的时候要先打开文件，而且取得的最后访问时间就是当前时间，没有多大意义，且比较麻烦，下面介绍CFile类中的静态方法。

static BOOL PASCAL GetStatus(LPCTSTR lpszFileName,CFileStatus& rStatus );
static void SetStatus( LPCTSTR lpszFileName, const CFileStatus& status );
throw( CFileException );
返回的是一个CfileStatus对象，这个结构的具体的成员变量包括：
struct CFileStatus
{
CTime m_ctime; // 文件创建时间
CTime m_mtime; // 文件最近一次修改时间
CTime m_atime; // 文件最近一次访问时间
LONG m_size; // 文件大小
BYTE m_attribute; // 文件属性
BYTE _m_padding; // 没有实际含义，用来增加一个字节
TCHAR m_szFullName[_MAX_PATH]; //绝对路径
#ifdef _DEBUG //实现Dump虚拟函数，输出文件属性
void Dump(CDumpContext& dc) const;
#endif
};
下面就举一个例子来实现：
CFileStatus status;
char *path = "D:\\VSS";
if(CFile::GetStatus( path, status ))
{
CString cTime,mTime,aTime;
cTime = status.m_ctime.Format("文件建立时间：%Y年%m月%d日 %H时%M分%S秒");
mTime = status.m_mtime.Format("文件最近修改时间：%Y年%m月%d日 %H时%M分%S秒");
aTime = status.m_atime.Format("文件最近访问时间：%Y年%m月%d日 %H时%M分%S秒");
CString str;
str = cTime + "\n" + mTime +"\n" + aTime ;
MessageBox(str);
}

四．取得和设置文件的属性
DWORD GetFileAttributes( LPCTSTR lpFileName //文件或文件夹路经 );
BOOL SetFileAttributes( LPCTSTR lpFileName, // 文件名 DWORD dwFileAttributes // 要设置的属性 );

取得的文件属性包括：FILE_ATTRIBUTE_ARCHIVE，FILE_ATTRIBUTE_HIDDEN，FILE_ATTRIBUTE_NORMAL，FILE_ATTRIBUTE_OFFLINE，FILE_ATTRIBUTE_READONLY，FILE_ATTRIBUTE_SYSTEM，FILE_ATTRIBUTE_TEMPORARY

不能设置的文件属性包括有：FILE_ATTRIBUTE_COMPRESSED，FILE_ATTRIBUTE_DIRECTORY，FILE_ATTRIBUTE_ENCRYPTED，FILE_ATTRIBUTE_REPARSE_POINT，FILE_ATTRIBUTE_SPARSE_FILE，FILE_ATTRIBUTE_SYSTEM。

CFileStatus中也定义了一组属性：
enum Attribute { normal, readOnly, hidden, system, volume, directory, archive };
可以通过if((status. m_attribute& readOnly) = =FILE_ATTRIBUTE_READONLY)来判断，这里利用另外的API来实现获得文件的详细信息：

HANDLE FindFirstFile( LPCTSTR lpFileName, //文件或文件夹路经r LPWIN32_FIND_DATA lpFindFileData );
BOOL FindNextFile( HANDLE hFindFile, LPWIN32_FIND_DATA lpFindFileData );
BOOL FindClose( HANDLE hFindFile );

取得的是一个WIN32_FIND_DATA结构;
typedef struct _WIN32_FIND_DATA {
DWORD dwFileAttributes; //文件属性
FILETIME ftCreationTime; // 文件创建时间
FILETIME ftLastAccessTime; // 文件最后一次访问时间
FILETIME ftLastWriteTime; // 文件最后一次修改时间
DWORD nFileSizeHigh; // 文件长度高32位
DWORD nFileSizeLow; // 文件长度低32位
DWORD dwReserved0; // 系统保留
DWORD dwReserved1; // 系统保留
TCHAR cFileName[ MAX_PATH ]; // 长文件名
TCHAR cAlternateFileName[ 14 ]; // 8.3格式文件名
}
WIN32_FIND_DATA, *PWIN32_FIND_DATA;

也可以利用另外一个函数来取得文件的信息:
BOOL GetFileInformationByHandle( HANDLE hFile, // 文件的句柄 LPBY_HANDLE_FILE_INFORMATION lpFileInformation );

函数填充的是BY_HANDLE_FILE_INFORMATION结构体:
typedef struct _BY_HANDLE_FILE_INFORMATION {
DWORD dwFileAttributes; //文件属性
FILETIME ftCreationTime; // 文件创建时间
FILETIME ftLastAccessTime; // 文件最后一次访问时间
FILETIME ftLastWriteTime; // 文件最后一次修改时间
DWORD dwVolumeSerialNumber; // 文件所在的磁盘的序列号
DWORD nFileSizeHigh; // 文件长度高32位
DWORD nFileSizeLow; // 文件长度低32位
DWORD nNumberOfLinks; //链接的数目
DWORD nFileIndexHigh;
DWORD nFileIndexLow;
}
BY_HANDLE_FILE_INFORMATION;

下面就举一个例子来实现：
HANDLE handle;
WIN32_FIND_DATA find_data;
handle = :: FindFirstFile("D:\\VSS",&find_data);
FindClose(handle);
find_data.dwFileAttributes = find_data.dwFileAttributes|FILE_ATTRIBUTE_READONLY;
::SetFileAttributes("D:\\VSS",find_data.dwFileAttributes);
在上面的介绍中,除了可以设置文件的属性之外，在操作的过程当中也可以取得文件的其他一些信息，可以根据具体的需要来实现。

五．获取文件名,文件类型,文件长度,文件路径
用利用CFile打开一个文件时,可以在利用成员函数

virtual CString GetFileName( ) const,
virtual CString GetFileTitle( ) const,
virtual CString GetFilePath( ) const,
virtual DWORD GetLength( ) const;
throw( CFileException );
来取得相关信息,如果一个文件的全路经是: c:\windows\write\myfile.wri,则每个函数取得的是: myfile.wri, myfile, c:\windows\write\myfile.wri. GetLength取得文件大小是按字节为单位的.

也可以利用：
virtual void SetLength( DWORD dwNewLen );
throw( CFileException );
virtual void SetFilePath( LPCTSTR lpszNewName );
来设置文件的长度和路径。

在当前的文件下面新建一个Text.txt文件，在里面写点东西，然后运行下面程序： CFile file("Text.txt",CFile::modeReadWrite);
ULONGLONG length; CString strFilePath;
length = file.GetLength();
length = length + 1024*10;
file.SetLength(length);
file.SetFilePath("D:\\Text.txt");
strFilePath = file.GetFilePath();
MessageBox(strFilePath);
file.Close();
最后发现文件的路径变了，但是在D盘下面并没有找到Text.txt，原因是SetFilePath只能指定一个路径给文件，SetFilePath并不能做为移动文件来使用。
CFile并没有给出取得文件类型的函数，有了上面基础，这个很容易实现。
API函数中也有获得文件路径的操作，这里只是做简单介绍，可以参照MSDNN的说明：
GetFileSize可以获得文件的大小，
GetFullPathName 函数获取文件的完整路径名，只有当该文件在当前目录下，结果才正确。
GetModuleFileName函数获取文件的完整路径名，这些函数有些用到文件句柄的。
用CFileDialog打开的文件,可以使用它的成员变量m_ofn,或者成员函数GetFileName, GetFileTitle, GetFilePath,GetFileExt来取得相关信息.
CFileDialog( BOOL bOpenFileDialog, LPCTSTR lpszDefExt = NULL, LPCTSTR lpszFileName = NULL, DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, LPCTSTR lpszFilter = NULL, CWnd* pParentWnd = NULL );
各个参数如下：
bOpenFileDialog 为TRUE为打开对话框，为FALSE为保存对话文件对话框 lpszDefExt 指定默认的文件扩展名。
lpszFileName 指定默认的文件名。
dwFlags 指明一些特定风格。
lpszFilter它指明可供选择的文件类型和相应的扩展名。参数格式如： "Chart Files (*.xlc)|*.xlc|Worksheet Files (*.xls)|*.xls|Data Files (*.xlc;*.xls)|*.xlc; *.xls|All Files (*.*)|*.*||";文件类型说明和扩展名间用 | 分隔，同种类型文件的扩展名间可以用 ; 分割，每种文件类型间用 | 分隔，末尾用 || 指明。
pParentWnd 为父窗口指针 CString FileFilter = "所有文件(*.*)|*.*||";

CFileDialog FileDialog(true,NULL,NULL,OFN_HIDEREADONLY,FileFilter,NULL);
FileDialog.DoModal();
MessageBox(FileDialog.GetFileName());

烈焰之光 2011-12-23 09:11 发表评论