C / C++ 文件文件夹操作详细整理

专题1   C/C++ 文件读写

#本文件所述内容遵循C/C++原汁原味思想。

#YangJD 2013/8/2 整理

#http://blog.csdn.net/cquredstar

一、C环境下文件夹操作

C的文件夹操作相关的结构体和函数定义在头文件io.h中。主要有结构体_finddata_t，函数_access、_findfirst、_findnext和_findclose。

1.结构体 _finddata_t内容如下:

#define _finddata_t  _finddata64i32_t

struct _finddata64i32_t {

       unsigned    attrib;

       __time64_t  time_create;    /* -1 for FAT file systems */

       __time64_t  time_access;    /* -1 for FAT file systems */

        __time64_t  time_write;         /*typedef __int64 __time64_t;*/

        _fsize_t     size;                       /*typedef unsigned long _fsize_t;*/

       char        name[260];

};

unsinged attrib的值有以下几种：

_A_ARCH（存档）

_A_HIDDEN（隐藏）

_A_NORMAL（正常）

_A_RDONLY（只读）

_A_SUBDIR（文件夹）

_A_SYSTEM（系统）

它们本身都是2的幂的宏定义。

2. 相关函数

_access函数的声明与定义

int  _access(_In_z_ const char * _Filename, _In_int _AccessMode);

返回值：若文件或文件夹存在，则返回非 -1值；若不存在，返回-1

参数：_Filename是文件夹或文件的路径字符串；_AccessMode指期望访问的方式。

_findfirst函数的声明与定义

#define_findfirst  _findfirst32

long _findfirst(char *filespec, struct _finddata_t *fileinfo )；

返回值：如果查找成功的话，将返回一个long型的唯一的查找用的句柄（就是一个唯一编号）。这个句柄将在_findnext函数中被使用。若失败，则返回-1。

参数：filespec标明文件的字符串，可支持通配符。比如：*.c，则表示当前文件夹下的所有后缀为C的文件；fileinfo用来存放文件信息的结构体的指针。这个结构体必须在调用此函数前声明，不过不用初始化，只要分配了内存空间就可以了。函数成功后，函数会把找到的文件的信息放入这个结构体中。

_findnext函数的声明和定义

#define_findnext  _findfirst32

int  _findnext( long handle, struct _finddata_t*fileinfo );

返回值：若成功返回0，否则返回-1。

参数：handle是由_findfirst函数返回回来的句柄；fileinfo是用来存放文件信息的结构体的指针。

_findclose函数的声明和定义

        int  _findclose( long handle );

        返回值：成功返回0，失败返回-1。

        参数： handle是由_findfirst函数返回的句柄。

3.示例程序

#pragma once

#include <io.h>/* 声明了文件夹或文件属性操作的结构体及函数 */

#include <stdio.h> /* 声明了标准输入相关的宏定义或函数 */

#include <stdlib.h> /* system("");要用到*/

#include <string.h> /* 定义了字符串操作相关函数*/

 

int main(int argn,char** argv)

{

         /*char*dir=".//test";*/

         chardir[128];

         charfilename[128];

         struct_finddata_t fddata;/*必须加上struct说明*/

         printf("pleaseinput an dir path:");

         scanf("%s",dir);

         if(_access(dir,0)==-1)

         {

                   printf("%sis unavalible.",dir);

                   system("pause");

                   return-1;

         }

         strcpy(filename,dir);

         strcat(filename,"//*.*");

         longhandle_fd=_findfirst(filename,&fddata);/*找到当前文件或文件夹下第一个文件*/

         if(!handle_fd)/*检查是否找到*/

         {

                   printf("%sis unavalible.",filename);

                   system("pause");

                   return-1;

         }

         do

         {

                   if(fddata.attrib==_A_SUBDIR)

                   {

                            printf("Dir: %s\n",fddata.name);

                   }

                   else

                   {

                            printf("File: %s\n",fddata.name);

                   }

         }while(!_findnext(handle_fd,&fddata));

         _findclose(handle_fd);/*关闭句柄内容*/

         system("pause");

         return0;

}

