精华内容
下载资源
问答
  • 2017-06-10 16:13:09

    文件读写是基础中的基础,关于此类知识的文章非常多,但还是想根据自己的使用心得去总结这么一些内容。

    1.文件的打开和关闭

    打开和关闭

    fopen()函数

    FILE *fopen(char *filename, *type);

    filename:可以包含 路径 和 文件名 两部分。如:“TEST.dat”、“C:\tc\TEST.dat”
    type:
    “r”打开文件只读。
    “w”创建文字文件只写。
    “a”增补,如果文件不存在则创建一个。
    “r+”打开一个文字文件读/写。
    “w+”创建一个文字文件读/写。
    “a+”打开或创建一个文件增补。
    “b”二进制文件(可以和以上每一项合并用)。
    “t”文本文件(默认项)。
    返回值:成功打开文件则返回文件指针;否则返回空指针(NULL)

    例:
    FILE *fp = fopen(strDEMFile.c_str(),_T("r"));//UNICODE以读方式打开文件
    【strDEMFile 是const string类型】
    另有:fopen_s()函数
    FILE*fp;
    fopen_s(&fp,strfileName.GetBuffer(),_T(“r”));//不能直接FILE *fp = fopen_s……
    【strfileName是CString类型,应该也可以是string类型,但不能用const修饰!】

    关闭

    fclose()函数

    int fclose(FILE *stream);//当文件关闭成功时,返回0,否则返回一个非0值;
    GetBuffer(); 本函数常见于文件的打开等数据操作,由于在很多情况下需要路径是const string类型,但路径变量又是非常量。用法见上

    文件的读写操作

    文件的顺序写

    fprintf()函数

    int fprintf (FILE *stream, const char *format,)
    FILE *stream:文件指针
    const char *format:输出格式
    < variable-list >(输出变量列表)
    返回值: 是输出的字符数,发生错误时返回EOF(值为-1)。
    例:
    fprintf (fp,"%d\n", i);//向文件写入一个整型 变量i

    fputs()-fputc函数

    int fputs ( const char * str, FILE * stream );//向文件写入一个字符串
    str:可以是字符型指针 或者 字符串常量
    FILE *stream:文件指针
    返回值:是输出的字符数,发生错误时返回EOF(值为-1)。
    例:
    fputs ("FuckWorld!\n", fp);

    int fputc ( int c, FILE *stream );//向文件写入一个字符
    c:可以是字符
    FILE *stream:文件指针
    返回值:是输出的字符数,发生错误时返回EOF(值为-1)。
    例:

    char strptr1[] = "This is a test of fputc!!\n";
    char *p;
    p = strptr1;
    while( (*p != '\0') && fputc(*(p++), fp) != EOF ) ;//这句话写的挺漂亮的

    fscanf()函数

    int fscanf ( FILE *stream, const char *format, );//顺序读取文件,遇空格和换行符结束
    FILE *stream:文件指针
    const char *format:输出格式
    (输出变量列表)
    返回值:成功,返回读入参数的个数;失败,返回EOF(值为-1)
    例:
    fscanf(fp, “%d”, &n);//加取地址符&
    fscanf(fp, “%s”, s);//注意:读入字符串时不要取地址符!【s 为char型,如:char s[10];】
    另有:fscanf_s()
    例:fscanf_s(fp, “%lf %lf”, &dX, &dY);//获取X,Y坐标【lf-double】

    fgets()函数

    char *fgets ( char *buf, intbufsize, FILE *stream );//按顺序读bufsize个字符串,遇到换行符结束
    *buf:字符型指针,指向用来存储所得数据的地址。
    bufsize: 整型数据,指明存储数据的大小。
    FILE *stream:文件指针
    返回值:成功,则返回第一个参数buf;在读字符时遇到end-of-file,则eof指示器被设置,如果还没读入任何字符就遇到这种情况,则buf保持原来的内容,返回NULL;如果发生读入错误,error指示器被设置,返回NULL,buf的值可能被改变。
    例:
    if( fgets( line, 100, stream ) == NULL)
    printf(“fgets error\n” );
    else
    printf( “%s”, line);//输出读取的字符串

    fgetc()函数

    int fgetc(FILE *stream);//按顺序读取文件,每次读取一个字符,读取后,光标位置后移一个字节。
    FILE *stream:文件指针
    返回值:成功,则返回所读取的一个字节;失败,(读到文件末尾或出错)则返回EOF

    二进制文件的读写(随机读写)

    常用读写方法:

    int fseek(FILE * stream, long offset, int fromwhere); //设置文件指针stream的位置
    int fread(void *buf, int size, int count, FILE *stream); //二进制读
    int fwrite(void *buf, int size, int count, FILE *stream); //二进制写
    long ftell(FILE *stream); //获取文件位置指针当前位置相对于文件首的偏移字节数

    Tips:
    fputs和fwrite函数在输入’\n’的时候,会最自动在前面添加一个’\r’,这样会导致最后输出的文本多一行空行,想要不自动加,则在fopen的时候就指定“b”参数(二进制文件)

    更多相关内容
  • C++文件操作函数详解

    千次阅读 2016-06-15 12:51:15
    转载:... C++通过以下几个类支持文件的输入输出 (1) ofstream:写操作,输出文件类; (2) ifstream:读操作,输入文件类; (3) fstream:可同时读写的文件类。 1. open函数:打开文件

    转载:http://blog.csdn.net/mafuli007/article/details/7271975

    C++通过以下几个类支持文件的输入输出

    (1)      ofstream:写操作,输出文件类;

    (2)      ifstream:读操作,输入文件类;

    (3)      fstream:可同时读写的文件类。

    1.     open函数:打开文件

    函数原型:void open(const char*filename,int mode,int access);      

    参数说明:filename:  要打开的文件名 
    mode:    要打开文件的方式 
    access:   打开文件的属性 

    打开文件的方式在类ios(是所有流式I/O类的基类)中定义,常用的值如下: 
    ios::app:   以追加的方式打开文件 
    ios::ate:   文件打开后定位到文件尾,ios:app就包含有此属性 
    ios::binary:  以二进制方式打开文件,缺省的方式是文本方式。两种方式的区别见前文 
    ios::in:    文件以输入方式打开 
    ios::out:   文件以输出方式打开 
    ios::nocreate: 不建立文件,所以文件不存在时打开失败  
    ios::noreplace:不覆盖文件,所以打开文件时如果文件存在失败 
    ios::trunc:  如果文件存在,把文件长度设为0 
      可以用“或”把以上属性连接起来,如ios::out|ios::binary 
    打开文件的属性取值是: 
    0:普通文件,打开访问 
    1:只读文件 
    2:隐含文件 
    4:系统文件 
    例如:以二进制输入方式打开文件c:\config.sys 
      fstreamfile1; 
      file1.open("c:\\config.sys",ios::binary|ios::in,0); 

    ofstream file;
    file.open ("example.bin", ios::out |ios::app | ios::binary);

    2.      close函数

    函数原型:void close()

    3. 二进制文件(Binary files)

    在二进制文件中,使用<< 和>>,以及函数(如getline)来操作符输入和输出数据,没有什么实际意义,虽然它们是符合语法的。

    文件流包括两个为顺序读写数据特殊设计的成员函数:write 和 read。第一个函数 (write) 是ostream 的一个成员函数,都是被ofstream所继承。而read 是istream 的一个成员函数,被ifstream 所继承。类 fstream 的对象同时拥有这两个函数。它们的原型是:

    write ( char *buffer, streamsize size );
    read ( char * buffer, streamsize size );

    这里 buffer 是一块内存的地址,用来存储或读出数据。参数size 是一个整数值,表示要从缓存(buffer)中读出或写入的字符数。

     
    1. // reading binary file  
    2.     #include <iostream>  
    3.     #include <fstream.h>  
    4.     const char * filename = "example.txt";  
    5.     int main () {  
    6.         char * buffer;  
    7.         long size;  
    8.         ifstream file (filename, ios::in|ios::binary|ios::ate);  
    9.         size = file.tellg();  
    10.         file.seekg (0, ios::beg);  
    11.         buffer = new char [size];  
    12.         file.read (buffer, size);  
    13.         file.close();  
    14.         cout << "the complete file is in a buffer";  
    15.         delete[] buffer;  
    16.         return 0;  
    17.     }  

    写文件举例:

     
    1. // writing on a text file  
    2. #include <fiostream.h>  
    3.   
    4. int main () {  
    5.     ofstream examplefile ("example.txt");  
    6.     if (examplefile.is_open()) {  
    7.         examplefile << "This is a line.\n";  
    8.         examplefile << "This is another line.\n";  
    9.         examplefile.close();  
    10.     }  
    11.     return 0;  
    12. }  

    读文件举例

       
     
    1. // reading a text file  
    2.    #include <iostream.h>  
    3.    #include <fstream.h>  
    4.    #include <stdlib.h>  
    5.      
    6.    int main () {  
    7.        char buffer[256];  
    8.        ifstream examplefile ("example.txt");  
    9.        if (! examplefile.is_open())  
    10.        { cout << "Error opening file"; exit (1); }  
    11.        while (! examplefile.eof() ) {  
    12.            examplefile.getline (buffer,100);  
    13.            cout << buffer << endl;  
    14.        }  
    15.        return 0;  
    16.    }  
      

    C++操作文件举例

     
    1. #include <fstream>  
    2. #include <iostream>  
    3. using namespace std;  
    4. int main()  
    5. {  
    6.         const int SZ=100;  
    7.         char buf[SZ];  
    8.         {  
    9.                ifstream in;  
    10.                in.open("example.cpp",ios::in);  
    11.                ofstream out;  
    12.                out.open("example.out");  
    13.                int j=1;  
    14.                while(in.get(buf,SZ))  
    15.                {  
    16.                        in.get();  
    17.                        cout<<buf<<endl;  
    18.                        out<<j++<<":"<<buf<<endl;  
    19.                }  
    20.         }  
    21.         ifstream in("example.out");  
    22.         while(in.getline(buf,SZ))  
    23.         {  
    24.                char *cp=buf;  
    25.                while(*cp!=':')  
    26.                {  
    27.                        ++cp;  
    28.                }  
    29.                cp+=2;  
    30.                cout<<cp<<endl;  
    31.         }  
    32.         system("pause");  
    33.         return 0;  
    34. }  

    C++中提供了移动文件指针的成员函数,从而对文件的进行随机地读写。类istream针对读指针提供3个成员函数:

      tellg()//返回输入文件读指针的当前位置;

      seekg(文件中的位置)//将输入文件中的读指针移动到指定位置

      seekg(位移量,参照位置)//以参照位置为基准移动若干字节

    其中参照位置是枚举值:

    ios::beg//从文件开头计算要移动的字节数

    ios::cur//从文件指针的当前位置计算要移动的字节数

    ios::end//从文件的末尾计算要移动的字节数

    如果参照位置省略,则默认为beg。而类ostream针对写指针提供的3个成员函数:

      tellp()//返回输出文件写指针的当前位置;

      seekp(文件中的位置)//将输出文件中的写指针移动到指定位置

      seekp(位移量,参照位置)//以参照位置为基准移动若干字节


    复制代码
     1 
    #include <iostream>
    #include <fstream>
    #include <cmath>
    using namespace std;
    int main()
    {
    	ifstream in;
    	in.open(url,ios::app| ios::binary);
    	if(!in.is_open())
    	{
    		cout<<"open file is failed";
    		return 1;
    	}
    
    	char* buffer = new char[100];
    	while(!in.eof())
    	{
    		
    		in.read(buffer,10);// 读完10个字节到buffer中,文件指针在第10个字节;
    		in.seekg(1,ios::cur);// 移动一个字节,从11个字节读取到buffer中;
    	}
    	in.close();
    	return 0;
    }
    展开全文
  • 作用:获得文件信息,也可以获取文件大小。 头文件: 参数说明: path 文件名 buf 传出参数,定义结构体 struct stat sb; &sb 返回值 失败:返回 -1,设置 errno 成功:返回 0 注意: stat 碰到链接,...

    一、概述

    在这里插入图片描述
    st_mode简单介绍
    在这里插入图片描述
    st_mode详细介绍
    在这里插入图片描述

    二、相关函数

    1. stat

    • 作用:获得文件信息,也可以获取文件大小。
    • 头文件:
      在这里插入图片描述
    • 参数说明:
      • path 文件名
      • buf 传出参数,定义结构体 struct stat sb; &sb
    • 返回值
      • 失败:返回 -1,设置 errno
      • 成功:返回 0

    注意: stat 碰到链接,会追溯到源文件,穿透!!!lstat 并不会穿透。

    stat结构体:
    在这里插入图片描述
    linux 命令 stat 执行结果:
    在这里插入图片描述
    注意三个时间的区别:

    time_t st_atime;/* time of last access */		文件被读,比如cat,open读等
    time_t st_mtime;/* time of last modification */ 文件内容发生改变
    time_t st_ctime;/* time of last status change */文件属性发生变化,比如大小,权限,硬连接数等
    

    需求:使用stat实现实现 ls -l 的功能?
    在这里插入图片描述
    在实现的过程中需要获取用户名及组名,因此先看两个函数:

    1)getpwuid

    • 作用:通过用户的uid获取用户名
    • 头文件
      在这里插入图片描述参数说明:
    • uid用户的uid

    返回值

    • 失败:返回NULL
    • 成功:返回 struct passwd * 结构体指针

    在这里插入图片描述

    2)getgrgid

    • 作用:通过用户的gid获取用户组名
    • 头文件
      在这里插入图片描述

    参数说明:

    • gid用户组的gid

    返回值

    • 失败:返回NULL
    • 成功:返回 struct group * 结构体指针

    在这里插入图片描述3)localtime

    • 作用:获取本地时间
    • 头文件
      在这里插入图片描述

    参数说明:

    • timep:一个时间相关的结构体

    返回值

    • 失败:返回NULL
    • 成功:返回 struct tm * 结构体指针

    在这里插入图片描述
    传入参数 timep 对应stat函数得到的结构体的秒数(time_t类型)。

    最终实现:
    在这里插入图片描述

    #include<stdio.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<string.h>
    #include<time.h>
    #include <grp.h>
    #include <pwd.h>
    
    int main(int argc, char *argv[])
    {
    	if (argc != 2)
    	{
    		printf("./a.out filename\n");
    		return -1;
    	}
    	struct stat sb;
    	stat(argv[1], &sb);
    	
    	char stmode[11] = {0};
    	memset(stmode, '-', sizeof(stmode)-1);
    
    	//解析文件属性
    	if (S_ISREG(sb.st_mode)) stmode[0] = '-'; //普通文件
    	if (S_ISDIR(sb.st_mode)) stmode[0] = 'd';
    	if (S_ISCHR(sb.st_mode)) stmode[0] = 'c';
    	if (S_ISBLK(sb.st_mode)) stmode[0] = 'b';
    	if (S_ISFIFO(sb.st_mode)) stmode[0] = 'p';
    	if (S_ISLNK(sb.st_mode))  stmode[0] = 'l';
    	if (S_ISSOCK(sb.st_mode)) stmode[0] = 's';
    
    	//解析权限
    	//user
    	if (sb.st_mode & S_IRUSR) stmode[1] = 'r';
    	if (sb.st_mode & S_IWUSR) stmode[2] = 'w';
    	if (sb.st_mode & S_IXUSR) stmode[3] = 'x';
    	//group
    	if (sb.st_mode & S_IRGRP) stmode[4] = 'r';
    	if (sb.st_mode & S_IWGRP) stmode[5] = 'w';
    	if (sb.st_mode & S_IXGRP) stmode[6] = 'x';
    	//other
    	if (sb.st_mode & S_IROTH) stmode[7] = 'r';
    	if (sb.st_mode & S_IWOTH) stmode[9] = 'w';
    	if (sb.st_mode & S_IXOTH) stmode[10] = 'x';
     
        //分析 用户名,组名可以通过函数获得 getpwuid, getgrgid
        //时间获取
    	struct tm *filetm = localtime(&sb.st_atim.tv_sec);
    	char timebuf[20] = {0};
    	sprintf(timebuf, "%d月    %d %02d:%02d", filetm->tm_mon+1, filetm->tm_mday, filetm->tm_hour, filetm->tm_min);
    
    	printf("%s %ld %s %s %ld %s %s\n", stmode, sb.st_nlink, getpwuid(sb.st_uid)->pw_name, 
        getgrgid(sb.st_gid)->gr_name, sb.st_size, timebuf, argv[1]);
    
    	return 0;
    }
    

    在这里插入图片描述

    2. access

    • 作用:测试指定文件是否有某种权限
    • 头文件
      在这里插入图片描述
      参数说明:
    • pathname文件名
    • mode:
      • R_OK
      • W_OK
      • X_OK
      • F_OK

    返回值

    • 失败:返回-1,设置errno
    • 成功:如果有权限或者文件存在,对应返回0
    #include<stdio.h>
    #include <unistd.h>
    
    int main(int argc, char *argv[])
    {
    	if (argc != 2)
    	{
    		printf("./a.out filename\n");
    		return -1;
    	}
    	if (access(argv[1], R_OK) == 0) printf("%s read ok!\n", argv[1]);
    	if (access(argv[1], W_OK) == 0) printf("%s write ok!\n", argv[1]);
    	if (access(argv[1], X_OK) == 0) printf("%s exe ok!\n", argv[1]);
    	if (access(argv[1], F_OK) == 0) printf("%s file exists!\n", argv[1]);
    	
    	return 0;
    }
    

    在这里插入图片描述

    3. chmod

    在这里插入图片描述

    4. truncate

    • 函数作用:截断文件
    • 头文件
      在这里插入图片描述

    参数说明:

    • path文件名
    • length长度,长度如果大于原文件,直接拓展,如果小于原文件,截断为length长度。

    返回值

    • 成功:返回0
    • 失败:返回-1,设置errno

    5. link

    • 函数作用:创建硬连接
    • 头文件
      在这里插入图片描述

    参数说明:

    • oldpath原文件
    • newpath硬连接文件

    返回值

    • 成功:返回0
    • 失败:返回-1,设置errno

    6. symlink

    • 函数作用:创建软连接
    • 头文件
      在这里插入图片描述

    参数解释:

    • oldpath原文件
    • newpath创建软连接文件

    返回值

    • 成功:返回0
    • 失败:返回-1,设置errno

    7. readlink

    • 函数作用:读取文件链接信息
    • 头文件
      在这里插入图片描述

    参数解释:

    • path链接名
    • buf缓冲区
    • bufsiz缓冲区大小

    返回值

    • 成功:返回buf填充的大小
    • 失败:返回-1,设置errno

    8. unlink

    • 函数作用:删除软硬链接
    • 头文件
      在这里插入图片描述

    函数参数:

    • pathname 链接名,文件也可以

    返回值

    • 成功:返回0
    • 失败:返回-1,设置errno

    在这里插入图片描述

    #include<stdio.h>
    #include <unistd.h>
    #include<stdlib.h>
    #include<fcntl.h>
    #include<string.h>
    #include<sys/types.h>
    
    int main(int argc, char *argv[])
    {
    	if (argc != 2)
    	{
    		printf("./a.out filename\n");
    		return -1;
    	}
    	int fd = open(argv[1], O_WRONLY|O_CREAT, 0666);
    	//注意只要有进程在使用该文件,则unlink在该文件退出时删除该文件
    	unlink(argv[1]);  
    	
    	int ret = write(fd, "hello", 5);
    	if (ret > 0)
    	{
    		printf("write ok! %d\n", ret);
    	}
    	if (ret < 0)
    	{
    		perror("write err");
    	}
    	close(fd);
    	return 0;
    }
    

    在这里插入图片描述
    在这里插入图片描述

    9. chown

    • 函数作用:修改文件属主及属组
    • 头文件
      在这里插入图片描述

    函数参数:

    • path文件名
    • owner用户ID,/etc/passwd
    • owner组ID,/etc/group

    返回值

    • 成功:返回0
    • 失败:返回-1,设置errno

    10. rename

    • 函数作用:文件或者目录重命名
    • 头文件
      在这里插入图片描述

    参数说明:

    • oldpath文件名
    • newpath文件新名

    返回值

    • 成功:返回0
    • 失败:返回-1,设置errno
    展开全文
  • c++文件操作大全

    万次阅读 多人点赞 2019-01-17 15:43:06
    c++文件操作大全 基于C的文件操作  在ANSI C中,对文件的操作分为两种方式,即流式文件操作和I/O文件操作,下面就分别介绍之。 一、流式文件操作 这种方式的文件操作有一个重要的结构FILE,FILE在stdio.h中定义...

    <--好消息!好消息!好消息!

    粉丝超过2000的公众号主快来接单吧,快来领取你的第一笔广告费。(粉丝数不够的小伙伴,请私信我一并解决)
    新用户注册红包1.8元,新用户注册并接单红包9.9元。
    绑定有赚并接单成功的小伙伴,来找我领大红包。
    具体操作指导可加我微信(lizaozhizao)私信我。(本人亲测,真实有效,非广告)
    点击下面链接直接注册(选流量主)。
    2021年,流量变现年,不要错过,只要有公众号,有视频号,有流量,就能变现。大家都在做自媒体变现,你为什么也不尝试一下呢?

    https://a.newrank.cn/link/tkfomO

    -->

    c++文件操作大全

    基于C的文件操作 
      在ANSI C中,对文件的操作分为两种方式,即流式文件操作和I/O文件操作,下面就分别介绍之。

    一、流式文件操作 
    这种方式的文件操作有一个重要的结构FILE,FILE在stdio.h中定义如下:

    复制代码

    typedef struct { 
      int level;           /* fill/empty level of buffer */ 
      unsigned flags;        /* File status flags */ 
      char fd;            /* File descriptor */ 
      unsigned char hold;      /* Ungetc char if no buffer */ 
      int bsize;           /* Buffer size */ 
      unsigned char _FAR *buffer; /* Data transfer buffer */ 
      unsigned char _FAR *curp;  /* Current active pointer */ 
      unsigned istemp;      /* Temporary file indicator */ 
      short token;          /* Used for validity checking */ 
    } FILE;              /* This is the FILE object */ 

    复制代码

      FILE这个结构包含了文件操作的基本属性,对文件的操作都要通过这个结构的指针来进行,此种文件操作常用的函数见下表 函数 功能 

      fopen() 打开流 
      fclose() 关闭流 
      fputc() 写一个字符到流中 
      fgetc() 从流中读一个字符 
      fseek() 在流中定位到指定的字符 
      fputs() 写字符串到流 
      fgets() 从流中读一行或指定个字符 
      fprintf() 按格式输出到流 
      fscanf() 从流中按格式读取 
      feof() 到达文件尾时返回真值 
      ferror() 发生错误时返回其值 
      rewind() 复位文件定位器到文件开始处 
      remove() 删除文件 
      fread() 从流中读指定个数的字符 
      fwrite() 向流中写指定个数的字符 
      tmpfile() 生成一个临时文件流 
      tmpnam() 生成一个唯一的文件名


    下面就介绍一下这些函数

    1.fopen() 
      fopen的原型是:FILE *fopen(const char *filename,const char *mode),fopen实现三个功能

      为使用而打开一个流 
      把一个文件和此流相连接 
      给此流返回一个FILR指针 
      参数filename指向要打开的文件名,mode表示打开状态的字符串,其取值如下表

      字符串 含义 
      "r" 以只读方式打开文件 
      "w" 以只写方式打开文件 
      "a" 以追加方式打开文件 
      "r+" 以读/写方式打开文件,如无文件出错 
      "w+" 以读/写方式打开文件,如无文件生成新文件

      一个文件可以以文本模式或二进制模式打开,这两种的区别是:在文本模式中回车被当成一个字符'/n',而二进制模式认为它是两个字符0x0D,0x0A;如果在文件中读到0x1B,文本模式会认为这是文件结束符,也就是二进制模型不会对文件进行处理,而文本方式会按一定的方式对数据作相应的转换。

      系统默认的是以文本模式打开,可以修改全部变量_fmode的值来修改这个设置,例如_fmode=O_TEXT;就设置默认打开方式为文本模式;而_fmode=O_BINARY;则设置默认打开方式是二进制模式。

      我们也可以在模式字符串中指定打开的模式,如"rb"表示以二进制模式打开只读文件,"w+t"或"wt+"表示以文本模式打开读/写文件。

      此函数返回一个FILE指针,所以申明一个FILE指针后不用初始化,而是用fopen()来返回一个指针并与一个特定的文件相连,如果成败,返回NULL。

      例:

      FILE *fp; 
      if(fp=fopen("123.456","wb")) 
      puts("打开文件成功"); 
      else 
      puts("打开文件成败");

    2.fclose() 
      fclose()的功能就是关闭用fopen()打开的文件,其原型是:int fclose(FILE *fp);如果成功,返回0,失败返回EOF。

      在程序结束时一定要记得关闭打开的文件,不然可能会造成数据丢失的情况,我以前就经常犯这样的毛病。

      例:fclose(fp);

    3.fputc() 
      向流写一个字符,原型是int fputc(int c, FILE *stream); 成功返回这个字符,失败返回EOF。

      例:fputc('X',fp);

    4.fgetc() 
      从流中读一个字符,原型是int fputc(FILE *stream); 成功返回这个字符,失败返回EOF。

      例:char ch1=fgetc(fp);

    5. fseek() 
      此函数一般用于二进制模式打开的文件中,功能是定位到流中指定的位置,原型是int fseek(FILE *stream, long offset, int whence);如果成功返回0,参数offset是移动的字符数,whence是移动的基准,取值是

      符号常量 值 基准位置 
      SEEK_SET 0 文件开头 
      SEEK_CUR 1 当前读写的位置 
      SEEK_END 2 文件尾部

      例:fseek(fp,1234L,SEEK_CUR);//把读写位置从当前位置向后移动1234字节(L后缀表示长整数)

      fseek(fp,0L,2);//把读写位置移动到文件尾

    6.fputs() 
      写一个字符串到流中,原型int fputs(const char *s, FILE *stream);

      例:fputs("I Love You",fp);

    7.fgets() 
      从流中读一行或指定个字符,原型是char *fgets(char *s, int n, FILE *stream); 从流中读取n-1个字符,除非读完一行,参数s是来接收字符串,如果成功则返回s的指针,否则返回NULL。

      例:如果一个文件的当前位置的文本如下

      Love ,I Have

      But ........

      如果用

      fgets(str1,4,file1);

      则执行后str1="Lov",读取了4-1=3个字符,而如果用

      fgets(str1,23,file1);

      则执行str="Love ,I Have",读取了一行(不包括行尾的'/n')。

    8.fprintf() 
      按格式输入到流,其原型是int fprintf(FILE *stream, const char *format[, argument, ...]);其用法和printf()相同,不过不是写到控制台,而是写到流罢了

      例:fprintf(fp,"%2d%s",4,"Hahaha");

    9.fscanf() 
      从流中按格式读取,其原型是int fscanf(FILE *stream, const char *format[, address, ...]);其用法和scanf()相同,不过不是从控制台读取,而是从流读取罢了。

      例:fscanf(fp,"%d%d" ,&x,&y);

    10.feof() 
      检测是否已到文件尾,是返回真,否则返回0,其原型是int feof(FILE *stream);

      例:if(feof(fp))printf("已到文件尾");

    11.ferror() 
      原型是int ferror(FILE *stream);返回流最近的错误代码,可用clearerr()来清除它,clearerr()的原型是void clearerr(FILE *stream);

      例:printf("%d",ferror(fp));

    12.rewind() 
      把当前的读写位置回到文件开始,原型是void rewind(FILE *stream);其实本函数相当于fseek(fp,0L,SEEK_SET);

      例:rewind(fp);

    13.remove() 
      删除文件,原型是int remove(const char *filename); 参数就是要删除的文件名,成功返回0。

      例:remove("c://io.sys");

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

      例:

      char x[4230]; 
      FILE *file1=fopen("c://msdos.sys","r"); 
      fread(x,200,12 ,file1);//共读取200*12=2400个字节

    15.fwrite() 
      与fread对应,向流中写指定的数据,原型是size_t fwrite(const void *ptr, size_t size, size_t n, FILE *stream);参数ptr是要写入的数据指针,void*的指针可用任何类型的指针来替换,如char*、int *等等来替换;size是每块的字节数;n是要写的块数,如果成功,返回实际写入的块数(不是字节数),本函数一般用于二进制模式打开的文件中。

      例:

      char x[]="I Love You"; 
      fwire(x, 6,12,fp);//写入6*12=72字节

      将把"I Love"写到流fp中12次,共72字节

    16.tmpfile() 
      其原型是FILE *tmpfile(void); 生成一个临时文件,以"w+b"的模式打开,并返回这个临时流的指针,如果失败返回NULL。在程序结束时,这个文件会被自动删除。

      例:FILE *fp=tmpfile();

    17.tmpnam(); 
      其原型为char *tmpnam(char *s); 生成一个唯一的文件名,其实tmpfile()就调用了此函数,参数s用来保存得到的文件名,并返回这个指针,如果失败,返回NULL。

     

    borland c++ bulder的文件操作总结2

    二、直接I/O文件操作 
      这是C提供的另一种文件操作,它是通过直接存/取文件来完成对文件的处理,而上篇所说流式文件操作是通过缓冲区来进行;流式文件操作是围绕一个FILE指针来进行,而此类文件操作是围绕一个文件的"句柄"来进行,什么是句柄呢?它是一个整数,是系统用来标识一个文件(在WINDOWS中,句柄的概念扩展到所有设备资源的标识)的唯一的记号。此类文件操作常用的函数如下表,这些函数及其所用的一些符号在io.h和fcntl.h中定义,在使用时要加入相应的头文件。

      函数 说明 
      open() 打开一个文件并返回它的句柄 
      close() 关闭一个句柄 
      lseek() 定位到文件的指定位置 
      read() 块读文件 
      write() 块写文件 
      eof() 测试文件是否结束 
      filelength() 取得文件长度 
      rename() 重命名文件 
      chsize() 改变文件长度

    下面就对这些函数一一说明:

    1.open() 
      打开一个文件并返回它的句柄,如果失败,将返回一个小于0的值,原型是int open(const char *path, int access [, unsigned mode]); 参数path是要打开的文件名,access是打开的模式,mode是可选项。表示文件的属性,主要用于UNIX系统中,在DOS/WINDOWS这个参数没有意义。其中文件的打开模式如下表。

      符号 含义 符号 含义 符号 含义 
      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 handle=open("c://msdos.sys",O_BINARY|O_CREAT|O_WRITE)

    2.close() 
      关闭一个句柄,原型是int close(int handle);如果成功返回0

      例:close(handle)

    3.lseek() 
      定位到指定的位置,原型是:long lseek(int handle, long offset, int fromwhere);参数offset是移动的量,fromwhere是移动的基准位置,取值和前面讲的fseek()一样,SEEK_SET:文件首部;SEEK_CUR:文件当前位置;SEEK_END:文件尾。此函数返回执行后文件新的存取位置。

      例:

      lseek(handle,-1234L,SEEK_CUR);//把存取位置从当前位置向前移动1234个字节。 
      x=lseek(hnd1,0L,SEEK_END);//把存取位置移动到文件尾,x=文件尾的位置即文件长度

    4.read() 
      从文件读取一块,原型是int read(int handle, void *buf, unsigned len);参数buf保存读出的数据,len是读取的字节。函数返回实际读出的字节。

      例:char x[200];read(hnd1,x,200);

    5.write() 
      写一块数据到文件中,原型是int write(int handle, void *buf, unsigned len);参数的含义同read(),返回实际写入的字节。

      例:char x[]="I Love You";write(handle,x,strlen(x));

    6.eof() 
      类似feof(),测试文件是否结束,是返回1,否则返回0;原型是:int eof(int handle);

      例:while(!eof(handle1)){……};

    7.filelength() 
      返回文件长度,原型是long filelength(int handle);相当于lseek(handle,0L,SEEK_END)

      例:long x=filelength(handle);

    8.rename() 
      重命名文件,原型是int rename(const char *oldname, const char *newname); 参数oldname是旧文件名,newname是新文件名。成功返回0

      例:rename("c://config.sys","c://config.w40");

    9.chsize(); 
      改变文件长度,原型是int chsize(int handle, long size);参数size表示文件新的长度,成功返回0,否则返回-1,如果指定的长度小于文件长度,则文件被截短;如果指定的长度大于文件长度,则在文件后面补'/0'。

      例:chsize(handle,0x12345);


    --------------------------------------------------------------------------------

      如果熟悉汇编可能会发现这种方式和汇编语言的DOS功能调用句柄式文件操作很像,比如open()就像DOS服务的3CH号功能调用,其实这种操作还有两种类型的函数就是直接用DOS功能来完成的,如_open(),_dos_open()等等。有兴趣可自已查询BCB的帮助。

      同流式文件操作相同,这种也提供了Unicode字符操作的函数,如_wopen()等等,用于9X/NT下的宽字符编程,有兴趣可自已查询BCB的帮助。

      另外,此种操作还有lock(),unlock(),locking()等用于多用户操作的函数,但在BCB中用得并不多,我就不介绍了,但如果要用C来写CGI,这些就必要的常识了,如果你有这方面的要求,那就得自已好好看帮助了。

      到这里,我就把基于C的文件操作介绍完了,下一篇将介绍基于C++的文件操作,敬请期待。

    在C++中,有一个stream这个类,所有的I/O都以这个"流"类为基础的,包括我们要认识的文件I/O,stream这个类有两个重要的运算符:

    1、插入器(<<) 
      向流输出数据。比如说系统有一个默认的标准输出流(cout),一般情况下就是指的显示器,所以,cout<<"Write Stdout"<<'/n';就表示把字符串"Write Stdout"和换行字符('/n')输出到标准输出流。

    2、析取器(>>) 
      从流中输入数据。比如说系统有一个默认的标准输入流(cin),一般情况下就是指的键盘,所以,cin>>x;就表示从标准输入流中读取一个指定类型(即变量x的类型)的数据。

    在C++中,对文件的操作是通过stream的子类fstream(file stream)来实现的,所以,要用这种方式操作文件,就必须加入头文件fstream.h。下面就把此类的文件操作过程一一道来。

    一、打开文件 
      在fstream类中,有一个成员函数open(),就是用来打开文件的,其原型是:

      void open(const char* filename,int mode,int access);

      参数:

      filename:  要打开的文件名 
      mode:    要打开文件的方式 
      access:   打开文件的属性 
      打开文件的方式在类ios(是所有流式I/O类的基类)中定义,常用的值如下:

      ios::app:   以追加的方式打开文件 
      ios::ate:   文件打开后定位到文件尾,ios:app就包含有此属性 
      ios::binary:  以二进制方式打开文件,缺省的方式是文本方式。两种方式的区别见前文 
      ios::in:    文件以输入方式打开 
      ios::out:   文件以输出方式打开 
      ios::nocreate: 不建立文件,所以文件不存在时打开失败  
      ios::noreplace:不覆盖文件,所以打开文件时如果文件存在失败 
      ios::trunc:  如果文件存在,把文件长度设为0 
      可以用"或"把以上属性连接起来,如ios::out|ios::binary

      打开文件的属性取值是:

      0:普通文件,打开访问 
      1:只读文件 
      2:隐含文件 
      4:系统文件 
      可以用"或"或者"+"把以上属性连接起来 ,如3或1|2就是以只读和隐含属性打开文件。

      例如:以二进制输入方式打开文件c:/config.sys

      fstream file1; 
      file1.open("c://config.sys",ios::binary|ios::in,0);

      如果open函数只有文件名一个参数,则是以读/写普通文件打开,即:

      file1.open("c://config.sys");<=>file1.open("c://config.sys",ios::in|ios::out,0);

      另外,fstream还有和open()一样的构造函数,对于上例,在定义的时侯就可以打开文件了:

      fstream file1("c://config.sys");

      特别提出的是,fstream有两个子类:ifstream(input file stream)和ofstream(outpu file stream),ifstream默认以输入方式打开文件,而ofstream默认以输出方式打开文件。

      ifstream file2("c://pdos.def");//以输入方式打开文件 
      ofstream file3("c://x.123");//以输出方式打开文件

      所以,在实际应用中,根据需要的不同,选择不同的类来定义:如果想以输入方式打开,就用ifstream来定义;如果想以输出方式打开,就用ofstream来定义;如果想以输入/输出方式来打开,就用fstream来定义。


    二、关闭文件 
      打开的文件使用完成后一定要关闭,fstream提供了成员函数close()来完成此操作,如:file1.close();就把file1相连的文件关闭。

    三、读写文件 
      读写文件分为文本文件和二进制文件的读取,对于文本文件的读取比较简单,用插入器和析取器就可以了;而对于二进制的读取就要复杂些,下要就详细的介绍这两种方式

      1、文本文件的读写 
      文本文件的读写很简单:用插入器(<<)向文件输出;用析取器(>>)从文件输入。假设file1是以输入方式打开,file2以输出打开。示例如下:

      file2<<"I Love You";//向文件写入字符串"I Love You" 
      int i; 
      file1>>i;//从文件输入一个整数值。

      这种方式还有一种简单的格式化能力,比如可以指定输出为16进制等等,具体的格式有以下一些

      操纵符 功能 输入/输出 
      dec 格式化为十进制数值数据 输入和输出 
      endl 输出一个换行符并刷新此流 输出 
      ends 输出一个空字符 输出 
      hex 格式化为十六进制数值数据 输入和输出 
      oct 格式化为八进制数值数据 输入和输出 
      setpxecision(int p) 设置浮点数的精度位数 输出

      比如要把123当作十六进制输出:file1<
      2、二进制文件的读写 
      ①put() 
      put()函数向流写入一个字符,其原型是ofstream &put(char ch),使用也比较简单,如file1.put('c');就是向流写一个字符'c'。

      ②get() 
      get()函数比较灵活,有3种常用的重载形式:

      一种就是和put()对应的形式:ifstream &get(char &ch);功能是从流中读取一个字符,结果保存在引用ch中,如果到文件尾,返回空字符。如file2.get(x);表示从文件中读取一个字符,并把读取的字符保存在x中。

      另一种重载形式的原型是: int get();这种形式是从流中返回一个字符,如果到达文件尾,返回EOF,如x=file2.get();和上例功能是一样的。

      还有一种形式的原型是:ifstream &get(char *buf,int num,char delim='/n');这种形式把字符读入由 buf 指向的数组,直到读入了 num 个字符或遇到了由 delim 指定的字符,如果没使用 delim 这个参数,将使用缺省值换行符'/n'。例如:

      file2.get(str1,127,'A');//从文件中读取字符到字符串str1,当遇到字符'A'或读取了127个字符时终止。

      ③读写数据块 
      要读写二进制数据块,使用成员函数read()和write()成员函数,它们原型如下:

      read(unsigned char *buf,int num); 
      write(const unsigned char *buf,int num);

      read()从文件中读取 num 个字符到 buf 指向的缓存中,如果在还未读入 num 个字符时就到了文件尾,可以用成员函数 int gcount();来取得实际读取的字符数;而 write() 从buf 指向的缓存写 num 个字符到文件中,值得注意的是缓存的类型是 unsigned char *,有时可能需要类型转换。

      例:

      unsigned char str1[]="I Love You"; 
      int n[5]; 
      ifstream in("xxx.xxx"); 
      ofstream out("yyy.yyy"); 
      out.write(str1,strlen(str1));//把字符串str1全部写到yyy.yyy中 
      in.read((unsigned char*)n,sizeof(n));//从xxx.xxx中读取指定个整数,注意类型转换 
      in.close();out.close();

    四、检测EOF 
      成员函数eof()用来检测是否到达文件尾,如果到达文件尾返回非0值,否则返回0。原型是int eof();

      例:  if(in.eof())ShowMessage("已经到达文件尾!");

    五、文件定位 
      和C的文件操作方式不同的是,C++ I/O系统管理两个与一个文件相联系的指针。一个是读指针,它说明输入操作在文件中的位置;另一个是写指针,它下次写操作的位置。每次执行输入或输出时,相应的指针自动变化。所以,C++的文件定位分为读位置和写位置的定位,对应的成员函数是 seekg()和 seekp(),seekg()是设置读位置,seekp是设置写位置。它们最通用的形式如下:

      istream &seekg(streamoff offset,seek_dir origin); 
      ostream &seekp(streamoff offset,seek_dir origin);

      streamoff定义于 iostream.h 中,定义有偏移量 offset 所能取得的最大值,seek_dir 表示移动的基准位置,是一个有以下值的枚举:

      ios::beg:  文件开头 
      ios::cur:  文件当前位置 
      ios::end:  文件结尾 
      这两个函数一般用于二进制文件,因为文本文件会因为系统对字符的解释而可能与预想的值不同。

      例:

      file1.seekg(1234,ios::cur);//把文件的读指针从当前位置向后移1234个字节 
      file2.seekp(1234,ios::beg);//把文件的写指针从文件开头向后移1234个字节

     

    ------------------------------------------------------------------------------------------------------------------------------------------

    在BCB中也提供了文件操作的函数,这些函数的功能和前面所介绍的大致相同,但这类函数和BCB关系紧密,能使用BCB中的AnsiString等数据类型,在BCB中用这种方式的文件操作是最方便的,下面我就把这种文件操作详细介绍。

    在BCB提供的这组文件操作函数中,可分为三种类型,就是:1、文件名函数,2、文件管理函数;3、文件I/O函数。

    1、文件名函数 
      文件名函数可以对文件的名称、所在子目录、驱动器和扩展名等进行操作。下表列出这些函数及其功能。

      函数 说明 
      ExpandFileName() 返回文件的全路径(含驱动器、路径) 
      ExtractFileExt() 从文件名中抽取扩展名 
      ExtractFileName() 从文件名中抽取不含路径的文件名 
      ExtractFilePath() 从文件名中抽取路径名 
      ExtractFileDir() 从文件名中抽取目录名 
      ExtractFileDrive() 从文件名中抽取驱动器名 
      ChangeFileExt() 改变文件的扩展名 
      ExpandUNCFileName() 返回含有网络驱动器的文件全路径 
      ExtractRelativePath() 从文件名中抽取相对路径信息 
      ExtractShortPathName() 把文件名转化为DOS的8·3格式 
      MatchesMask() 检查文件是否与指定的文件名格式匹配

      下面就把这些函数作一一介绍:

      ⑴ExpandFileName() 
      原型:extern PACKAGE AnsiString __fastcall ExpandFileName(const AnsiString FileName);

      功能:返回文件的全路径(含驱动器、路径)

      参数:FileName:要处理的文件名

      例:ShowMessage(ExpandFileName(Application->ExeName));//显示你的程序文件名,如C:/MyBCB/Sample1.EXE

      ⑵ExtractFileExt() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFileExt(const AnsiString FileName);

      功能:从文件名中抽取扩展名

      参数:FileName:要处理的文件名(全路径)

      例:ShowMessage(ExtractFileExt(Application->ExeName));//显示".exe"

      ⑶ExtractFileName() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFileName(const AnsiString FileName);

      功能:从文件名中抽取不含路径的文件名

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractFileExt("c://Winnt//SOL.EXE"));//显示"SOL.EXE"

      ⑷ExtractFilePath() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFilePath(const AnsiString FileName);

      功能:从文件名中抽取路径名

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractFilePath("Winnt//SOL.EXE"));//显示"Winnt/"

      ⑸ExtractFileDir() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFileDir(const AnsiString FileName);

      功能:从文件名中抽取目录名(和上个函数不同,不包括最后的"/")

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractFileDir("Winnt//SOL.EXE"));//显示"Winnt",注意和上个函数的区别

      ⑹ExtractFileDrive() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFileDrive(const AnsiString FileName);

      功能:从文件名中抽取驱动器名

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractFileDrive("c://Winnt//SOL.EXE"));//显示"c:"

      ⑺ChangeFileExt() 
      原型:extern PACKAGE System::AnsiString __fastcall ChangeFileExt(const System::AnsiString FileName, const System::AnsiString Extension);

      功能:更改文件名的扩展名,不是对真正的文件进行改名,只是对文件名这个字符串进行处理

      参数:FileName:要改名的文件名,Extension:新的扩展名

      例:ShowMessage(ChangeFileExt("c://Winnt//SOL.EXE",".OOO"));//显示"c:/winnt/SOL.OOO"

      ⑻ExpandUNCFileName() 
      原型:extern PACKAGE AnsiString __fastcall ExpandUNCFileName(const AnsiString FileName);

      功能:返回含有网络驱动器的文件全路径,格式为://机器名/共享名/文件名

      参数:FileName:要处理的文件名

      例:ShowMessage(ExpandUNCFileName("F://Winnt//SOL.EXE"));/*如果F:是映射的网络驱动器//NT40/WINNT,则显示"//NT40/WINNT/SOL.EXE"*/

      ⑼ExtractRelativePath() 
      原型:extern PACKAGE AnsiString __fastcall ExtractRelativePath(const AnsiString BaseName, const AnsiString DestName);

      功能:从文件名中抽取相对路径信息,如"../sss/ss.asd"这种形式

      参数:BaseName:基准文件名;DestName:目标文件名

      例:ShowMessage(ExtractRelativePath("D://Source//c//1.123","D://Source//Asm//dz.asm"));/*显示"../asm/dz.asm"*/

      (10) ExtractShortPathName() 
      原型:extern PACKAGE AnsiString __fastcall ExtractShortPathName(const AnsiString FileName);

      功能:把文件名转换为DOS的8、3格式

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractShortPathName("E://Program Files//Dual Wheel Mouse//4dmain.exe"));/*显示"E:/Progra~1/dualwh~1/4dmain.exe"*/

      ⑾MatchesMask() 
      原型:extern PACKAGE bool __fastcall MatchesMask(const AnsiString Filename, const AnsiString Mask);

      功能:检查文件是否与指定的文件名格式匹配

      参数:FileName:要处理的文件名;Mask:文件名格式,支持通配符

      例:ShowMessage(MatchesMask("Lxf.exe","*.?x?));//显示"true"

    2、文件管理函数 
      这类函数包括设置和读取驱动器、子目录和文件的有关的各种操作,下表列出这类操作常用的函数及其功能。

      函数 功能 
      CreateDir() 创建新的子目录 
      DeleteFile() 删除文件 
      DirectoryExists() 判断目录是否存在 
      DiskFree() 获取磁盘剩余空间 
      DiskSize() 获取磁盘容量 
      FileExists() 判断文件是否存在 
      FileGetAttr() 获取文件属性 
      FileGetDate() 获取文件日期 
      GetCurrentDir() 获取当前目录 
      RemoveDir() 删除目录 
      SetCurrentDir() 设置当前目录

      下面就把这些函数作一一介绍:

      ⑴CreateDir() 
      原型:extern PACKAGE bool __fastcall CreateDir(const System::AnsiString Dir);

      功能:建立子目录,如果成功返回true,否则返回false

      参数:Dir:要建立的子目录的名字

      例:Create("ASM");//在当前目录下建立一个名为ASM的子目录

      ⑵DeleteFile() 
      原型:extern PACKAGE bool __fastcall DeleteFile(const System::AnsiString FileName);

      功能:删除文件,如果成功返回true,否则返回false

      参数:FileName:要删除的文件名

      例:if(OpenDialog1->Execute())DeleteFile(OpenDialog1->FileName);

      ⑶DirectoryExists() 
      原型:extern PACKAGE bool __fastcall DirectoryExists(const System:: AnsiString Name);

      功能:检测目录是否存在,如果存在返回true,否则返回false

      参数:Name:要检测的目录名

      例:if(!DirectoryExists("ASM"))CreateDir("ASM");//如果ASM这个目录不存在则创建之

      ⑷DiskFree() 
      原型:extern PACKAGE __int64 __fastcall DiskFree(Byte Drive);

      功能:检测磁盘剩余空间,返回值以字节为单位,如果指定的磁盘无效,返回-1

      参数:Drive:磁盘的代号,0表示当前盘, 1=A,2=B,3=C 以此类推

      例:ShowMessage(DiskFree(0));//显示当前盘的剩余空间

      ⑸DiskSize() 
      原型:extern PACKAGE __int64 __fastcall DiskSize(Byte Drive);

      功能:检测磁盘容量,返回值以字节为单位,如果指定的磁盘无效,返回-1

      参数:Drive:磁盘的代号,0表示当前盘, 1=A,2=B,3=C 以此类推

      例:ShowMessage(DiskFree(0));//显示当前盘的容量

      ⑹FileExists() 
      原型:extern PACKAGE bool __fastcall FileExists(const AnsiString FileName);

      功能:检测文件是否存在,如果存在返回true,否则返回false

      参数:FileName:要检测的文件名

      例:if(FileExists("AAA.ASM"))DeleteFile("AAA.ASM");

      ⑺FileGetAttr() 
      原型:extern PACKAGE int __fastcall FileGetAttr(const AnsiString FileName);

      功能:取得文件属性,如果出错返回-1

      返回值如下表,如果返回$00000006表示是一个具有隐含和系统属性的文件(4+2)

      常量 值 含义 
      faReadOnly $00000001 只读文件 
      faHidden $00000002 隐含文件 
      faSysFile $00000004 系统文件 
      faVolumeID $00000008 卷标 
      faDirectory $00000010 目录 
      faArchive $00000020 归档文件

      例:if(FileGetAttr("LLL.TXT")&0x2)ShowMessage("这是一个有隐含属性的文件");

      与此对应的有FileSetAttr() ,请自已查阅帮助系统


      ⑻FileGetDate() 
      原型:extern PACKAGE int __fastcall FileGetDate(int Handle);

      功能:返回文件的建立时间到1970-1-1日0时的秒数

      参数:Handle:用FileOpen()打开的文件句柄。

      例:

      int i=FileOpen("C://autoexec.bat",fmOpenRead); 
      ShowMessage(FileGetDate(i)); 
      FileClose(i);

      与此对应的有FileSetDate(),请自已查阅帮助系统

      ⑼GetCurrentDir() 
      原型:extern PACKAGE AnsiString __fastcall GetCurrentDir();

      功能:取得当前的目录名

      例:ShowMessage(GetCurrentDir());

      ⑽RemoveDir() 
      原型:extern PACKAGE bool __fastcall RemoveDir(const AnsiString Dir);

      功能:删除目录,如果成功返回true,否则返回false

      参数:Dir:要删除的目录名

      例:if(DiectoryExists("ASM"))RemoveDir("ASM");

      ⑾SetCurrentDir() 
      原型:extern PACKAGE bool __fastcall SetCurrentDir(const AnsiString Dir);

      功能:设置当前目录,如果成功返回true,否则返回false

      参数:Dir:要切换到的目录名

      例:SetCurrentDir("C://WINDOWS");


    3、文件I/O函数 
      这类函数完成对文件的读写相关的操作,这种类型的操作和C的基于I/O文件操作类似,下表列出这类操作常用的函数及其功能。


      FileOpen() 打开文件 
      FileClose() 关闭文件 
      FileRead() 读文件 
      FileSeek() 文件定位 
      FileWrite() 写文件 
      FileCreate() 创建文件

      下面就对这些函数作详细介绍。

      ⑴FileOpen() 
      原型:extern PACKAGE int __fastcall FileOpen(const AnsiString FileName, int Mode);

      功能:打开文件,如果成功返回其句柄,否则返回-1

      参数:FileName:要打开的文件名;Mode:打开的方式,取值如下表,可用"或"("|")运算符连接。

      常量 值 说明 
      ------------------------------------------------------------- 
      fmOpenRead 0 以只读属性打开 
      fmOpenWrite 1 以只写属性打开 
      fmOpenReadWrite 2 以读/写属性打开 
      fmShareCompat 0 兼容FCB方式(汇编中有相应的DOS功能调用,感兴趣自已查阅相关资料) 
      fmShareExclusive 16 共享方式:以独占方式打开,在关闭以前,别人不能访问 
      fmShareDenyWrite 32 共享方式:拒绝写访问 
      fmShareDenyRead 48 共享方式:拒绝读访问 
      fmShareDenyNone 64 共享方式:无限制,允许读写 
      例:int i=FileOpen("C://WINDOWS//Win.ini",fmOpenReadWrite|fmShareExclusive);

      ⑵FileClose() 
      原型:extern PACKAGE void __fastcall FileClose(int Handle);

      功能:关闭打开的句柄。

      参数:Handle:要关闭的句柄

      例:FileClose(i);

      ⑶FileRead() 
      原型:extern PACKAGE int __fastcall FileRead(int Handle, void *Buffer, int Count);

      功能:读文件,返回实际读取的字节数,句柄必须首先由FileOpen或FileCreate创建。

      参数:Handle:要读取的句柄;Buffer:存放读取的数据的缓冲区;Count:想读取的字节数

      例:char str[400];FileRead(hnd1,str,400);

      ⑷FileSeek() 
      原型:extern PACKAGE int __fastcall FileSeek(int Handle, int Offset, int Origin);

      功能:移动文件读取指针,成功返回文件指针的位置,失败返回-1

      参数:Handle:相关联的句柄;Offset:移动的量;Orgin:移动的基准,0=文件头,1=当前位置,2=文件尾。

      例:ShowMessage(FileSeek(hnd1,0,2));//取得文件的长度

      ⑸FileWrite() 
      原型:extern PACKAGE int __fastcall FileWrite(int Handle, const void *Buffer, int Count);

      功能:写文件,返回实际写入的字节数,句柄必须首先由FileOpen或FileCreate创建。

      参数:Handle:要写入的句柄;Buffer:存放写入数据的缓冲区;Count:想写入的字节数

      例:char str[]="I Love You";FileWrite(hnd1,str,strlen(str));

      ⑹FileCreate() 
      原型:extern PACKAGE int __fastcall FileCreate(const AnsiString FileName);

      功能:创建文件。成功返回其句柄,否则返回-1

      参数:FileName:要创建的文件名

      例:if(!FileExists("KC.C"))hnd1=FileCreate("KC.C");


    更多技巧文章、优秀资源下载:

    最通俗的解读,最深刻的干货,最简洁的教程,众多你不知道的小技巧等你来发现!

    欢迎关注公众号:「智阅荟」,懂技术,更懂你!

    请自行搜索“智阅荟”,暂不显示二维码。

    说明:本站提供的所有软件已经过360、火绒安全检测,在使用中如有问题可在公众号留言!

    展开全文
  • C++ 文件读写相关函数

    千次阅读 2019-03-13 14:19:49
    几个C/C++语言文件读写函数 1、打开和关闭文件  (1)打开文件:FILE * fopen(const char *filename, const char *mode)  在使用打开文件函数时,我们要提供一个要打开的文件名,这里要提供一个当前用户有...
  • c++钩子函数:copy hook c++调用钩子函数监视复制文件操作
  • c++ 文件读取函数总结

    千次阅读 2017-09-17 01:01:48
    c++ 文件读取函数总结IO相关类继承关系 本文讲解文件读写,因此主要介绍相关类以及的fopen。
  • C++文件操作Read函数

    万次阅读 2018-08-21 15:06:56
    1. read 头文件: #include &lt;unistd.h&gt; 函数原型: ssize_t read(int filedes, void *buf, ... read 函数从 filedes 指定的已打开文件中读取 nbytes 字节到 buf 中。以下几种情况会导致读取到的...
  • C++文件操作

    千次阅读 2022-03-18 13:23:12
    C++中对文件操作需要包含头文件 文件类型分为两种: 1、文本文件:文件以文本的ASCII码形式存储在计算机中; 2、二进制文件:文件以文本的二进制形式存储在计算机中,用户一般不能直接读懂它们 操作文件的三大类: ...
  • C++文件操作_(最全面浅而易懂的文件操作)】

    千次阅读 多人点赞 2022-02-25 22:58:26
    C++文件操作 程序运行时产生的数据都属于临时数据,程序一旦运行结束都会被释放 通过文件可以将数据持久化 C++中对文件操作需要包含头文件<fstream> 文件类型分为两种: 文本文件:文本文件的ASCII码形式存储...
  • C\C++ | FILE文件基本操作函数

    千次阅读 2020-06-18 18:43:07
    C\C++FILE文件操作函数 首先,我们先来了解一下打开文件时要用到的参数: 标志 含义 r,rb 以只读的方式打开文件 w,wb 以只写的方式打开文件,若不存在,则新建文件,否则文件被截断(覆盖) a,ab 以...
  • C++文件操作成员函数及其使用说明

    千次阅读 2015-04-11 21:19:21
    C++文件操作归纳总结: C++ 通过以下几个类支持文件的输入输出: ofstream: 写操作(输出)的文件类 (由ostream引申而来)  ifstream: 读操作(输入)的文件类(由istream引申而来)  fstream: 可同时...
  • 方法介绍 可以把多个需要调用的子函数声明在一个头文件中。具体是: 1.函数的定义写在源文件(A.cpp)里 2.把函数的声明写在头文件(B.h)里(不必与...这样就不必在主文件中引用这些头文件。 如果在头文件中声...
  • (转)c++文件操作详解

    万次阅读 多人点赞 2018-05-11 15:35:30
    C++文件操作详解 本文转自:https://blog.csdn.net/kingstar158/article/details/6859379 在看C++编程思想中,每个练习基本都是使用ofstream,ifstream,fstream,以前粗略知道其用法和含义,在看了几位...
  • C++ 输入输出函数

    千次阅读 2021-01-04 11:37:11
    C++使用一个预处理器,该程序在进行主编译之前对源文件进行处理,它处理以#开头的编译指令,不必执行任何特殊的操作来调用该预处理器,它会在编译程序时自动运行。 第一行是编译指令,它导致预处理器将iostream...
  • clearerr(清除文件流的错误旗标) ...函数说明 clearerr()清除参数stream指定的文件流所使用的错误旗标。 返回值   fclose(关闭文件) 相关函数 close,fflush,fopen,setbuf 表头文件 #include
  • C++文件基本操作

    千次阅读 多人点赞 2020-01-16 12:06:34
    一、文件分类: ...二、操作文件的三大类: 1、fstream:读写操作 2、ofstream:写操作 3、ifstream:读操作 三、常见文件打开方式: ios::in 为读文件而打开文件 ios::out 为写文件而打开文件 ios::ate 打开...
  • C/C++ 删除文件 remove函数(转载)

    千次阅读 2020-06-21 09:35:39
    函数原型:int remove(const char * filename); 返回结果:如果成功返回 0,失败返回“EOF”( -1)。 #include<iostream> #include<cstdio> using namespace std; int main() { char *savePath = "/...
  • C/C++ 删除文件 remove函数

    千次阅读 2019-08-08 13:35:09
    头文件:#include <stdio.h>... 函数原型:int remove(const char * filename);  返回结果:如果成功返回 0,失败返回“EOF”( -1)。 #include<iostream> #include<cstdio> usi...
  • C++回调函数详解

    千次阅读 2021-05-07 22:34:54
    1、什么是回调函数 2、为什么需要回调函数 3、什么函数可以作为回调函数
  • C++文件的读取操作

    千次阅读 2022-04-18 21:15:38
    C++文件的读取操作
  • C++ 字符串操作函数

    千次阅读 2017-02-23 17:28:58
    由于字符串使用广泛,C和C++提供了一些字符串函数,包括字符串连接函数strcat,字符串复制函数strcpy,字符串比较函数strcmp,字符串长度函数strlen,在C语言中被定义在string.h中定义。在C++中被定义在cstring和...
  • c++拷贝函数

    万次阅读 多人点赞 2019-06-14 15:58:50
    2019.6.14 c++拷贝构造函数详解 一、什么是拷贝构造函数 首先对于普通类型的对象来说,他们之间的复制是很简单的,例如: int a = 100; int b = a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在...
  • C++通过Read函数读取文件

    万次阅读 多人点赞 2018-01-04 22:24:11
    通过read函数文件中的数据按照一定的长度读取出来并且存放在新的数组中。 函数原型istream& read (char* s, streamsize n); //用来暂存内容的数组(必须是char*型),以及流的长度比如我们要读取txt文件中的内容 ...
  • 本篇文章主要讲解C++中的文件操作的相关简介。 一.C++文件简介 c++支持以下两种文件类型: 1.文本文件,又称ASCII字符文件,其每一个字节存放一个ASCII字符。 2.二进制文件,把内存中的数据原样存放到磁盘上。 一个...
  • c/c++文件操作

    千次阅读 2018-12-22 15:09:30
    简单方便用法: 读:freopen('a.txt','w',stdin); 写:freopen('b.txt','r', stdout)  文件是存储在某种长期储存设备...磁盘文件操作系统中的文件系统统一管理,也只有文件系统才能直接操作文件。所以编写C+...
  • 1.write() 函数的参数 第一个参数是char*类型的,所以我们在写入数据...3.read()参数和方法都类似于write(),这两个函数都是文件读写中方便对一串数据(而不是一个一个字符)进行读写,不同的场合应该用不同的方法,不一

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 419,783
精华内容 167,913
关键字:

c++文件操作函数

c++ 订阅