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

    万次阅读 多人点赞 2015-12-11 16:46:40
    C语言文件操作函数 函数介绍 文件打开与关闭操作 fopen():文件打开操作 头文件:stdio.h 函数定义:FILE *fopen(char *pname, char *mode) 函数说明:pname是文件名,mode是打开文件的方式 mode:"r" 打开一...

    C语言文件操作函数

    函数介绍

    文件打开与关闭操作

    fopen():文件打开操作

    头文件:stdio.h
    函数定义:FILE *fopen(char *pname, char *mode)
    函数说明:pname是文件名,mode是打开文件的方式
    mode:"r" 打开一个已经存在的文件文本,文件不存在则出错



    以“r+”的方式打开一个文件,会清空文件的原始内容,重新写入数据

    返回值:正常返回:FILE *一个指向文件在内存中的文件信息去的开头

    异常返回:NULL,表示打开操作不成功

    打开文件的作用是:
    (1)分配给打开文件一个FILE 类型的文件结构体变量,并将有关信息填入文件结构体变量;
    (2)开辟一个缓冲区;
    (3)调用操作系统提供的打开文件或建立新文件功能,打开或建立指定文件;
    FILE *:指出fopen是一个返回文件类型的指针函数;

     返回值
       正常返回:被打开文件的文件指针。
       异常返回:NULL,表示打开操作不成功。

     要说明的是:C语言将计算机的输入输出设备都看作是文件。例如,键盘文件、屏幕文件等。ANSI C标准规定,在执行程序时系统先自动打开键盘、屏幕、错误三个文件。这三个文件的文件指针分别是:标准输入stdin、标准输出stdout和标准出错 stderr。

     fclose():文件关闭

    函数定义int fclose(FILE *fp);

    函数说明:fp是一个以打开的文件的文件指针

    返回值:

    正常返回:0

    异常返回:EOF,表示文件在关闭时发生错误


    fgetc:读取一个字符

    函数定义:int fgetc(FILE *fp)

    函数说明:从fp中读取一个字符,作为返回值返回

    返回值:

    正常返回:返回读取字符的代码

    异常返回:返回EOF。例如:要从“写打开”的文件中读取一个字符时,会发生错误而返回一个EOF

    【例8.1】显示指定文件的内容。

    //程序名为:display.c
    //执行时可用:display filename1 形式的命令行运行。显示文件filename1中的内容。例如,执行命令行display display.c将在屏幕上显示display的原代码。
    
    //File display program.
    #include <stdio.h>
    void main(int argc,char *argv[]) //命令行参数
    {
        int ch;//定义文件类型指针
        FILE *fp;//判断命令行是否正确
        if(argc!=2)
        {
            printf("Error format,Usage: display filename1\n");
            return; //键入了错误的命令行,结束程序的执行
        }
        //按读方式打开由argv[1]指出的文件
        if((fp=fopen(argv[1],"r"))==NULL)
        {
            printf("The file <%s> can not be opened.\n",argv[1]);//打开操作不成功
            return;//结束程序的执行
        }
        //成功打开了argv[1]所指文件
        ch=fgetc(fp); //从fp所指文件的当前指针位置读取一个字符
        while(ch!=EOF) //判断刚读取的字符是否是文件结束符
        {
            putchar(ch); //若不是结束符,将它输出到屏幕上显示
            ch=fgetc(fp); //继续从fp所指文件中读取下一个字符
        } //完成将fp所指文件的内容输出到屏幕上显示
        fclose(fp); //关闭fp所指文件
    }



    fputc:写一个字符到文件中

    函数定义:int fputc(int ch, FILE*fp)

    函数说明:ch是一个整型变量,要写到文件的字符

    fp:文件指针,要写入的文件

    返回值:

    正常返回:要写入的字符的代码

    异常返回:返回EOF

    【例8.2】将一个文件的内容复制到另一个文件中去。

    //程序名为:copyfile.c
    //执行时可用:copyfile filename1 filename2形式的命令行运行,将文件filename1中的内容复制到文件filename2中去。
    //file copy program.
    #include <stdio.h>
    void main(int argc,char *argv[]) //命令行参数
    {
        int ch;
        FILE *in,*out; //定义in和out两个文件类型指针
        if(argc!=3) //判断命令行是否正确
        {
            printf("Error in format,Usage: copyfile filename1 filename2\n");
            return; //命令行错,结束程序的执行
        }
        //按读方式打开由argv[1]指出的文件
        if((in=fopen(argv[1],"r"))==NULL)
        {
            printf("The file <%s> can not be opened.\n",argv[1]);
            return; //打开失败,结束程序的执行
        }
        //成功打开了argv[1]所指文件,再
        //按写方式打开由argv[2]指出的文件
        if((out=fopen(argv[2],"w"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[2]);
            return; //打开失败,结束程序的执行
        }
        //成功打开了argv[2]所指文件
        ch=fgetc(in); //从in所指文件的当前指针位置读取一个字符
        while(ch!=EOF) //判断刚读取的字符是否是文件结束符
        {
            fputc(ch,out); //若不是结束符,将它写入out所指文件
            ch=fgetc(in); //继续从in所指文件中读取下一个字符
        } //完成将in所指文件的内容写入(复制)到out所指文件中
        fclose(in); //关闭in所指文件
        fclose(out); //关闭out所指文件
    }


    【例8.3】按十进制和字符显示文件代码,若遇不可示字符就用井号"#"字符代替之。

    //程序名为:dumpf.c
    //执行时可用:dumpf filename1 形式的命令行运行。
    // File dump program.
    #include <stdio.h>
    void main(int argc,char *argv[])
    {
        char str[9];
        int ch,count,i;
        FILE *fp;
        if(argc!=2)
        {
            printf("Error format,Usage: dumpf filename\n");
            return;
        }
        if((fp=fopen(argv[1],"r"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[1]);
            return;
        }
        count=0;
        do{
            i=0;
            //按八进制输出第一列,作为一行八个字节的首地址
            printf("%06o: ",count*8);
            do{
                // 从打开的文件中读取一个字符
                ch=fgetc(fp);
                // 按十进制方式输出这个字符的ASCII码
                printf("%4d",ch);
                // 如果是不可示字符就用"#"字符代替
                if(ch<' '||ch>'~') str[i]='#';
                // 如果是可示字符,就将它存入数组str以便形成字符串
                else str[i]=ch;
                // 保证每一行输出八个字符
                if(++i==8) break;
            }while(ch!=EOF); // 遇到文件尾标志,结束读文件操作
            str[i]='\0'; // 在数组str加字符串结束标志
            for(;i<8;i++) printf(" "); // 一行不足八个字符用空格填充
            printf(" %s\n",str); // 输出字符串
            count++; // 准备输出下一行
        }while(ch!=EOF); // 直到文件结束
        fclose(fp); // 关闭fp所指文件
    }
    


    fgets():从文件中读取一个字符串

    函数定义:char *fgets(char *str, int n, FILE *fp)

    函数说明:由fp指出的文件中读取n-1个字符,并把他们存放到有str指出的字符数组中区,最后加上一个由字符串结束符'\0'

    参数说明:str:接受字符串的内存地址,可以是数组别名,也可以是指针

    n:指出要读取的字符的个数

    fp:这个是文件指针,指出要从中读取字符的文件

    返回值:

    正常返回:字符串的内存首地址,即str的值

    异常返回:返回一个NULL值,此时应当用feof()或ferror()函数来判别是读取到了文件尾,还是发生了错误。

    fputs():写入字符串到文件中去

    函数定义:把由str之处的字符串写入到fp所指的文件中去

    函数说明:

    str:之处要写入到文件中去的字符串,不包括最后的'\0'

    fp:这个是文件指针,之处字符串要写入到的文件指针

    返回值:

    正常返回:写入到的文件的字符个数,即字符串的长度

    非正常返回:返回一个NULL值,此时应当用feof()或ferror()函数来判别是读取到了文件尾,还是发生了错误。

    5.实例

    【例8.4】以下程序将一个文件的内容附加到另一个文件中去。

    //程序名:linkfile.c
    //执行时可用:linkfile filename1 filename2形式的命令行运行,将文件filename2的内容附加在文件filename1之后。
    // file linked program.
    #include <stdio.h>
    #define SIZE 512
    void main(int argc,char *argv[])
    {
        char buffer[SIZE];
        FILE *fp1,*fp2;
        if(argc!=3)
        {
            printf("Usage: linkfile filename1 filename2\n");
            return;
        }
        // 按追加方式打开argv[1] 所指文件
        if((fp1=fopen(argv[1],"a"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[1]);
            return;
        }
        if((fp2=fopen(argv[2],"r"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[2]);
            return;
        }
        // 读入一行立即写出,直到文件结束
        while(fgets(buffer,SIZE,fp1)!=NULL)
            printf("%s\n",buffer);
        while(fgets(buffer,SIZE,fp2)!=NULL)
            fputs(buffer,fp1);
        fclose(fp1);
        fclose(fp2);
        if((fp1=fopen(argv[1],"r"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[1]);
            return;
        }
        while(fgets(buffer,SIZE,fp1)!=NULL)
            printf("%s\n",buffer);
        fclose(fp1);
    }


    E. 往文件中写格式化数据

    1.函数原型

    int fprintf(FILE *fp,char *format,arg_list)

    2.功能说明
      将变量表列(arg_list)中的数据,按照format指出的格式,写入由fp指定的文件。fprintf()函数与printf()函数的功能相同,只是printf()函数是将数据写入屏幕文件(stdout)。
    3.参数说明
      fp:这是个文件指针,指出要将数据写入的文件。
      format:这是个指向字符串的字符指针,字符串中含有要写出数据的格式,所以该字符串成为格式串。格式串描述的规则与printf()函数中的格式串相同。
    arg_list:是要写入文件的变量表列,各变量之间用逗号分隔。
    4.返回值
      无。
    5. 实例

    【8.5】下列程序的执行文件为display.exe,执行时键入命令行:
       display [-i][-s] filename
    下面的表格列出了命令行参数的含义及其功能:

    //存储文件名:save.txt
    //程序代码如下:
    // file display program.
    #include <stdio.h>
    void main()
    {
        char name[10];
        int nAge,nClass;
        long number;
        FILE *fp;
        if((fp=fopen("student.txt","w"))==NULL)
        {
            printf("The file %s can not be opened.\n","student.txt");
            return;
        }
        fscanf(stdin,"%s %d %d %ld",name,&nClass,&nAge,&number);
        fprintf(fp,"%s %5d %4d %8ld",name,nClass,nAge,number);
        fclose(fp);
        if((fp=fopen("student.txt","r"))==NULL)
        {
            printf("The file %s can not be opened.\n","student.txt");
            return;
        }
        fscanf(fp,"%s %d %d %ld",name,&nClass,&nAge,&number);
        printf("name nClass nAge number\n");
        fprintf(stdout,"%-10s%-8d%-6d%-8ld\n",name,nClass,nAge,number);
        fclose(fp);
    }


    G. 以二进制形式读取文件中的数据

    1. 函数原型

    int fread(void *buffer,unsigned sife,unsigned count,FILE *fp)

    2. 功能说明
      从由fp指定的文件中,按二进制形式将sife*count个数据读到由buffer指出的数据区中。
    3. 参数说明
    buffer:这是一个void型指针,指出要将读入数据存放在其中的存储区首地址。
    sife:指出一个数据块的字节数,即一个数据块的大小尺寸。
    count:指出一次读入多少个数据块(sife)。
    fp:这是个文件指针,指出要从其中读出数据的文件。
    4.返回值
      正常返回:实际读取数据块的个数,即count。
      异常返回:如果文件中剩下的数据块个数少于参数中count指出的个数,或者发生了错误,返回0值。此时可以用feof()和ferror()来判定到底出现了什么
    情况。

    H. 以二进制形式写数据到文件中去

    1. 函数原型

    int fwrite(void *buffer,unsigned sife,unsigned count,FILE *fp)

    2. 功能说明
      按二进制形式,将由buffer指定的数据缓冲区内的sife*count个数据写入由fp指定的文件中去。
    3. 参数说明
    buffer:这是一个void型指针,指出要将其中数据输出到文件的缓冲区首地址。
    sife:指出一个数据块的字节数,即一个数据块的大小尺寸。
    count:一次输出多少个数据块(sife)。
    fp:这是个文件指针,指出要从其中读出数据的文件。
    4.返回值
      正常返回:实际输出数据块的个数,即count。
      异常返回:返回0值,表示输出结束或发生了错误。
    5.实例

    【例8.7】

    #include <stdio.h>
    #define SIZE 4
    struct worker
    { int number;
        char name[20];
        int age;
    };
    void main()
    {
        struct worker wk;
        int n;
        FILE *in,*out;
        if((in=fopen("file1.txt","rb"))==NULL)
        {
            printf("The file %s can not be opened.\n","file1.txt");
            return;
        }
        if((out=fopen("file2.txt","wb"))==NULL)
        {
            printf("The file %s can not be opened.\n","file2.txt");
            return;
        }
        while(fread(&wk,sizeof(struct worker),1,in)==1)
            fwrite(&wk,sizeof(struct worker),1,out);
        fclose(in);
        fclose(out);
    }


    I. 以二进制形式读取一个整数

    1. 函数原型

    int getw(FILE *fp)

    2. 功能说明
      从由fp指定的文件中,以二进制形式读取一个整数。
    3. 参数说明
      fp:是文件指针。
    4. 返回值
      正常返回:所读取整数的值。
      异常返回:返回EOF,即-1。由于读取的整数值有可能是-1,所以必须用feof()或ferror()来判断是到了文件结束,还是出现了一个出错。
    5. 实例

    【例8.8】

    #include <stdio.h>
    void main(int argc,char *argv[])
    {
        int i,sum=0;
        FILE *fp;
        if(argc!=2)
        {
            printf("Command error,Usage: readfile filename\n");
            exit(1);
        }
        if(!(fp=fopen(argv[1],"rb")))
        {
            printf("The file %s can not be opened.\n",argv[1]);
            exit(1);
        }
        for(i=1;i<=10;i++) sum+=getw(fp);
        printf("The sum is %d\n",sum);
        fclose(fp);
    }


    J. 以二进制形式存贮一个整数

    1.函数原型

    int putw(int n,FILE *fp)

    2. 功能说明
     以二进制形式把由变量n指出的整数值存放到由fp指定的文件中。
    3. 参数说明
     n:要存入文件的整数。
     fp:是文件指针。
    4. 返回值
     正常返回:所输出的整数值。
     异常返回:返回EOF,即-1。由于输出的整数值有可能是-1,所以必须用feof()或ferror()来判断是到了文件结束,还是出现了一个出错。
    5. 实例

    【例8.9】

    #include <stdio.h>
    void main(int argc,char *argv[])
    {
        int i;
        FILE *fp;
        if(argc!=2)
        {
            printf("Command error,Usage: writefile filename\n");
            return;
        }
    
        if(!(fp=fopen(argv[1],"wb")))
        {
            printf("The file %s can not be opened.\n",argv[1]);
            return;
        }
        for(i=1;i<=10;i++) printf("%d\n", putw(i,fp));
        fclose(fp);
    }


    * 文件状态检查

    A. 文件结束
    (1) 函数原型

    int feof(FILE *fp)

    (2) 功能说明
       该函数用来判断文件是否结束。
    (3) 参数说明
       fp:文件指针。
    (4) 返回值
       0:假值,表示文件未结束。
       1:真值,表示文件结束。
    (5) 实例

    【例8.10】

    #include <stdio.h>
    void main(int argc,char *argv[])
    {
        FILE *in,*out;
        char ch;
        if(argc!=3)
        {
            printf("Usage: copyfile filename1 filename2\n");
            return;
        }
        if((in=fopen(argv[1],"rb"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[1]);
            return;
        }
        if((out=fopen(argv[2],"wb"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[2]);
            return;
        }
        while(!feof(in))
        {
            ch=fgetc(in);
            if(ferror(in))
            {
                printf("read error!\n");
                clearerr(in);
            }
            else
            {
                fputc(ch,out);
                if(ferror(out))
                {
                    printf("write error!\n");
                    clearerr(out);
                }
            }
        }
        fclose(in);
        fclose(out);
    }


    B. 文件读/写出错
    (1) 函数原型

    int ferror(FILE *fp)

    (2) 功能说明
       检查由fp指定的文件在读写时是否出错。
    (3) 参数说明
       fp:文件指针。
    (4) 返回值
       0:假值,表示无错误。
       1:真值,表示出错。

    C. 清除文件错误标志

    (1) 函数原型

    void clearerr(FILE *fp)

    (2) 功能说明
       清除由fp指定文件的错误标志。
    (3) 参数说明
       fp:文件指针。
    (4) 返回值
       无。
    (5) 实例

    【例8.12】

    #include <stdio.h>
    void main(int argc,char *argv[])
    {
        FILE *in,*out;
        char ch;
        if(argc!=3)
        {
            printf("Usage: copyfile filename1 filename2\n");
            return;
        }
        if((in=fopen(argv[1],"rb"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[1]);
            return;
        }
        if((out=fopen(argv[2],"wb"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[2]);
            return;
        }
        while(!feof(in))
        {
            ch=fgetc(in);
            if(ferror(in))
            {
                printf("read error!\n");
                clearerr(in);
            }
            else
            {
                fputc(ch,out);
                if(ferror(out))
                {
                    printf("write error!\n");
                    clearerr(out);
                }
            }
        }
        fclose(in);
        fclose(out);
    }


    D. 了解文件指针的当前位置
    (1) 函数原型

    long ftell(FILE *fp)

    (2) 功能说明
       取得由fp指定文件的当前读/写位置,该位置值用相对于文件开头的位移量来表示。
    (3) 参数说明
       fp:文件指针。
    (4) 返回值
       正常返回:位移量(这是个长整数)。
       异常返回:-1,表示出错。
    (5) 实例

    * 文件定位

    A. 反绕
    (1) 函数原型

    void rewind(FILE *fp)

    (2) 功能说明
       使由文件指针fp指定的文件的位置指针重新指向文件的开头位置。
    (3) 参数说明
       fp:文件指针。
    (4) 返回值
       无。
    (5) 实例

    【例8.14】

    #include <stdio.h>
    void main()
    {
        FILE *in,*out;
        in=fopen("filename1","r");
        out=fopen("filename2","w");
        while(!feof(in)) fputc(fgetc(in),out);
        rewind(out);
        while(!feof(in)) putchar(fgetc(in));
        fclose(in);
        fclose(out);
    }

    B. 随机定位
    (1) 函数原型

    int fseek(FILE *fp,long offset,int base)

    (2) 功能说明
       使文件指针fp移到基于base的相对位置offset处。
    (3)参数说明
       fp:文件指针。
       offset:相对base的字节位移量。这是个长整数,用以支持大于64KB的文件。
       base:文件位置指针移动的基准位置,是计算文件位置指针位移的基点。ANSI C定义了base的可能取值,以及这些取值的符号常量。

    (4)返回值

      正常返回:当前指针位置。
      异常返回:-1,表示定位操作出错。

    (5)实例
    【例8.15】

    #include <stdio.h>
    #include <string.h>
    struct std_type
    {
        int num;
        char name[20];
        int age;
        char class;
    }stud;
    int cstufile()
    {
        int i;
        FILE *fp;
        if((fp=fopen("stufile","wb"))==NULL)
        {
            printf("The file can't be opened for write.\n");
            return 0;
        }
        for(i=1;i<=100;i++)
        {
            stud.num=i;
            strcpy(stud.name,"aaaa");
            stud.age=17;
            stud.class='8';
            fwrite(&stud,sizeof(struct std_type),1,fp);
        }
        fclose(fp);
        return 1;
    }
    void main()
    {
        int n;
        FILE *fp;
        if(cstufile()==0) return;
        if((fp=fopen("stufile","rb"))==NULL)
        {
            printf("The file can not be opened.\n");
            return;
        }
        for(n=0;n<100;n+=2)
        {
            fseek(fp,n*sizeof(struct std_type),SEEK_SET);
            fread(&stud,sizeof(struct std_type),1,fp);
            printf("%10d%20s%10d%4c\n",stud.num,stud.name,stud.age,stud.class);
        }
        fclose(fp);
    }


    * 关于exit()函数
    1. 函数原型

    void exit(int status)

    2. 功能说明
      exit()函数使程序立即终止执行,同时将缓冲区中剩余的数据输出并关闭所有已经打开的文件。
    3. 参数说明
      status:为0值表示程序正常终止,为非0值表示一个定义错误。
    4. 返回值
      无。

    * 关于feof()函数
    1. 函数原型

    int feof(FILE *fp)

    2. 功能说明
       在文本文件(ASCII文件)中可以用值为-1的符号常量EOF来作为文件的结束符。但是在二进制文件中-1往往可能是一个有意义的数据,因此不能用它 来作为文件的结束标志。为了能有效判别文件是否结束,ANSI C提供了标准函数feof(),用来识别文件是否结束。
    3. 参数说明
      fp:文件指针。
    4. 返回值
      返回为非0值:已到文件尾。
      返回为0值:表示还未到文件尾。

    展开全文
  • C语言文件读写(1)-文本文件读操作

    千次阅读 多人点赞 2020-06-30 12:40:09
    C语言文件读写-之文本文件读写

    C语言文件读写——文本文件读操作

     

    最近和几个初学C语言的朋友讨论文件读写,发现他们在使用C语言文件读写功能的时候遇到了不少问题,不是文件打开方式有问题,就是文件读写有问题,总是得不到自己想要的结果。

    C语言文件读写操作,既简单又复杂,要熟练使用每一项功能,也确实不易,既有文本文件操作,也有二进制文件的读写。本文先比较详细地介绍C语言的文本文件读操作,下一篇会详细介绍文本文件的写使用。

    什么是文本文件

    文本文件是由一行一行的字符的有序序列组成的。一行是由0个或者若干个字符加上一个行结束符'\n'(换行符)组成的,但是最后一行的最后一个字符是否是'\n'可能在不同的平台的实现不太一样,但是由于是最后一行的最后一个字符,所以并不会影响正常读写,但是我们在写文本文件的时候,最好也保证最有一个字符是行结束符'\n'。

    在Windows上,为了方便人阅读文本文档,在写入'\n'的时候,系统会自动将'\n'转换为'\r\n'(回车换行),在读取的时候会自动将'\r\n'转换为'\n'。在Linux上,并不会有这种转换,所以Windows上的文本文件在Linux上比较低的版本上进行读写的时候有时候需要进行一下转换,但是现在的Linux系统基本上已经能够正常处理'\r\n'了。

    为了能够保证文本文件的正常读写,要求:

    • 写入的字符是可打印字符,或者一些特殊的控制符,比如'\t'(TAB键),'\n'。
    • 不要在空格字符后紧跟'\n'字符,否则可能在读取的时候空格会丢失。
    • 最后一个字符是'\n'。

    读文本文件示例

    说了这么多,我们先直接来一个读取文本文件内容的例子,然后再做一下具体分析,这个文本文件的内容就是本文档的部分内容,我们把它读取出来,然后在控制台显示,我们以Windows系统为例,Linux下面的操作方式是类似的,读取文本文件的示例代码如下:

    #include <stdio.h>
    void read_text(const char* file_name)
    {
    	char line[1024]={0};
    	FILE *file = fopen(file_name,"rt");
    	if(!file)
    		return;
    	while(1)
    	{
    		//文件读取结束
    		if(EOF == fscanf(file,"%s",line))
    			break;
    		printf("%s\n",line);
    	}
    	fclose(file);
    
    }
    int main(int argc, char* argv[])
    {
    	read_text("test.txt");
    	return 0;
    }

    然后运行程序,看效果是否是我们期望的那样,一行一行地显示在控制台,如下图所示,上边是程序的输出,下边是test.txt文件的内容。

    读文本文件详解

    C语言中打开文件,主要有两个函数,fopen和fopen_s,fopen_s是C11标准中新引入的,它们的函数申明是这样的:

    		
    	(1) 	
    FILE *fopen( const char *filename, const char *mode );	(until C99)
    FILE *fopen( const char *restrict filename, const char *restrict mode );(since C99)
    
    	(2) 	
    errno_t fopen_s(FILE *restrict *restrict streamptr, 
                    const char *restrict filename,  
                    const char *restrict mode);(since C11)

    fopen_s会做一些额外的检查,更“安全”一些,C11标准后,有很多这样的_s的函数,都是为了更加安全,会做一些安全性的检查,比如函数传入的指针是否为空,传入的缓冲区是否会溢出等等。

    返回值FILE*就代表了一个文件流对象,如果为NULL,则表示打开文件失败。

    重点看一下mode,即打开文件的方式,常用的mode主要有:

    mode 含义 说明 如果文件存在 如果文件不存在
    “r” 以读的方式打开文件,打开以后只能读 成功打开,并从文件开始读 打开失败
    "w" 创建一个文件进行写 文件内容会被清空 创建一个新文件
    "a" 追加 追加内容到文件末尾 将文件内容追加到文件末尾 创建一个新文件
    "r+" 扩展读 打开文件进行读写,可读可写 从文件开始读 打开失败
    "w+" 扩展写 创建一个文件进行读写 文件内容会被清空 创建一个新文件
    "a+" 扩展追加 打开文件进行读写 追加内容到文件末尾 创建一个新文件

     

     

     

     

     

    11啊

     除了这些基本的打开模式之外,还可以附加一些别的模式,比如“t”,“b”等,例如“rb”,表示以二进制方式打开文件,"wt"以文本文件的方式创建文件,默认是文本文件方式,所以“t”一般可以省略。

    从上面的表格我们可以简单总结出来,只要是有“r”标志,文件就要求存在,否则就会打开失败,其他的打开模式都不需要文件一定存在,如果文件不存在,则会创建一个新文件。所以,在进行文件读写之前,一定要明确自己的目的,是读文件,还是写文件,是从文件开始写,还是追加内容到文件末尾。

    本节的主题是读文本文件,所以我们在使用fopen的时候,就使用"r"或者"rt"标志,不要使用别的模式。

    说到读文本文件内容,不是一件简单事情,因为读文本文件内容也涉及到好些函数,如果选择不当,得到的结果也会不是我们期望的。

    其实文本文件的内容虽然在前面介绍过,要作为文本文件是有要求的,比如前面提到的每行要求以'\n'结束等。但是文本文件内容本身又可以分为有格式的和没有格式的,比如我们前面的test.txt文件,就是没有格式的,就是纯文本文件,因为除了换行之外,没有任何别的格式,信息是杂乱的。如果我们查看一下一个普通的Excel文件,里面的数据就很有格式,一行一行,一列一列,非常整齐,这就是有格式的文本文件样子,我们看一个有格式的文本文件,这是一个简易的学生名单文件student.txt,每一行包含的内容为学号,姓名,所属学院,成绩,如下图所示。

    这个student.txt文件内容就是格式化的,即每一行的数据格式都是一致的,包含的信息都是类似的,即都包含学号,姓名,学院和分数,而且它们之间是用空格隔开的,这就是格式化的文件数据。

    在读取非格式化和格式化数据的时候,需要用到的函数是不一样的,否则,用非格式化数据读取函数去读取格式化的数据,读取到的内容我们也不好利用,同样,用格式化数据读取函数去读取非格式化的数据,有时候也得不到正确结果。

    非格式化文本文件读取

     

    非格式文本文件内容读取主要有两个函数,fgetc和fgets,fgetc的函数原型为:

    int fgetc( FILE *stream );

     

    每次从文件中读取一个字符,直到文件结尾。如果读到文件结尾,返回EOF。

    fgetc不会对文件中的内容做任何处理,一次就读一个字符,'\n'也会想普通字符一样读取,我们来看一下使用fgetc读取我们前面提到的text.txt文件的效果,代码如下:

    void read_text_by_getc(const char* file_name)
    {
    	int ch = 0;
    	FILE *file = fopen(file_name,"rt");
    	if(!file)
    		return;
    	while(EOF != (ch = fgetc(file)))
    	{
    		//在屏幕上输出读到的每一个字符
    		putchar(ch);
    	}
    	fclose(file);
    }

    则执行效果下图所示。

    fgetc对于读取非格式化的文本内容,就是最真实地反应了文本文件中的内容。

    但是fgetc读取容易,处理起来却很麻烦,如果只是在屏幕上显示文件内容的话,没有问题,如果还要想对读取的内容进行处理的话,就麻烦一些。

    我们再来看一下fgets函数。

    fgets的函数原型为:

    char *fgets( char *restrict str, int count, FILE *restrict stream );

     

    (since C99)

    每次从文件中读取指定长度的内容,读取的长度最多为count-1个字符。读到'\n'的时候,这一次读取就结束了,即使还没有读到count-1个字符。如果读取失败,返回NULL。

    我们先看一下使用fgets读取test.txt文本文件的效果,代码如下:

    void read_text_by_gets(const char* file_name)
    {
    	char buffer[20]={0};
    	FILE *file = fopen(file_name,"rt");
    	if(!file)
    		return;
    	while(NULL != (fgets(buffer,sizeof(buffer),file)))
    	{
    		//显示每一次读取到的内容
    		printf("%s",buffer);
    	}
    	fclose(file);
    }

    然后运行,结果如下所示。

    从图中可以看到,显示结果一塌糊涂,为什么呢?因为我们的缓冲区buffer大小是20,所以每次只读19个字符,有时候刚好得到半个汉字,就显示很凌乱了。

    因此,如果我们想完整的一次读取一行的数据,这个缓冲区buffer必须足够大,至少要超过文件中最长的一行字符的长度,我们修改一下程序,我们知道我们的test.txt文件中每行都不会太长,所以我们把buffer的大小设置成128,看看效果如何,如下图所示。

    因此,我们在对于非格式化文本进行读取的时候,要选择合适的函数来读取,如果想一行一行的读取文本文件中的内容,最好使用fgets,并且提供足够大的缓冲区。

    格式化文本文件读取

    格式化文本文件的读取主要用到函数fscanf和fscanf_s。

    先看一下fscanf函数的原型。

    int fscanf( FILE *restrict stream, const char *restrict format, ... );

    (since C99)

    fscanf和scanf一样,有一个格式化字符串format参数,因此在读取文本内容的时候会严格按照这个format格式去读,因此,对于我们的读取结构化的数据就非常方便,以我们的student.txt为例,我们再来看一下student.txt文件的内容。

    1001 张三 计算机学院 90.0
    1002 李四 计算机学院 98.7
    1003 王五 软件学院 88
    1004 黄渤海 人文学院 97

    每一行代表一个学生,包含学号,姓名,所属学院以及成绩。

    当使用fscanf读取的时候,同样,遇到'\n',一次读取就结束了,假设我们有四个变量ID,Name,College,Score,我们可以用scanf一次把一行的数据都读取到这四个变量中,我们看一下代码:

    void read_formated_text(const char* file_name)
    {
    	int ID;
    	char Name[32]={0};
    	char College[128]={0};
    	float Score = 0.0;
    	FILE *file = fopen(file_name,"rt");
    	if(!file)
    		return;
    	printf("学生名单为:\n");
    	while(1)
    	{
    		//文件读取结束
    		if(EOF == fscanf(file,"%d %s %s %f",&ID,Name,College,&Score))
    			break;
    		printf("学号:%d 姓名:%s 学院:%s 分数:%.2f\n",ID,Name,College,Score);		
    	}
    	fclose(file);
    }

     

     运行结果下图所示。

    如果我们有一个结构体Student的话,也可以通过这种方式把一行的数据直接读取到一个结构体中,代码如下:

    void read_formated_text_by_struct(const char* file_name)
    {
    	struct Student stu;
    	FILE *file = fopen(file_name,"rt");
    	if(!file)
    		return;
    	printf("学生名单为:\n");
    	while(1)
    	{
    		//文件读取结束
    		if(EOF == fscanf(file,"%d %s %s %f",&stu.ID,stu.Name,stu.College,&stu.Score))
    			break;
    		printf("学号:%d 姓名:%s 学院:%s 分数:%.2f\n",stu.ID,stu.Name,stu.College,stu.Score);		
    	}
    	fclose(file);
    }

     

    结果是一样的。

    现在简单介绍一下fscanf_s,其函数原型为:

    int fscanf_s(FILE *restrict stream, const char *restrict format, ...);

      (since C11)

    对于这个函数的使用,牢记住一点就好了,如果读取的是字符串类型,需要在字符串变量后面在跟一个字符串长度的值来指明字符串变量或者数组能够容纳多少个字符,比如我们前面的读取student.txt文件的代码就可以改为:

    void read_formated_text_by_struct(const char* file_name)
    {
    	struct Student stu;
    	FILE *file = fopen(file_name,"rt");
    	if(!file)
    		return;
    	printf("学生名单为:\n");
    	while(1)
    	{
    		//文件读取结束
    		if(EOF == fscanf_s(file,"%d %s %s %f",&stu.ID,stu.Name,sizeof(stu.Name)-1,stu.College,sizeof(stu.College)-1,&stu.Score))
    			break;
    		printf("学号:%d 姓名:%s 学院:%s 分数:%.2f\n",stu.ID,stu.Name,stu.College,stu.Score);		
    	}
    	fclose(file);
    }

    因为Name和College都是字符串类型,所以在它们后面都跟了一个长度。执行结果仍然一样。

    到了这里,大家以为文本文件的读取内容应该已经结束了,其实不是,如果你是C语言的初级选手或者刚学计算机不太久,后面的内容可以暂时跳过。

    窄字符与宽字符

    窄字符和宽字符都是指对字符的编码,窄字符就是一个字符占有的空间只有一个字节,宽字符通常一个字符占用两个字节的空间,我们也常常说宽字符为UNICODE编码字符。

    我们前面所讲的读取文件,这些函数其实都是针对窄字符的,因为这些文件内容的编码都是窄字符编码,一个英文是一个字符,一个汉字是两个字符,它们都是一个字符占用一个字节。

    如果是宽字符的话,一个字符占用两个字节,每一个英文字符还是一个字符,一个中文汉字通常也是一个字符,但是它们都占用两个字节。我们把test.txt文件另存一下,存为UNICODE编码,用记事本的另存功能,选择UNICODE,如图所示。

     

    如果我们此时还是用前面的代码来读取test_unicode.txt文件,效果会是什么样呢?我们以read_text_by_getc来验证一下,结果如图所示。

    可以再次用一塌糊涂来形容,什么也不是了。

    这就涉及到另外的读取函数了,是专门针对宽字符的,主要也有这几个函数,与窄字符对应的函数分别为:

    wint_t fgetwc( FILE *stream );

      (since C95)

    wchar_t *fgetws( wchar_t * restrict str, int count, FILE * restrict stream );

      (since C99)

    int fwscanf( FILE *restrict stream,
                 const wchar_t *restrict format, ... );

    (since C99)

    int fwscanf_s( FILE *restrict stream,
                   const wchar_t *restrict format, ...);

    (5) (since C11)

     它们的用法和窄字符的用法完全一样,唯一的不同是它们都要求被读取的文件的内容是UNICODE即宽字符编码的。

    这里不做试验了,有的朋友如果有兴趣的话,自己可以试一试,看看效果。

     

    其它

    如果要学习VC++调试相关技术,可以学习

    https://edu.csdn.net/course/detail/28915

    如果要学习Linux gdb C/C++调试相关技术,可以学习

    https://edu.csdn.net/course/detail/28981

     

     

    《完》

     

    展开全文
  • 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语言文件操作

    千次阅读 多人点赞 2017-09-09 00:34:10
    C语言文件操作一、文件的打开与关闭 使用 fopen 打开文件FILE *file; file = fopen("文件名","文件使用方式"); 文件的打开方式 文件使用方式 解释 r 只读。若文件不存在返回空指针 w 只写。若文件存在,则删除...

    C语言文件操作

    一、文件的打开与关闭

    1. 使用 fopen 打开文件

      FILE *file;
      file = fopen("文件名","文件使用方式");
    2. 文件的打开方式

      文件使用方式 解释
      r 只读。若文件不存在返回空指针
      w 只写。若文件存在,则删除其内容,否则创建一个新文件
      a 追加。若文件不存在,则创建一个新文件
      r+ 读写。指定的文件必须已存在,否则返回NULL
      w+ 读写。若指定的文件已存在,则其中的内容被删去
      a+ 读写。追加写

      如果在后面附加 ”b“ ,则表示打开的是二进制文件。

    3. 使用 fclose 关闭文件

      fclose(文件指针); 

    二、文件读写常用函数

    1. fgetc 函数
      从指定文件读入一个字符

      fgetc(文件指针);
    2. fread 函数

      从指定文件读入一组数据

      fread(buffer, size, count, file);

      buffer 存放读入数据的内存首地址

      size 每个数据项的字节数

      count 数据项个数

      file 文件类型的指针

    3. fscanf 函数

      从指定的文件中格式化读入数据。其一般形式为:

      fscanf(文件指针,格式控制,地址表);
    4. 读入例子

      
      #include<stdio.h>
      
      int main()
      {
         FILE *file;
         //1.dat 为 "Demo1"
         file = fopen("1.dat","r");
      
         char a;
         char b[3];
         int c;
      
         if(file != NULL){
             a = fgetc(file);
             fread(b,sizeof(char),3,file);
             fscanf(file,"%d",&c);
         }
      
         putchar(a);
         for(int i = 0; i < 3; i++){
             printf(" %c",b[i]);
         }
         printf(" %d",c);
      
         fclose(file);
         return 0;
      }
    5. fputc 函数

      将一个字符写到指定的文件中,若写成功返回以输出字符,否则返回 EOF

      fputc( int , FILE* );
    6. fwrite 函数

      将一组数据写到指定的文件中

      fwrite( buffer, size, count, file);

      buffer 输出数据的首地址

      size 每个数据项的字节数

      count 数据项个数

      file 文件类型的指针

    7. fprintf 函数

      格式化写数据到指定的文件中,形式为

      fprintf(文件指针,格式控制,输出表);
    8. 读写例子

      
      #include<stdio.h>
      
      int main()
      {
         FILE *file;
         //1.dat 为空
         file = fopen("1.dat","w+");
      
         char a0 = 'D';
         char b0[3] = {'e','m','o'};
         int c0 = 2;
         char a1;
         char b1[3];
         int c1;
      
         if(file != NULL){
             // 输出
             fputc(a0,file);
             fwrite(b0,sizeof(char),3,file);
             fprintf(file,"%d",c0);
             // 读写指针移动到文件开头
             rewind(file);
             // 读入
             a1 = fgetc(file);
             fread(b1,sizeof(char),3,file);
             fscanf(file,"%d",&c1);
         }
         // 打印结果
         putchar(a1);
         for(int i = 0; i < 3; i++){
             printf(" %c",b1[i]);
         }
         printf(" %d",c1);
      
         fclose(file);
         return 0;
      }
      

    三、文件的定位

    1. rewind 函数

      将文件的读写指针移动到文件的开头。

      rewind(文件指针);
    2. fseek 函数

      将文件的读写指针移动到文件的指定位置

      fseek(文件指针,偏移量,起始位置);

      偏移量的类型为长整型

      起始位置是指移动文件读写指针的参考位置,有以下三个值

      SEEK_SET 或 0 表示文件首

      SEEK_CUR 或 1 表示当前读写的位置

      SEEK_END 或 2 表示文件尾

    3. ftell 函数

      返回文件的当前读写位置,若出错返回(-1L)。其形式为

      ftell(文件指针);

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

    千次阅读 多人点赞 2018-12-21 09:26:46
    C语言文件处理功能,大体上分为两种:一种是设置缓冲区,另一种是不设置缓冲区。因为不设置缓冲区的方法直接对磁盘进行操作,速度较慢,并且由于不是C的标准函数,跨平台操作时容易出问题。本文只介绍设置缓冲区的...
  • C语言文件的定义,如何对文件进行操作,文件指针,如何定义指向文件的指针,通过文件指针对文件进行操作,文件应用举例,二进制文件相关操作,文件定位
  • C语言文件路径

    2019-11-14 17:05:40
    c语言文件路径 “\”一般是表示本地目录的,比如你电脑里面的C:\windows… “/”主要表示远程电脑或者网络上的,比如你这个贴子的地址: http://zhidao.baidu.com/question/36480033.html windows下文件路径是用...
  • C语言文件读写操作(详解)

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

    千次阅读 2020-04-16 00:51:17
    这里写目录标题C语言 文件读写操作文件打开模式文件操作函数fopen()——打开文件fclose()——关闭文件流fputs()——写入文件内容fgets()——获取文件内容打开文件实例读写文件实例 C语言 文件读写操作 最近在写c语言...
  • C语言文件管理

    千次阅读 2018-03-25 11:30:13
    C语言文件管理:1、 哪些可以放在头文件中,哪些不可以放在头文件中A) 函数声明可以放在头文件中,函数定义(函数体)不可以放在头文件中例如:Int Find();B) 全局变量声明(extern)可以放在头文件中,函数定义...
  • C语言 文件操作的头文件

    千次阅读 2020-01-06 09:31:27
    C语言 文件操作的头文件 计算机文件是以计算机硬盘为载体存储在计算机上的信息集合,是存储在某种长期储存设备上的一段数据流。在C语言中用一个指针变量指向一个文件,这个指针称为文件指针。通过文件指针...
  • C语言文件操作函数

    千次阅读 2014-09-09 11:19:12
    C语言文件操作函数
  • C语言文件结构

    千次阅读 2014-01-09 11:06:56
    C语言文件结构FILE的定义来自头文件stdio.h 以下为codeblock中内容。 typedef struct _iobuf { char* _ptr; //文件当前指针 int _cnt; char* _base; //指针基址 int _flag; //文件状态 int _file; int ...
  • C语言文件的打开与关闭

    千次阅读 多人点赞 2018-11-29 10:39:58
    C语言文件的打开与关闭 在C语言中,文件操作都是由库函数来完成的。 文件的打开(fopen函数) fopen() 函数用来打开一个文件,它的原型为: FILE *fopen(char *filename, char *mode); filename为文件名(包括...
  • C语言文件的随机读写

    千次阅读 2018-11-29 10:40:02
    C语言文件的随机读写 文件顺序读写,即读写文件只能从头开始,依次读写各个数据。但在实际开发中经常需要读写文件的中间部分,要解决这个问题,就得先移动文件内部的位置指针,再进行读写。这种读写方式称为随机...
  • 【C】C语言文件(包括:文件各种读写方式)

    万次阅读 多人点赞 2018-05-09 09:52:32
    文件概述 文件是指存储在外部存储器上的数据集合。更准确的来说,文件就是一组相关元素或数据的有序集合,而且每个集合都有一个符号化的指代,称这个符号化的指代为文件名。 文件类型 根据文件在外部存储器上的...
  • c语言文件分割与合并

    千次阅读 2017-05-20 23:05:00
    c语言文件分割与合并 一.综述 c语言操作文件通过文件指针FILE*,每个要操作的文件必须打开然后才能读写。 注意事项: @1分割与合并文件最好使用二进制模式即"rb"或"wb",这样可以操作任何类型文件 ...
  • C语言文件读写操作总结

    万次阅读 多人点赞 2012-07-25 18:53:23
    C语言文件读写操作总结 C语言文件操作 一、标准文件的读写 1.文件的打开 fopen() 文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区,并将该结构的指针返回给用户程序,以后用户程序就可用此...
  • C语言 文件IO的使用

    千次阅读 2018-01-22 17:10:57
    简单介绍C语言文件操作函数的用法(可以直接使用): fopen fclose fprintf fscanf fputc fgetc fread fwrite 头文件 #include 函数使用 fopen 函数原型: FILE *fopen( const char *...
  • C语言文件操作知识点总结

    千次阅读 2019-04-23 23:22:50
    C语言文件操作 1、文件:磁盘上的文件,一般我们谈的文件有两种:程序文件和数据文件 程序文件:源程序文件后缀为.c,目标文件后缀为.obj,可执行程序(windows环境下为.exe)。 数据文件:程序运行需要从中...
  • C语言文件读写-判断文件是否结束 在读文件的时候,很重要的一个条件是:文件是否结束,因为文件已经结束了,就不用继续读文件了。 判断文件结束,有许多方式,比如读取文本文件和二进制文件就可以使用不同的方式,...
  • http://c.biancheng.net/view/407.html
  • Visual Studio新建一个C语言文件 Microsoft Visual Studio简称VS。VS是一个基本完整的开发工具集,包含了许多与编程有关的工具。如果你打开它的新建项目模板,会看到有C#、C++等模板,却没有最基础的C语言模板,那要...
  • C语言可以对文件进行读写 仅仅使用文件的数据时分为以下几个步骤: 1.打开文件 2.读取文件 3.关闭文件 下面一个例子来说明文件操作的方法 打开文件的方法:定义指针,使用函数fopen("路径“,“r”)进行读取,打开...
  • 用VC++6.0简单创建C语言文件教程

    千次阅读 2019-10-15 21:11:56
    用VC++6.0简单创建C语言文件教程 先找到桌面上的图标双击打开 打开后点左上角文件,然后新建。 或者快捷键ctrl+N 如下: 按着下面的步骤进行 1:选择工程 2:选Win 32 Console Application,别选错! 3:为...
  • C语言文件读写操作,从文件读取数据
  • 许多同学在进行C语言文件操作的时候,需要对文件是否存在进行一个判断,经过昨天的了解,io库中的access函数可以起到文件判断的作用: C语言判断文件是否存在 用函数access,头文件是io.h,原型...
  • c语言 文件 字符串添加,或替换,或修改 有a.txt内容为 a=1 x!=22 b=333 d=4444 现在要将要a.txt的内容改为 a=100 b=2 c=3 d=4444 即是: 1.在1后面添加00 2.删除第二行 3.删除第三行的后两个3 4.添加一行c=3 ...
  • c语言文件读写三板斧

    2013-03-19 11:30:24
    关于语言的文件读写,说白了就三板斧:fread,fwrite,fseek。偶尔看到一篇博文写的很全面,在此不再赘述,贴上链接:c语言文件操作函数大全。看着这篇博文里面的例子,自己动手操作一遍,c语言文件操作也很简单。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,601
精华内容 25,440
关键字:

c语言文件

c语言 订阅