二、C环境下文件读写

在标准C中，对文件的操作分为流文件操作和标准I/O文件操作。

1.流文件操作

有关流文件操作的数据结构或函数定义在头文件stdio.h中。FILE结构体描述了一个文件的属性。

FILE结构体定义如下：

struct _iobuf {

        char *_ptr;

        int   _cnt;

        char *_base;

        int   _flag;

        int   _file;

        int   _charbuf;

        int   _bufsiz;

        char *_tmpfname;

        };

typedef struct _iobuf FILE;

文件操作的函数主要有：

FILE* fopen(constchar* file name, const char* _mode) //打开流,不成功返回NULL

         文件打开方式可以为：

         "r"以只读方式打开文件

"w" 以只写方式打开文件

"a" 以追加方式打开文件

"r+" 以读/写方式打开文件，如无文件出错

"w+" 以读/写方式打开文件，如无文件生成新文件

int fclose(FILE*) //关闭流

intfputc(int c, FILE *stream) //写一个字符到流中，如fputc("X",fp)

int fgetc(FILE*stream)//从流中读一个字符,如char ch=fgetc(fp)

int fseek(FILE*stream, long OFFSET, intfromwhere)//在流中定位到指定的字符

         OFFSET是偏移量，fromwhere是移动基准量，其值可以是：

         SEEK_SET0 文件开头

SEEK_CUR 1 当前读写的位置

SEEK_END 2 文件尾部

int fputs(constchar *s, FILE *stream)//写字符串到流

char *fgets(char*s, int n, FILE *stream)/*

从流中读一行或指定个字符，从流中读取n-1个字符，除非读完一行，参数s是来接收字符串，如果成功则返回s的指针，否则返回NULL

*/

intfprintf(FILE *stream, const char *format[, argument, …]) //按格式输出到流

int fscanf(FILE*stream, const char *format[, address, …]) //从流中按格式读取

intfeof(FILE *stream) //到达文件尾时返回真值

int ferror(FILE*stream)//发生错误时返回其值

void rewind(FILE*stream)//复位文件定位器到文件开始处

int remove(constchar *filename) //删除文件

size_t fread(void*ptr, size_t size, size_t n, FILE*stream)/*

从流中读指定个数的字符；参数ptr是保存读取的数据，void*的指针可用任何类型的指针来替换，如char*、int*等等来替换；size是每块的字节数；n是读取的块数，如果成功，返回实际读取的块数(不是字节数)，本函数一般用于二进制模式打开的文件中

*/

size_t fwrite(constvoid *ptr, size_t size, size_t n, FILE *stream) /*

向流中写指定个数的字符;参数ptr是要写入的数据指针，void*的指针可用任何类型的指针来替换，如char*、int *等等来替换；size是每块的字节数；n是要写的块数，如果成功，返回实际写入的块数(不是字节数)，本函数一般用于二进制模式打开的文件中

*/

FILE* tmpfile(void)//生成一个临时文件流,

char* tmpnam(char*s) //生成一个唯一的文件名,其实tmpfile()就调用了此函数

 

2.标准I/O文件操作

标准I/O文件按操作通过直接存/取文件来完成对文件的处理，此类文件操作是围绕一个文件的“句柄”来进行。句柄是一个整数，是系统用来标识一个文件的唯一的记号。标准I/O文件操作相关的数据结构和函数主要定义在头文件io.h和fntl.h中。

主要的函数有：

int open(constchar *path, int access [, unsigned mode]); /*

打开一个文件并返回它的句柄;参数path是要打开的文件名，access是打开的模式，mode是可选项。打开模式可以为：

O_RDONLY 只读方式

O_WRONLY 只写方式

O_RDWR 读/写方式

O_NDELAY 用于UNIX系统

O_APPEND 追加方式

O_CREAT 如果文件不存在就创建

O_TRUNC 把文件长度截为0

O_EXCL  与O_CREAT连用，如果文件存在返回错误

O_BINARY 二进制方式

O_TEXT 文本方式

对于多个要求，可以用"|"运算符来连接，如O_APPEND|O_TEXT表示以文本模式和追

加方式打开文件。

*/

