精华内容
下载资源
问答
  • C语言文件读写操作

    千次阅读 多人点赞 2020-10-25 15:58:33
    c语言文件读写操作 介绍了文件指针FILE的使用,文件读写操作的一般函数

    c语言文件读写操作

    一、文件指针File

    1.定义

    1. FILE类型是系统预先设定的一种结构体指针
    2. FILE* 指针作为文件句柄,是文件访问的唯一标识,它由fopen函数创建,fopen打开文件成功,则返回一个有效的FILE*指针,否则返回空指针NULL
    3. 定义方式
      FILE *fp=fopen(char *filename,char *mode);

      FILE *fp;
      fp=fopen(char *filename,char *mode);

      FILE * fopen(char* filename,char* mode)
      filename:文件名,如“students.txt”。 相对路径
      mode:打开方式(读写方式,文件类型)

    2.文件类型分类

    1. 文本文件:这类文件以文本的ASCII、UNICODE(万国码)等编码形式存储在计算机中。它是以"行"为基本结构的一种信息组织和存储方式。
    2. 二进制文件:这类文件以文本的二进制形式存储在计算机中,用户一般不能直接读懂它们,只有通过相应的软件才能将其显示出来。二进制文件一般是可执行程序、图形、图像、声音等等。

    3.文件打开方式

    1. "r"正文文件只读方式打开。文件不存在,则打开失败
    2. "w"正文文件只写方式打开。若文件不存在,则建立文件;若文件存在,则删除文件内容,重建空文件
    3. "a"正文文件添加方式。文件不存在,则建立文件
    4. "r+ ":正文文件读写打开,文件不存在,则打开失败
    5. "w+ " :正文文件读写方式打开,文件不存在,则建立文件

    4.文件打开

    #include <stdio.h>
    int main()
    {
        FILE *fp; /*文件指针*/
        fp=fopen("member.txt","rb");
        if(fp==NULL)
            printf("提示:文件未能成功打开");
        else
            printf("提示:文件已经打开");
        return 0;
    } 
    

    Warning!
    使用fopen时,但凡含r字母的打开方式,一定要加判断,文件是否打开成功,否则程序不会报告错误,会运行下去。如:

    FILE *fr; 
    fr=fopen("abc.txt","r"); 
    if(fr==NULL){
    printf("File not open!/n"); 
    

    5.文件关闭

    fclose(FILE *fp)
    一般地,fclose(fp)应与fopen配对使用,特别是含有写方式的文件,若不关闭,可能会造成文件数据丢失。

    二、一般读写函数

    字符的读写函数:fgetc()函数和fputc()函数
    字符串的读写函数:fgets()函数和fputs()函数
    数据块的读写函数,主要针对二进制文件:fread()函数和fwrite()函数
    格式化的读写函数,主要针对文本文件:fscanf()函数和fprintf()函数

    字符串读写

    1、fputs()函数

    格式:fputs(s,fp);
    功能:用来将一个字符串写入指定的文本文件。
    其中,fp为文件指针,s可以是字符数组名,字符型指针变量或字符串常量。该函数的功能是将字符串s写入由fp指向的文件中,字符串末尾的‘\0’字符不允写入。
    返回值:执行成功,返回所写的最后一个字符;否则,返回EOF。

    //fputs
    
    #include <stdio.h>
    #include <stdlib.h>
    void main(){
        FILE *fp;
        char s[][15]={"BeiJing","ShangHai","GuangZhou","NanJing","HangZhou"};
        if((fp=fopen("c:\\1\\wenjiu3.txt","w"))==NULL)
        /*只能相应文件,创建不了文件夹,fopen()函数会寻找相应位置文件夹然后在其中创建所需文件。
        当没有所需文件夹的时候,系统会自动跳转到NULL!*/
        {
            printf("Cannot open the file,strike any key to exit!\n");
            getchar();
            exit(0);
        }
        for(int i=0;i<6;i++){
            fputs(s[i],fp);
            fputs("\n",fp);
        }
        fclose(fp);
    }//输出在文件中的第六行,会出现“'jb”这个字符串
    

    2、fgets()函数

    格式:fgets(s,n,fp);

    功能:用于从指定的文件中读一个字符串到字符数组中。

    其中,s可以是字符型数组名或字符串指针,n是指定读入的字符个数;fp为文件指针。n是一个正整数,表示从文件中最多读取n-1个字符,并将字符串指针s定位在读入的字符串首地址。fgets()函数从文件中读取字符直到遇到回车符或EOF为止,函数会在最后一个字符后加上字符串结束标志’\0’;若有EOF,则不予保留。

    返回值:该函数如果执行成功,返回读取字符串;如果失败,则返回空指针NULL,这时,s中的内容不确定。

    //fgets()函数
    
    #include <stdio.h>
    #include <stdlib.h>
    void main(){
        FILE *fp;
        char s[6][15];
        if((fp=fopen("c:\\1\\wenjiu3.txt","r"))==NULL){
            printf("Cannot open the file,strike any key to exit!\n");
            getchar();
            exit(0);
        }
        for(int i=0;i<6;i++){
            fgets(s[i],15,fp);
            if(i%2==0)
                printf("%s",s[i]);
        }
        fclose(fp);
    }
    

    格式化读写

    1.fprintf()函数

    格式:fprintf(fp, format, arg1, arg2,….,argn);

    功能:fprintf()用来将输出项按指定的格式写入指定的文本文件中,其中格式化规定与printf()函数功能相似,所不同的只是fprintf()函数是将输出的内容写入文件中,而printf()函数则是在屏幕输出。

    其中,fp为文件指针,format为指定的格式控制字符串;arg1~argn为输出项,可以是字符、 字符串或各种类型的数值。该函数的功能是按格式控制字符串format给定的格式,将输出项arg1,arg2,……,argn的值写入fp所指向的文件中。

    返回值:如果函数执行成功,返回实际写入文件的字符个数;若出现错误,返回负数。

    fprintf()中格式控制的使用与printf()相同。
    例如:fprintf(fp,”r=%f,area=%f\n”,r,area);

    //fprintf()函数
    
    #include <stdio.h>
    #include <stdlib.h>
    void main(){
        FILE *fp;
        int data[1000];
        for(int i=0;i<1000;i++)
            data[i]=(rand()%1000);//产生0~999的随机整数
        if((fp=fopen("c:\\1\\wenjiu5.txt","w"))==NULL){
            printf("Cannot open the file,strike any key to exit!\n");
            getchar();
            exit(0);
        }
        for(i=0;i<1000;i++){
            if(i%20==0)
                fprintf(fp,"\n%5d",data[i]);
            else
                fprintf(fp,",%5d",data[i]);
            if((i+1)%20==0)
                fprintf(fp,"\n");
        }
        fclose(fp);
    
    }
    

    2、fscanf()函数

    格式:fscanf(fp,format,arg1,arg2,……,argn);

    功能:fscanf()用来按规定的格式从指定的文本文件中读取数据。它与scanf()函数的功能相似,都是按规定的格式读数据的函数,只是fscanf()函数读的对象不是键盘区,而是文件。

    其中,fp为文件指针,format为指定的格式控制字符串;arg1~argn为输入项的地址。该函数的功能是从文件指针fp所指的文本文件中读取数据,按格式控制字符串format给定的格式赋予输入项arg1,arg2,……,argn中。

    返回值:如果该函数执行成功,返回读取项目个数;如果遇到文件末尾,返回EOF;如果赋值失败,返回0.

    fscanf()中格式控制的使用与scanf()相同。
    例如:fprintf(fp,”%d,%d\n”,&a,&b);

    //fscanf()函数
    
    #include <stdio.h>
    #include <stdlib.h>
    void main(){
        FILE *fp;
        int data[1000];
        if((fp=fopen("c:\\1\\wenjiu5.txt","r+"))==NULL){
            printf("Cannot open the file,strike any key to exit!\n");
            getchar();
            exit(0);
        }
        for(int i=0;i<1000;i++){
            if(i%20==0)
                fscanf(fp,"\n%5d",&data[i]);
            else
                fscanf(fp,",%5d",&data[i]);
        }
        fseek(fp,0,SEEK_END);
        fprintf(fp,"\n\n");
        int j=0;
        for(i=0;i<1000;i++){
            {
                if(data[i]%7==0)
                {
                    if(j%20==0)
                        fprintf(fp,"%5d",data[i]);
                    if((j+1)%20==0) fprintf(fp,"\n");
                    j++;
                }
            }
            fclose(fp);
        }
    }
    

    结语

    第一次发表博客,还有点小激动,虽然不是原创,从网上几篇文章整理的,就是复习了一下c语言文字文件读写操作,也供自己以后回顾。

    展开全文
  • c语言文件读写操作

    万次阅读 多人点赞 2019-03-20 20:15:35
    当使用打开函数时,必须给出文件名、文件操作方式(读、写或读写),如果该文件名不存在,就意味着建立(只对写文件而言,对读文件则出错),并将文件指针指向文件开头。若已有一个同名文件存在,则删除该文件,若无同名...

    文件的打开函数fopen()

    文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区,并将该结构的指针返回给用户程序,以后用户程序就可用此FILE指针来实现对指定文件的存取操作了。当使用打开函数时,必须给出文件名、文件操作方式(读、写或读写),如果该文件名不存在,就意味着建立(只对写文件而言,对读文件则出错),并将文件指针指向文件开头。若已有一个同名文件存在,则删除该文件,若无同名文件,则建立该文件,并将文件指针指向文件开头。

    fopen(char *filename,char *type);

    其中filename是要打开文件的文件名指针,一般用双引号括起来的文件名表示,也可使用双反斜杠隔开的路径名。而type参数表示了对打开文件的操作方式。其可采用的操作方式如下: 方式 含义 “r” 打开,只读; “w” 打开,文件指针指到头,只写; “a” 打开,指向文件尾,在已存在文件中追加; “rb” 打开一个二进制文件,只读; “wb” 打开一个二进制文件,只写; “ab” 打开一个二进制文件,进行追加 ;“r+” 以读/写方式打开一个已存在的文件; “w+” 以读/写方式建立一个新的文本文件 ;“a+” 以读/写方式打开一个文件文件进行追加 ;“rb+” 以读/写方式打开一个二进制文件; “wb+” 以读/写方式建立一个新的二进制文件 ;“ab+” 以读/写方式打开一个二进制文件进行追加 ;当用fopen()成功的打开一个文件时,该函数将返回一个FILE指针,如果文件打开失败,将返回一个NULL指针。

    关闭文件函数fclose()

    文件操作完成后,必须要用fclose()函数进行关闭,这是因为对打开的文件进行写入时,若文件缓冲区的空间未被写入的内容填满,这些内容不会写到打开的文件中去而丢失。只有对打开的文件进行关闭操作时,停留在文件缓冲区的内容才能写到该文件中去,从而使文件完整。再者一旦关闭了文件,该文件对应的FILE结构将被释放,从而使关闭的文件得到保护,因为这时对该文件的存取操作将不会进行。文件的关闭也意味着释放了该文件的缓冲区。

    int fclose(FILE *stream);

    它表示该函数将关闭FILE指针对应的文件,并返回一个整数值。若成功地关闭了文件,则返回一个0值,否则返回一个非0值。

    int read(int handle, void *buf, int count);
    read()函数从handle(文件描述字)相连的文件中, 读取count个字节放到buf所指的缓冲区中, 返回值为实际所读字节数, 返回-1表示出错。返回0 表示文件结束。

    write()函数的调用格式为:
    int write(int handle, void *buf, int count);
    write()函数把count个字节从buf指向的缓冲区写入与handle相连的文件中, 返回值为实际写入的字节数。

    size_t fread( void *buffer, size_t size, size_t count, FILE *stream )
    buffer 是读取的数据存放的内存的指针(可以是数组,也可以是新开辟的空间,buffer就是一个索引)
    size 是每次读取的字节数
    count 是读取次数
    stream 是要读取的文件的指针

    size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );

    其中,ptr:指向保存数据的指针;size:每个数据类型的大小;count:数据的个数;stream:文件指针 ; 函数返回写入数据的个数。

    fseek
    函数名: fseek
    功 能: 重定位流上的文件指针
    用 法: int fseek(FILE *stream, long offset, int fromwhere);
    描 述: 函数设置文件指针stream的位置。如果执行成功,stream将指向以fromwhere为基准,偏移offset个字 节的位置。如果执行失败(比如offset超过文件自身大小),则不改变stream指向的位置。
    返回值: 成功,返回0,否则返回其他值。
    fromwhere有三个可选值:SEEK_SET 开始 SEEK_CUR现在指针所指的位置 SEEK_END末尾

    ftell
    用于得到二进制文件位置指针当前位置相对于文件首的偏移字节数。在随机方式存取文件时,由于文件位置频繁的前后移动,程序不容易确定文件的当前位置。
    long ftell(FILE *stream);

    int fprintf(FILE *stream,char *format,variable-list)
    int fscanf(FILE *stream,char *format,variable-list)
    fprintf()则是向流指针指向的文件输出;fscanf()是从文件输入

    简单的例子:先读取文件内容,再向文件写数据

    #include "pch.h"
    #include <iostream>
    #include<stdio.h>
    #include<stdlib.h>
    
    using namespace std;
    int main()
    {
    	const char *filename ="test.txt";
    	FILE *fp;
    	//以追加读写的方式打开文件
    	fopen_s(&fp,"test.txt","ab+");
    	if (!fp) {
    		printf("open file %s failed!", filename);
    	}
    	//统计文件大小
    	fseek(fp,0,SEEK_END);  
    	int len = ftell(fp);
    	//若使用fseek,ftell统计文件大小,那么在获得大小后要将指针移回原来的位置,因为fseek会改变指针的位置
    	fseek(fp,0,0);  
    	//保存从文件中读去的数据
    	char buf[10000] = {0};
    	//读取文件
    	fread(buf,len,1,fp);
    	//关闭
    	fclose(fp); 
    	//重新打开,不然会写入失败,不知道为什么
    	fopen_s(&fp, "test.txt", "ab+"); 
    	cout << buf << endl;
    	//保存写入文件的内容
    	char writebuf[1024];
    	char ch = 0;
    	int i = 0;
    	//读取输入字符,以换行符结束
    	while ((ch=getchar())!='\n') {
    		writebuf[i++] = ch;
    	}
    	writebuf[i++] = '\n';
    	writebuf[i++] = '\0';
    	//向文件末尾添加数据
    	int flen=fwrite(writebuf,i,1,fp);
    	//关闭数据
    	fclose(fp);
    	return 0;
    }
    
    
    
    展开全文
  • C语言文件读写操作(详解)

    万次阅读 多人点赞 2020-07-21 23:02:51
    进行C语言文件读写时,都会先进行“打开文件”操作,这个操作就是在打开数据流,而“关闭文件”操作就是关闭数据流。 缓冲区 在程序执行时,所提供的额外内存,可用来暂时存放准备执行的数据。它的设置是为了提高...

    数据流和缓冲区是什么?文件类型和文件存取方式都有啥?

    • 数据流
      就C程序而言,从程序移进,移出字节,这种字节流就叫做流。程序与数据的交互是以流的形式进行的。进行C语言文件的读写时,都会先进行“打开文件”操作,这个操作就是在打开数据流,而“关闭文件”操作就是关闭数据流。
    • 缓冲区
      在程序执行时,所提供的额外内存,可用来暂时存放准备执行的数据。它的设置是为了提高存取效率,因为内存的存取速度比磁盘驱动器快得多。
      当使用标准I/O函数(包含在头文件stdio.h中)时,系统会自动设置缓冲区,并通过数据流来读写文件。当进行文件读取时,是先打开数据流,将磁盘上的文件信息拷贝到缓冲区内,然后程序再从缓冲区中读取所需数据。事实上,当写入文件时,并不会马上写入磁盘中,而是先写入缓冲区,只有在缓冲区已满或“关闭文件”时,才会将数据写入磁盘。
    • 文件类型
      文本文件和二进制文件:
      文本文件是以字符编码的方式进行保存的。
      二进制文件将内存中的数据原封不动的进行保存,适用于非字符为主的数据。其实,所有的数据都可以算是二进制文件。二进制文件的优点在于存取速度快,占用空间小。
    • 文件存取方式
      顺序存取方式和随机存取方式:
      顺序存取就是从上往下,一笔一笔读取文件的内容。写入数据时,将数据附加在文件的末尾。这种存取方式常用于文本文件。
      随机存取方式多半以二进制文件为主。它会以一个完整的单位来进行数据的读取和写入,通常以结构为单位。

    什么是文件呢?

    文件是一段数据的集合,这些数据可以是有规则的,也可以是无序的集合。在stdio.h有一个非常重要的东西,文件指针,每个文件都会在内存中开辟一块空间,用于存放文件的相关信息,这些信息保存在一个结构体中:
    struct _iobuf {
    char *_ptr; //指向buffer中第一个未读的字节
    int _cnt; //记录剩余的未读字节的个数
    char *_base;//文件的缓冲
    int _flag;//打开文件的属性
    int _file;//获取文件描述
    int _charbuf;//单字节的缓冲,即缓冲大小仅为1个字节
    int _bufsiz;//记录这个缓冲大小
    char *_tmpfname;//临时文件名
    };
    typedef struct _iobuf FILE;
    FILE是一个数据结构,用于访问一个流。每个流都会对应一个FILE结构体。

    C语言文件操作函数详解

    C语言中没有输入输出语句,所有的输入输出功能都用 ANSI C提供的一组标准库函数来实现。文件操作标准库函数有:

    • 文件的打开
      fopen():打开文件
    • 文件的关闭
      fclose():关闭文件
    • 文件的读写
      fgetc():读取一个字符
      fputc():写入一个字符
      fgets():读取一个字符串
      fputs():写入一个字符串
      fprintf():写入格式化数据
      fscanf():格式化读取数据
      fread():读取数据
      fwrite():写入数据
    • 文件状态检查
      feof():文件是否结束
      ferror():文件读/写是否出错
      clearerr():清除文件错误标志
      ftell():文件指针的当前位置
    • 文件指针定位
      rewind():把文件指针移到开始处
      fseek():重定位文件指针

    参数解释:
    “r”:以只读的形式打开文本文件(不存在则出错)
    “w”:以只写的形式打开文本文件(若不存在则新建,反之,则从文件起始位置写,覆盖原内容)
    “a”:以追加的形式打开文本文件(若不存在,则新建;反之,在原文件后追加)
    “r+”:以读写的形式打开文本文件(读时,从头开始;写时,新数据只覆盖所占的空间)
    “wb”:以只写的形式打开二进制文件
    “rb”:以只读的形式打开二进制文件
    “ab”:以追加的形式打开一个二进制文件
    “rb+”:以读写的形式打开二进制文件。
    “w+”:首先建立一个新文件,进行写操作,然后从头开始读(若文件存在,原内容将全部消失)
    “a+”:功能与”a”相同。只是在文件尾部追加数据后,可以从头开始读
    “wb+”:功能与”w+”相同。只是在读写时,可以由位置函数设置读和写的起始位置
    “ab+”:功能与”a+”相同。只是在文件尾部追加数据之后,可以由位置函数设置开始读的起始位置

    打开文件
    FILE *fopen( const char *filename, const char *mode );

    • filename:文件的路径
    • mode:打开模式

    例:

    int main()
    {
        FILE* f;
        f = fopen("file.txt", "w");
        if (f != NULL)
        {
            fputs("fopen example", f);
            fclose(f);
            f=NULL;
        }
        return 0;
    }
    

    注意:

    • 文件是否打开成功
    • 关闭文件
    • 文件指针置空

    关闭文件
    函数原型:int fclose( FILE *stream );

    • stream:流

    例:

    if(fclose(f)!=0) 
    {
    	printf("File cannot be closed/n"); 
    	exit(1); 
    } 
    else
    {
        printf("File is now closed/n"); 
    }
    

    读取字符
    int fgetc ( FILE * stream );

    • stream:流

    例:

    #include <stdio.h>
    int main ()
    {
      FILE * pFile;
      int c;
      int n = 0;
      pFile = fopen ("D:\\myfile.txt", "r");
      if (pFile == NULL) perror ("Error opening file"); // 打开失败
      else
      {
        while (c != EOF)
        {
          c = fgetc (pFile); // 获取一个字符
          if (c == '$') n++; // 统计美元符号 '$' 在文件中出现的次数
        }
        fclose (pFile); // 一定记得要关闭文件
        printf ("The file contains %d dollar sign characters ($).\n",n);
      }
      return 0;
    }
    

    写入字符
    int fputc( int c, FILE *stream );

    • c:要写入的字符
    • stream:流

    例:

        char ch;
        FILE* pf = fopen("file.txt", "w");
        if (pf == NULL)
        {
            perror("error opening file");
            exit(0);
        }
        ch = getchar();
        while (ch != '$')
        {
            fputc(ch, pf);
            ch = getchar();
        }
        fclose(pf);
    

    读取字符串
    char * fgets ( char * str, int num, FILE * stream );

    • str:将读取到的内容复制到的目标字符串
    • num:一次读取的大小
    • stream:流

    例:

        char buf[10] = { 0 };
        FILE *pf = fopen("file.txt", "r");
        if (pf == NULL)
        {
            perror("open file for reading");
            exit(0);
        }
        fgets(buf, 9, stdin);
        printf("%s", buf);
        fclose(pf);
    

    写入字符串
    int fputs( const char *string, FILE *stream );

    • string:要写入的字符串
    • stream:一次读取的大小

    例:

        char buf[10] = { 0 };
        FILE *pf = fopen("file.txt", "r");
        if (pf == NULL)
        {
            perror("open file for reading");
            exit(0);
        }
        fgets(buf, 9, stdin);
        fputs(buf, stdout);
        fclose(pf);
    

    读取数据块
    size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );

    • ptr:目标内存块
    • size:一次读取的字节大小
    • count:一次读取多少个 size
    • stream:流

    例:

    #include <stdio.h>
    #include <string.h>
     
    int main()
    {
        FILE *pFile = fopen("file.txt", "rb");
        if (pFile == NULL) 
        {
            perror ("Error opening file");
            return 0;
        }
        char buf[100] = { 0 };
        while (!feof(pFile)) //没有到文件末尾
        {
            memset(buf, 0, sizeof(buf));
            size_t len = fread(buf, sizeof(char), sizeof(buf), pFile);
            printf("buf: %s, len: %d\n", buf, len);
        }
        fclose(pFile);
    }
    

    写入数据块
    size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
    同理,简单好理解,就不详细阐述了。

    文件指针重定位
    int fseek ( FILE * stream, long int offset, int origin );

    • stream:流
    • offset:相对应 origin 位置处的偏移量,单位为字节
    • origin:指针的位置
      #define SEEK_CUR 1 // 当前位置
      #define SEEK_END 2 // 末尾
      #define SEEK_SET 0 // 开头

    获取指针位置
    long int ftell ( FILE * stream );

    • stream:流

    获取文件大小
    例:

    long n;
    fseek(pf,0,SEEK_END);
    n=ftell(pf);
    

    文件指针移到开始处
    void rewind( FILE *stream );

    • stream:流

    清除文件错误标志
    void clearerr( FILE *stream );

    • stream:流

    文件流是否读到了文件尾
    int feof( FILE *stream );

    • stream:流

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

    • oldname:原名
    • newname:新名

    删除文件
    int remove ( const char * filename );

    • filename:文件的路径
    展开全文
  • 主要介绍了c语言文件读写示例(c语言文件操作),需要的朋友可以参考下
  • C语言文件读写操作总结

    千次阅读 2018-05-22 18:58:10
    转自:http://www.cnblogs.com/xiajun/archive/2010/08/14/2282881.htmlC语言文件操作一、标准文件读写1.文件的打开fopen() 文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区,并将该结构的指针返回...

    转自:http://www.cnblogs.com/xiajun/archive/2010/08/14/2282881.html

    C语言文件操作

    一、标准文件的读写

    1.文件的打开

    fopen() 文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区,并将该结构的指针返回给用户程序,以后用户程序就可用此FILE指针来实现对指定文件的存取操作了。当使用打开函数时,必须给出文件名、文件操作方式(读、写或读写),如果该文件名不存在,就意味着建立(只对写文件而言,对读文件则出错),并将文件指针指向文件开头。若已有一个同名文件存在,则删除该文件,若无同名文件,则建立该文件,并将文件指针指向文件开头。

    fopen(char *filename,char *type);

    其中*filename是要打开文件的文件名指针,一般用双引号括起来的文件名表示,也可使用双反斜杠隔开的路径名。而*type参数表示了对打开文件的操作方式。其可采用的操作方式如下: 方式 含义 "r" 打开,只读; "w" 打开,文件指针指到头,只写; "a" 打开,指向文件尾,在已存在文件中追加; "rb" 打开一个二进制文件,只读; "wb" 打开一个二进制文件,只写; "ab" 打开一个二进制文件,进行追加 ;"r+" 以读/写方式打开一个已存在的文件; "w+" 以读/写方式建立一个新的文本文件 ;"a+" 以读/写方式打开一个文件文件进行追加 ;"rb+" 以读/写方式打开一个二进制文件; "wb+" 以读/写方式建立一个新的二进制文件 ;"ab+" 以读/写方式打开一个二进制文件进行追加 ;当用fopen()成功的打开一个文件时,该函数将返回一个FILE指针,如果文件打开失败,将返回一个NULL指针。如想打开test文件,进行写:

    1. FILE *fp;  
    2. if((fp=fopen("test","w"))==NULL) {  
    3.     printf("File cannot be opened/n");  
    4.     exit();  
    5. }  
    6. else  
    7.     printf("File opened for writing/n");  
    8. ……  
    9. fclose(fp);   

    DOS操作系统对同时打开的文件数目是有限制的,缺省值为5,可以通过修改CONFIG.SYS文件改变这个设置。

    2.关闭文件函数fclose()

    文件操作完成后,必须要用fclose()函数进行关闭,这是因为对打开的文件进行写入时,若文件缓冲区的空间未被写入的内容填满,这些内容不会写到打开的文件中去而丢失。只有对打开的文件进行关闭操作时,停留在文件缓冲区的内容才能写到该文件中去,从而使文件完整。再者一旦关闭了文件,该文件对应的FILE结构将被释放,从而使关闭的文件得到保护,因为这时对该文件的存取操作将不会进行。文件的关闭也意味着释放了该文件的缓冲区。

    int fclose(FILE *stream); 

    它表示该函数将关闭FILE指针对应的文件,并返回一个整数值。若成功地关闭了文件,则返回一个0值,否则返回一个非0值。常用以下方法进行测试:

    1. if(fclose(fp)!=0) {  
    2.     printf("File cannot be closed/n");   
    3.     exit(1);   
    4. }   
    5. else  
    6.     printf("File is now closed/n");   

    当打开多个文件进行操作,而又要同时关闭时,可采用 fcloseall()函数,它将关闭所有在程序中打开的文件。 int fcloseall(); 该函数将关闭所有已打开的文件,将各文件缓冲区未装满的内容写到相应的文件中去,接着释放这些缓冲区,并返回关闭文件的数目。如关闭了4个文件,则当执行: n=fcloseall(); 时,n应为4。

    3.文件的读写

    (1).读写文件中字符的函数(一次只读写文件中的一个字符):

    int fgetc(FILE *stream);

    int getchar(void);

    int fputc(int ch,FILE *stream);

    int putchar(int ch);

    int getc(FILE *stream);

    int putc(int ch,FILE *stream);

    其中fgetc()函数将把由流指针指向的文件中的一个字符读出,例如: ch=fgetc(fp); 将把流指针fp指向的文件中的一个字符读出,并赋给ch,当执行fgetc()函数时,若当时文件指针指到文件尾,即遇到文件结束标志EOF(其对应值为-1),该函数返回一个-1给ch,在程序中常用检查该函数返回值是否为-1来判断是否已读到文件尾,从而决定是否继续。

    1. #include "stdio.h"   
    2. #include <stdlib.h>  
    3. int main() {   
    4.     FILE *fp;   
    5.     char ch;  
    6.     if((fp=fopen("myfile.txt","r"))==NULL) {  
    7.         printf("file cannot be opened/n");   
    8.         exit(1);   
    9.     }   
    10.     while((ch=fgetc(fp))!=EOF)   
    11.         fputc(ch,stdout);   
    12.     fclose(fp);   
    13. }   

    该程序以只读方式打开myfile.txt文件,在执行while循环时,文件指针每循环一次后移一个字符位置。用fgetc()函数将文件指针指定的字符读到ch变量中,然后用fputc()函数在屏幕上显示,当读到文件结束标志EOF时,关闭该文件。 上面的程序用到了fputc()函数,该函数将字符变量ch的值写到流指针指定的文件中去,由于流指针用的是标准输出(显示器)的FILE指针stdout,故读出的字符将在显示器上显示。又比如: fputc(ch,fp); 该函数执行结构,将把ch表示的字符送到流指针fp指向的文件中去。 在TC中,putc()等价于fputc(),getc()等价于fgetc()。 putchar(c)相当于fputc(c,stdout);getchar()相当于fgetc(stdin)。 注意,这里使用char ch,其实是不科学的,因为最后判断结束标志时,是看ch!=EOF,而EOF的值为-1,这显然和char是不能比较的。所以,某些使用,我们都定义成int ch。

    (2).读写文件中字符串的函数

    char *fgets(char *string,int n,FILE *stream);

    char *gets(char *s);

    int fprintf(FILE *stream,char *format,variable-list);

    int fputs(char *string,FILE *stream);

    int fscanf(FILE *stream,char *format,variable-list);

    其中fgets()函数将把由流指针指定的文件中n-1个字符,读到由指针string指向的字符数组中去,例如: fgets(buffer,9,fp); 将把fp指向的文件中的8个字符读到buffer内存区,buffer可以是定义的字符数组,也可以是动态分配的内存区。 注意,fgets()函数读到'/n'就停止,而不管是否达到数目要求。同时在读取字符串的最后加上'/0'。 fgets()函数执行完以后,返回一个指向该串的指针。如果读到文件尾或出错,则均返回一个空指针NULL,所以长用feof()函数来测定是否到了文件尾或者是ferror()函数来测试是否出错,例如下面的程序用fgets()函数读test.txt文件中的第一行并显示出来:

    1. #include "stdio.h"   
    2. int main() {  
    3.     FILE *fp;   
    4.     char str[128];   
    5.     if((fp=fopen("test.txt","r"))==NULL) {  
    6.         printf("cannot open file/n"); exit(1);  
    7.     }   
    8.     while(!feof(fp)) {  
    9.         if(fgets(str,128,fp)!=NULL)  
    10.         printf("%s",str);  
    11.     }  
    12.     fclose(fp);  
    13. }   

    gets()函数执行时,只要未遇到换行符或文件结束标志,将一直读下去。因此读到什么时候为止,需要用户进行控制,否则可能造成存储区的溢出。 fputs()函数想指定文件写入一个由string指向的字符串,'/0'不写入文件。 fprintf()和fscanf()同printf()和scanf()函数类似,不同之处就是printf()函数是想显示器输出,fprintf()则是向流指针指向的文件输出;fscanf()是从文件输入。 下面程序是向文件test.dat里输入一些字符:

    1. #include <stdio.h>  
    2. #include <stdlib.h>  
    3. int main() {  
    4.     char *s="That's good news";   
    5.     int i=617;   
    6.     FILE *fp;  
    7.     fp=fopen("test.dat""w"); /*建立一个文字文件只写*/   
    8.     fputs("Your score of TOEFL is",fp); /*向所建文件写入一串字符*/   
    9.     fputc(':', fp); /*向所建文件写冒号:*/   
    10.     fprintf(fp, "%d/n", i); /*向所建文件写一整型数*/   
    11.     fprintf(fp, "%s", s); /*向所建文件写一字符串*/   
    12.     fclose(fp);  
    13. }   

    用DOS的TYPE命令显示TEST.DAT的内容如下所示: 屏幕显示 Your score of TOEFL is: 617 That's good news 下面的程序是把上面的文件test.dat里的内容在屏幕上显示出来:

    1. #include <stdio.h>  
    2. int main() {  
    3.     char s[24], m[20];   
    4.     int i;  
    5.     FILE *fp;  
    6.     fp=fopen("test.dat""r"); /*打开文字文件只读*/  
    7.     fgets(s, 24, fp); /*从文件中读取23个字符*/  
    8.     printf("%s", s);   
    9.     fscanf(fp, "%d", &i); /*读取整型数*/  
    10.     printf("%d", i);   
    11.     putchar(fgetc(fp)); /*读取一个字符同时输出*/  
    12.     fgets(m, 17, fp); /*读取16个字符*/   
    13.     puts(m); /*输出所读字符串*/   
    14.     fclose(fp);   
    15. }   

    运行后屏幕显示: Your score of TOEFL is: 617 That's good news

    4.清除和设置文件缓冲区

    (1).清除文件缓冲区函数:

     int fflush(FILE *stream); 

    int flushall();

     fflush()函数将清除由stream指向的文件缓冲区里的内容,常用于写完一些数据后,立即用该函数清除缓冲区,以免误操作时,破坏原来的数据。 flushall()将清除所有打开文件所对应的文件缓冲区。

    (2).设置文件缓冲区函数

     void setbuf(FILE *stream,char *buf); 

    void setvbuf(FILE *stream,char *buf,int type,unsigned size); 

    这两个函数将使得打开文件后,用户可建立自己的文件缓冲区,而不使用fopen()函数打开文件设定的默认缓冲区。 对于setbuf()函数,buf指出的缓冲区长度由头文件stdio.h中定义的宏BUFSIZE的值决定,缺省值为512字节。当选定buf为空时,setbuf函数将使的文件I/O不带缓冲。而对setvbuf函数,则由malloc函数来分配缓冲区。参数size指明了缓冲区的长度(必须大于0),而参数type则表示了缓冲的类型,其值可以取如下值: type 值 含义 _IOFBF 文件全部缓冲,即缓冲区装满后,才能对文件读写 _IOLBF 文件行缓冲,即缓冲区接收到一个换行符时,才能对文件读写 _IONBF 文件不缓冲,此时忽略buf,size的值,直接读写文件,不再经过文件缓冲区缓冲。

    5.文件的随机读写函数

     前面介绍的文件的字符/字符串读写,均是进行文件的顺序读写,即总是从文件的开头开始进行读写。这显然不能满足我们的要求,C语言提供了移动文件指针和随机读写的函数,它们是:

    (1).移动文件指针函数:

     long ftell(FILE *stream);

     int rewind(FILE *stream);

     fseek(FILE *stream,long offset,int origin);

     函数ftell()用来得到文件指针离文件开头的偏移量。当返回值是-1时表示出错。 rewind()函数用于文件指针移到文件的开头,当移动成功时,返回0,否则返回一个非0值。 fseek()函数用于把文件指针以origin为起点移动offset个字节,其中origin指出的位置可有以下几种:

     origin 数值 代表的具体位置 

    SEEK_SET 0 文件开头

     SEEK_CUR 1 文件指针当前位置

     SEEK_END 2 文件尾 

    例如: fseek(fp,10L,0); 把文件指针从文件开头移到第10字节处,由于offset参数要求是长整型数,故其数后带L。

     fseek(fp,-15L,2); 把文件指针从文件尾向前移动15字节。

    (2).文件随机读写函数

     int fread(void *ptr,int size,int nitems,FILE *stream);

     int fwrite(void *ptr,int size,int nitems,FILE *stream);

     fread()函数从流指针指定的文件中读取nitems个数据项,每个数据项的长度为size个字节,读取的nitems数据项存入由ptr指针指向的内存缓冲区中,在执行fread()函数时,文件指针随着读取的字节数而向后移动,最后移动结束的位置等于实际读出的字节数。该函数执行结束后,将返回实际读出的数据项数,这个数据项数不一定等于设置的nitems,因为若文件中没有足够的数据项,或读中间出错,都会导致返回的数据项数少于设置的nitems。当返回数不等于nitems时,可以用feof()或ferror()函数进行检查。 fwrite()函数从ptr指向的缓冲区中取出长度为size字节的nitems个数据项,写入到流指针stream指向的文件中,执行该操作后,文件指针将向后移动,移动的字节数等于写入文件的字节数目。该函数操作完成后,也将返回写入的数据项数。

    二、非标准文件的读写

     这类函数最早用于UNIX操作系统,ANSI标准未定义,但有时也经常用到,DOS 3.0以上版本支持这些函数。它们的头文件为io.h。 由于我们不常用这些函数,所以在这里就简单说一下。

    1.文件的打开和关闭

     open()函数的作用是打开文件,其调用格式为: int open(char *filename, int access); 该函数表示按access的要求打开名为filename的文件,返回值为文件描述字,其中access有两部分内容: 基本模式和修饰符, 两者用" "("或")方式连接。修饰符可以有多个, 但基本模式只能有一个。 access的规定 -------------------------------------------------------- 基本模式 含义 修饰符 含 义 -------------------------------------------------------- O_RDONLY 只读 O_APPEND 文件指针指向末尾 O_WRONLY 只写 O_CREAT 文件不存在时创建文件, 属性按基本模式属性 O_RDWR 读写 O_TRUNC 若文件存在, 将其长度缩为0, 属性不变 O_BINARY 打开一个二进制文件 O_TEXT 打开一个文字文件 --------------------------------------------------------- open()函数打开成功, 返回值就是文件描述字的值(非负值), 否则返回-1。 close()函数的作用是关闭由open()函数打开的文件, 其调用格式为: int close(int handle); 该函数关闭文件描述字handle相连的文件。

    2.读写函数

     int read(int handle, void *buf, int count);

     read()函数从handle(文件描述字)相连的文件中, 读取count个字节放到buf所指的缓冲区中, 返回值为实际所读字节数, 返回-1表示出错。返回0 表示文件结束。 write()函数的调用格式为: int write(int handle, void *buf, int count); write()函数把count个字节从buf指向的缓冲区写入与handle相连的文件中, 返回值为实际写入的字节数。

    3.随机定位函数

     lseek()函数的调用格式为: int lseek(int handle, long offset, int fromwhere); 

    该函数对与handle相连的文件位置指针进行定位,功能和用法与fseek()函数相同。 tell()函数的调用格式为: long tell(int handle); 该函数返回与handle相连的文件现生位置指针, 功能和用法与ftell()相同

    5. read 函数和 write 函数

    来源:蚂蚁的 C/C++ 标准编程 作者:antigloss

    1. read 

    #include ssize_t read(int filedes, void *buf, size_t nbytes); 返回值:读取到的字节数;0(读到 EOF);-1(出错) read 函数从 filedes 指定的已打开文件中读取 nbytes 字节到 buf 中。以下几种情况会导致读取到的字节数小于 nbytes :

    A. 读取普通文件时,读到文件末尾还不够 nbytes 字节。例如:如果文件只有 30 字节,而我们想读取 100 字节,那么实际读到的只有 30 字节,read 函数返回 30 。此时再使用 read 函数作用于这个文件会导致 read 返回 0 。

    B. 从终端设备(terminal device)读取时,一般情况下每次只能读取一行。

    C. 从网络读取时,网络缓存可能导致读取的字节数小于 nbytes 字节。

    D. 读取 pipe 或者 FIFO 时,pipe 或 FIFO 里的字节数可能小于 nbytes 。

    E. 从面向记录(record-oriented)的设备读取时,某些面向记录的设备(如磁带)每次最多只能返回一个记录。 F. 在读取了部分数据时被信号中断。读操作始于 cfo 。在成功返回之前,cfo 增加,增量为实际读取到的字节数。

    2. write

     #include ssize_t write(int filedes, const void *buf, size_t nbytes); 返回值:写入文件的字节数(成功);-1(出错)write 函数向 filedes 中写入 nbytes 字节数据,数据来源为 buf 。返回值一般总是等于 nbytes,否则就是出错了。常见的出错原因是磁盘空间满了或者超过了文件大小限制。 对于普通文件,写操作始于 cfo 。如果打开文件时使用了 O_APPEND,则每次写操作都将数据写入文件末尾。成功写入后,cfo 增加,增量为实际写入的字节数。


    展开全文
  • C语言文件读写操作

    千次阅读 2020-06-18 00:38:29
    很基础的用open, close, read 和 write 写的C语言文件读写代码
  • C语言文件读写操作之换行符处理

    千次阅读 2020-08-04 00:11:52
    文件操作 t模式 与 b模式: windows下每个文件中正确的换行符号是:\r\n \r 0D \n 0A t模式(缺省):读取windows文件时将\r\n在读取过程中合并为\n t模式写入文件时会将\n的换行符,在写入时加入\r称为\r\n的换行符...
  • C语言文件读写操作详解

    千次阅读 2016-03-24 14:28:35
    下面按文件的性质分类进行操作。针对文本文件和二进制文件的不同性质,对文本文件来说,可按字符读写或按字符串读写;对二进制文件来说,可进行成块的读写或格式化的读写。 1. 读写字符  C提供fgetc和fputc函数对...
  • C语言文件读写操作中缓冲区问题和setbuf函数详解
  • 文件的基本概念 文件打开函数 读字符函数 写字符函数 读字符串函数 写字符串函数 数据块读写函数 格式化读写函数
  • C语言把磁盘文件看成是字符(或字节)的序列,按照存储信息的形式来说,文件主要是有文本文件和二进制文件。文本文件由一个个字符组成,每个字节存放一个ASCII码制,代表一个字符。二进制文件把内存中的数据按其在...
  • C语言读写文件操作

    万次阅读 2018-05-07 21:40:45
    文件读写是有两个文件来实现的,一个是写入数据,一个读出数据,根据代码进行解析吧。举一个最简单的例子:# include &lt;stdio.h&gt; # include &lt;stdlib.h&gt; int main(void) { int k, n, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,647
精华内容 23,858
关键字:

c语言文件读写操作

c语言 订阅