int close(int handle)// 关闭一个句柄

long lseek(int handle, long OFFSET, int fromwhere)// 定位到文件的指定位置

int read(int handle, void *buf, unsignedlen)/*

块读文件，参数buf保存读出的数据，len是读取的字节。函数返回实际读出的字节。*/

int write(int handle, void *buf, unsignedlen)/*

块写文件,参数的含义同read()，返回实际写入的字节

*/

int eof(int handle)// 测试文件是否结束

long filelength(int handle)//取得文件长度,相当于lseek(handle,0L,SEEK_END)

int rename(const char *oldname, const char*newname)//重命名文件

int chsize(int handle, long size)/*

改变文件长度，如果指定的长度小于文件长度，则文件被截短；如果指定的长度大

于文件长度，则在文件后面补''/0''。

*/

3.示例程序

流式C风格文件操作

#include <stdio.h>   /*定义了基本的输入输出*/

#include <stdlib.h>/* void free(void*ptr) */

int main(int argn,char** argv)

{

         charfilename[128];

         charbuffer[128];

         charstr[]="MAX";

         intdata=10;

         FILE*fp;

         printf("pleaseinput file path(128):");

         scanf("%s",filename);

         fp=fopen(filename,"w+");

         if(!fp)/*检查是否打开*/

         {

                   printf("%sis unavaliable.");

                   system("pause");

                   return-1;

         }

         fputc('X',fp);    

         rewind(fp);/*定位到文件开头*/

         printf("fgetc:%c\n",fgetc(fp));

         fseek(fp,0,SEEK_END);/*回到文件尾*/

         fputs("yangjdis a good boy!\n",fp);

         fseek(fp,0,SEEK_SET);

         fgets(buffer,128,fp);

         printf("fgets:%s\n",buffer);

         fseek(fp,0,SEEK_END);

         fprintf(fp,"%s\t%d\n",str,data);

         fseek(fp,0,SEEK_SET);

         fscanf(fp,"%s%d",buffer,&data);

         printf("fscanf:%s\t%d\n",buffer,data);

         rewind(fp);

         while(!feof(fp))

         {

                   fgets(buffer,128,fp);

                   printf("fgetsloop:%s\n",buffer);

         }

         fclose(fp);

         //free(fp);

         system("pause");

         return0;

}

 

标准I/O方式 C风格文件操作

#include <io.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdlib.h>//system

#include <string.h>

//#include <conio.h>//clrscr()函数

int main(int argn,char** argv)

{

         char  filename[128];

         charbuffer[1024];

         intfh;

         longflen;

         intleaves;

         inti=1;

         intreallen;

         memset(buffer,'\0',1024);

         printf("filename:");

         scanf("%s",filename);

         fh=open(filename,O_RDONLY|O_TEXT);

         if(fh==-1)

         {

                   printf("error:%sis unavaliable.",filename);

                   system("pause");

                   return-1;

         }

         flen=filelength(fh);

         leaves=flen/1024;

         for(;!eof(fh);i++)

         {

                   system("cls");

                   reallen=read(fh,buffer,1024);

                   printf("%d\\%d",i,leaves);

                   printf("\n===================================\n");

                   printf("%s",book);

                   system("pause");

         }

         close(fh);

         system("pause");

         return0;

}

三、C++环境下文件夹操作

C++本身没有定义支持文件夹的操作。但是利用C的io.h头文件支持则可以完成C/C++风格的文件夹操作。参看第一节所述内容。

四、C++环境下文件读写

1. 相关头文件

IO标准库（类型和头文件）

头文件

类型

iostream

istream 从流中读取

ostream 写到流中去

iostream 对流进行读写；从istream和ostream派生而来

fstream

ifstream 从文件中读取；由istream派生而来

ofstream 写到文件中去；由ostream派生而来

fstream 读写文件；由iostream派生而来

sstream

istringstream 从string对象中读取；由istream派生而来

ostringstream 写到stream对象中去；由ostream派生而来

stringstream 对string对象进行读写；由iostream派生而来

这里所描述的流类读写的是由char类型组成的流。此外，标准库还定义了一组相关的类型，支持wchar_t类型。每个头文件前加上"w"前缀，以与char类型的版本区分开来，如wfstream。文件的读写（输入与输出）主要使用fstream类及其派生类即可。

2. 流的条件状态

IO标准库的条件状态

strm::iostate

机器相关的整型名，用于定义条件状态

strm::badbit

strm::iostate类型的值，用于指出被破坏的流

strm::failbit

strm::iostate类型的值，用于指出失败的IO操作

strm::eofbit

strm::iostate类型的值，用于指出流已经到达文件结束符

s.eof()

如果设置了流s的eofbit值，则返回true

s.fail()

如果设置了流s的failbit值，则返回true

s.bad()

如果设置了流s的badbit值，则返回true

s.good()

如果设置了流s处于有效状态，则返回true

s.clear()

将流s中的所有状态值都重设为有效状态

s.clear(flag)

将流s中的某个状态设置为有效。flag为strm::iostate类型

s.setstate(flag)

给流s添加指定条件

s.rdstate()

返回流s的当前条件，返回值类型为strm::iostate

3. C++中的文件名

通常比较好的方法是将文件名读入string对象，而不是C风格的字符数组，然后调用string对象的c_str()成员获取C风格字符串用来作为文件名参数。

4. 文件模式

文件模式

in

读

out

写

app

在每次写之前找到文件尾（追加）

ate

打开文件后立即将文件定位在文件尾

trunc

打开文件时清空已存在的文件流

binary

以二进制模式进行IO操作

5. 文件模式的有效组合

文件模式的有效组合

out

删除文件中已有的数据，然后写

out|app

在文件尾写入

out|trunc

同out

in

读

in|out

定位于文件开头处读写

in|out|trunc

删除文件中已有的数据，进行读写

6. 示例程序

#pragma once

#include <fstream>

//#include <ifstream>//在VC2010中，fstream包含了ifstream

//#include <ofstream>//在VC2010中，fstream包含了ofstream

#include <iostream>//定义了cout等标准输入输出流

#include <string>//为字符串类型提供支持和定义，包括单字节字符串(由char组成)的string

//和多字节字符串(由wchar_t组成)

 

using namespace std;

 

int main(int argn,char* argv[])

{

   cout << "C++ File Subject!" << endl;

   string filename;

         cout<<"filename:";

   //cin>>filename;//这种方式遇到空格就会终止读入，可替换为getline(cin,filename)

         getline(cin,filename);

ifstreaminFile;//(filename.c_str(),fstream::in);//以构造函数方式打开，调用c_str()得到C

//风格字符串

         inFile.open(filename.c_str(),ifstream::in);//以open函数打开，调用c_str()得到C风格字符

//串

   if(!inFile)//检查文件是否打开

    {

       cerr<<"error: unable to open input file:"<<filename<<endl;

                   system("pause");

       return -1;

    }

   string line;

   getline(inFile,line);//声明和定义在string头文件中

   //cout<<line.c_str()<<endl;

   inFile.close();   //将文件重新捆绑则需要必须先关闭文件

         ofstreamoutFile(filename.c_str(),ofstream::app);

         if(!outFile)//检查文件是否打开

    {

       cerr<<"error: unable to open input file:"<<filename<<endl;

                   system("pause");

       return -1;

    }

         //stringaline("yangjd is a CPC.");

         stringaline;

         cout<<"appendoutput:";

         cin.tie(0);

         //cin>>aline;

         getline(cin,aline);//getline读入含空格的字符串

         //cout<<aline<<endl;

         outFile<<aline<<endl;

         outFile.close();//关闭文件流

   fstream inOutFile;

         inOutFile.open(filename.c_str(),fstream::in);

         if(!inOutFile)//检查文件是否打开

    {

       cerr<<"error: unable to open input file:"<<filename<<endl;

                   system("pause");

       return -1;

    }

         while(getline(inOutFile,line))//当文件结束时为空

         {

                   cout<<line<<endl;

         }

         inOutFile.close();

         system("pause");

   return 0;

}