精华内容
下载资源
问答
  • c语言文本文件的读写
    万次阅读 多人点赞
    2020-07-21 23:02:51

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

    • 数据流
      就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语言_文件读写

    千次阅读 2022-03-11 14:33:56
    标准格式化文本读写 fscanf() 纯文本 ANSI 编码格式的文本内容如下: #include<stdio.h> int main(){ int ID; char Name[32]={0}; char College[128]={0}; float Score = 0.0; FILE *file = fopen("123...

    标准格式化文本读写 fscanf()

    纯文本 ANSI 编码格式的文本内容如下:
    在这里插入图片描述

    #include<stdio.h>
    
    int main(){
        int ID;
        char Name[32]={0};
        char College[128]={0};
        float Score = 0.0;
    
        FILE *file = fopen("123_ANSI.txt","r");
        if(!file){
            printf("Fail to open file....\n");
            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);
        return 0;
    }
    

    在这里插入图片描述
    如果 123.txt 文件编码格式为 unicode utf-8 ,需要自己编写编码转换,否则输出易出现乱码错误,因 fopen() 支持两种方式读写文件,一种是 二进制、另一种是 纯文本(ANSI)
    在这里插入图片描述

    fgets() 按行读文本

    2_1_input_data.txt ANSI编码,内容如下

    3,4,5
    S,.,.,.
    .,X,.,X
    .,.,.,D
    
    #include<stdio.h>
    #include<stdbool.h>
    #include<string.h>
    #include<math.h>
    
    #define N 9
    
    int main(){
        char map[N][N];
        char str[1000];
    
        int i=0,j; // 循环变量
        memset(map,0,sizeof(map));
    
        FILE *file = fopen("2_1_input_data.txt","r");
        if(!file){
            printf("Fail to open file....\n");
            return;
        }
        
        int array[10];
        int count = 0;
        char *p;
        while(fgets(str, sizeof(str),file) != NULL){
            count=count+1;
            //str[strlen(str)-1]='\0';        //将换行符\n 换成字符串结束符 \0
    
            if(count==1){
                printf("%s",str);
                p=strtok(str,",");
                j=0;
                while(p){
                    printf("%s\n",p);
                    array[j]=atoi(p);
                    p = strtok(NULL, ",");
                    j=j+1;
                }
                n=array[0];
                m=array[1];
                t=array[2];
            }
    
    
            if(count!=1){
    
                printf("%s",str);
                p=strtok(str,",");
                j=0;
                while(p){
                    printf("%s\n",p);
                    map[i][j]= *p;
                    j=j+1;
                    p = strtok(NULL, ",");
                }
                i=i+1;
            }
        }
        fclose(file);
    
        printf("...............\n");
        printf("n=%d\n",n);
        printf("m=%d\n",m);
        printf("t=%d\n",t);
        for(i=0;i<n;i++){
            for(j=0;j<m;j++){
                printf("%c ",map[i][j]);
            }
            printf("\n");
        }
        return 0;
    }
    
    

    在这里插入图片描述

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

    千次阅读 2022-03-23 16:30:28
    一 、文件读写的常用函数 (1) 读写文本文件: 读文本文件 :一般都使用 getc 、fgets 、fscanf 函数 使用getc读文件 #include <stdio.h> int main() { char a[20] = "a.txt"; FILE *p = fopen(a,"r"); ...

    文件的读写操作

    一 、文件读写的常用函数

    (1) 读写文本文件:

    读文本文件 :一般都使用 getc 、fgets 、fscanf 函数

    • 使用getc读文件

      #include <stdio.h>
      int main()
      {
          char a[20] = "a.txt";
          FILE *p = fopen(a,"r");
          if(p)
          {
              char c;
              while(1)
              {
                  c = getc(p);
                  if(c == EOF)
                      break;
                  printf("%c",c);
              }
              printf("\n");
              fclose(p);
          }
          else
          {
              printf("fail\n");
          }
          return 0;
      }
      
    • 使用fgets读文件

      #include <stdio.h>
      int main()
      {
          FILE *p = fopen("test.txt","r");
          if(p == NULL)
              return 0;
          char temp[1024];
          fgets(temp,sizeof(temp),p);
          while(!feof(p))
          {
              printf("%s",temp);
              fgets(temp,sizeof(temp),p);
          }
          fclose(p);
          return 0;
      }
      
    • 使用fscanf读文件

      #include <stdio.h>
      int main()
      {
          FILE *p = fopen("a.txt", "r");
          if(p == NULL)
          {
              printf("the file is close!");
              return 0;
          }
          char str1[200], str2[200], str3[200];
          int year;
          int status = fscanf(p, "%s %s %s %d", str1, str2, str3, &year); 
          while(!feof(p))
          {
              printf("%s %s %d %d status = %d\n", str1, str2, str3, year, status);
              status = fscanf(p, "%s %s %s %d", str1, str2, str3, &year);
          }
          fclose(p);
          return 0;
      }
      

    写文本文件 :一般都使用 putc 、 fputs、fprintf 函数

    • 使用putc写文件

      #include <stdio.h>
      int main()
      {
          FILE *p = fopen("a.txt","w");
          if(p)
          {
              putc('h',p);
              fclose(p);
          }
          return 0;
      }
      
    • 使用fputs写文件

      #include <stdio.h>
      int main()
      {
          FILE *p = fopen("abc.c","w");
          if(p)
          {
              fputs("#include <stdio.h>\nint main()\n{\nprintf(\"hello world\\n\");\nreturn 0;\n}",p);
              fclose(p);
          }
          return 0;
      }
      
    • 使用fprintf写文件

      #include <stdio.h>
      #include <string.h>
      int main()
      {
          FILE *p = fopen("a.txt","w");
          char buf[1024];
          fgets(buf, sizeof(buf), stdin);
          while(strcmp(buf,"exit\n") != 0)
          {
             fprintf(p, "%s", buf);
             fgets(buf, sizeof(buf), stdin); 
          }
          fclose(p);
          return 0;
      }
      

    (2) 读写二进制文件

    读二进制文件: 使用fread 函数

    • 代码:

      #include <stdio.h>
      void readFile()
      {
          FILE *p = fopen("a.txt", "rb");
          char buf[20] = { 0 };
          int index = 0;
          while(1)
          {
              int res = fread(buf, 1, 5, p);
              printf("res = %d , ", res);
              if(feof(p))
                  break;
              printf("buf = %s\n",buf);
              index++;
          }
          fclose(p);
          printf("%d\n", index);
      }
      int main()
      {
          readFile();
          return 0;
      }
      

    写二进制文件: 使用fwrite 函数

    • 代码

      #include <stdio.h>
      void writeFile()
      {
          FILE *p = fopen("b.txt", "w");
          char buf = 'a';
          int i;
          for(i = 0; i < 10 ; i++)
          {
              fwrite(&buf, 1, 1, p);
              buf++;
          }
          fclose(p);
      }
      int main()
      {
          writeFile();
          return 0;
      }
      

    二、文件读写的深层次的剖析

    (1)操作系统与硬件储存

    众所周知,我们的计算机操作系统都是由C语言写的,通过C语言协调物理内存与虚拟内存,操作系统想要向物理内存中写数据的时候,会费很大的力。

    写数据到物理内存

    当操作系统有一个字节的数据想要写入物理磁盘中,首先要经历一下几个步骤:

    1. 调用CPU的控制器,发出存储请求。
    2. 控制器把将要存储的数据放入临时寄存器。
    3. 查看总线是否被占用,请求总线控制。
    4. 往地址总线发送将要使用的一个字节的空间指定。
    5. 讲数据寄存器中数据发送到数据总线上,传输到先一步找到的物理地址。
    6. 存储完毕,释放总线。

    从磁盘中读数据

    读数据的操作与写数据的操作正好相反,也是要经历总线请求与总线释放的过程。

    总之,操作系统想要往磁盘中读写数据要经历很繁琐的过程。

    (2)操作系统封装读写数据函数接口

    每次操作系统与磁盘进行数据交互的时候,都会对CPU有一系列的操作指令,这些读写指令的合集就是读写函数,通过C语言实现这些读写函数再往外部抛出一系列的接口,就实现的读写数据的函数封装。

    当用户想往磁盘中写入数据的时候只需要调用这些函数接口就行了。

    然而这些函数都是针对最底层的数据存储操作,不利于计算机的操作性能提高,所以,有人就在这层函数的基础上再次进行封装,把性能更加好,更加优化的读写数据函数封装到C语言的标准库中。

    在标准库中的读写数据函数,例如fwrite和fputs等等。它们不是每次写入一个字节数据就往物理磁盘中写入数据,而是利用函数在内存中开辟出一个固定大小的字节缓冲池,通过这个缓冲池,来实现数据的读与写。

    (3)C语言中的数据缓冲池

    C语言的所有读写函数,都会使用到数据缓冲池,无论是读数据操作,还是写数据操作,都会把数据临时存储到这里。

    写数据

    当我们使用C语言往文件中写入一个字节的数据的时候,会经历一下几个步骤:

    1. 使用函数往目标文件中写入一个字节的数据。
    2. 数据被存储在内存的数据缓冲池中。
    3. 关闭要写入的文件。
    4. 底层函数把缓冲池中的数据写入磁盘中。

    从上面的步骤中可以看出我们的函数在执行到写入数据的操作的时候,数据并没有真正的写入到磁盘中,而是等到写入文件的操作结束的时候,才把数据缓冲池中的数据写入磁盘中。

    同样的我们使用C语言读一个字节数据的时候,同样会经历一下步骤:

    1. 打开要读的文件。
    2. 底层函数从磁盘中读取满整个缓冲池的数据。
    3. 关闭要读的文件。
    4. 从缓冲池中读取要读取的字节数,剩余没用的数据不读。

    缓冲池工作原理

    当知道我们的所有读写操作都要进入缓冲池时,我们同样要知道缓冲池的工作原理。

    • 缓冲池有一定固定的大小

    • 缓冲池在进行读数据的操作时,如果要读取的数据字节小于缓冲池的大小,缓冲池会从磁盘中读取满整个缓冲池的数据,所以当每次读取的字节数过小,读取次数过多的时候,会减少访问实际磁盘的磁盘,增加程序运行的性能。

    • 缓冲池的刷新,每刷新一次都会进行与实际物理内存的交互。

      当缓冲池满了或者目标操作文件关闭的时候,缓冲池会自动刷新,写数据时,缓冲池的数据会进入物理磁盘;读数据时,缓冲池的数据会数据固定字节的数据进入输出终端。

    总而言之,缓冲池仅仅是用户与物理磁盘之间数据交户的一个缓冲而已,不用想的太深奥。

    三、使用函数刷新缓冲池

    fflush函数:

    函数作用:

    刷新缓冲池

    函数定义:

    int fflush(FILE *P);
    

    参数 返回值:

    • P :目标操作文件
    • 返回值:如果成功,该函数返回零值。如果发生错误,则返回 EOF 。

    使用示例:

    现有空文件a.txt

    利用标准输入数据,在文件没有关闭的时候,查看文件内是否有写入的数据。

    #include <stdio.h>
    #include <string.h>
    void write_file()
    {
        FILE *p = fopen("a.txt", "w");
        char temp[100] = { 0 };
        while(1)
        {
            fgets(temp, sizeof(temp), stdin);
            if(strcmp(temp, "exit\n") == 0)
                break;
            fprintf(p, "%s", temp);
        }
        fclose(p);
    }
    int main()
    {
        write_file();
        return 0;
    }
    

    运行结果:

    1. 输入中

      [文件]$ gcc -o a fflush.c
      [文件]$ a
      hello
      
      
    2. 查看文件a.txt

      
      

      可以看到文件为空,输入的文件现在正存储在缓冲池中。

    3. 输入exit退出输入,查看文件a

      [文件]$ cat a.txt
      hello
      

      文件关闭,缓冲池中的数据写入磁盘。

    现在我们创建一个函数使每输入一次都写入一次磁盘:

    #include <stdio.h>
    #include <string.h>
    void write_file()
    {
        FILE *p = fopen("a.txt", "w");
        char temp[100] = { 0 };
        while(1)
        {
            fgets(temp, sizeof(temp), stdin);
            if(strcmp(temp, "exit\n") == 0)
                break;
            fprintf(p, "%s", temp);
            fflush(p);
        }
        fclose(p);
    }
    int main()
    {
        write_file();
        return 0;
    }
    

    运行结果:

    1. 输入中,查看a.txt

      [文件]$ gcc -o a fflush.c
      [文件]$ a
      hello
      
      

      再开启另一个终端查看文件 a.txt 状态:

      [文件]$ cat a.txt
      hello
      
    2. 输入结束,查看a.txt

      [文件]$ a
      hello
      exit
      [文件]$ cat a.txt
      hello
      [文件]$ 
      

    可以看到使用fflush函数把缓冲池中的数据写入了磁盘。

    四、总结

    当我们在往磁盘中录入重要的非常重要的数据的时候,一定要使用fflush不断的刷新缓冲池,因为数据非常重要;但我们输入不重要的数据是一定要尽量减少使用fflush函数的次数,因为那样会让程序变得缓慢。

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

    千次阅读 2021-12-09 09:54:51
    本文主要是对文本读写的基本操作进行记录,下面为相关函数的简单介绍和应用。 1. 打开文件C语言中,通过调用fopen打开文件,函数定义如下: FILE * fopen ( const char * filename, const char * mode ); ...

    0. 背景介绍

    在C语言中,stdio.h库中提供了Input/Output 操作的函数。本文主要是对文本读写的基本操作进行记录,下面为相关函数的简单介绍和应用。

    1. 打开文件

    在C语言中,通过调用fopen打开文件,函数定义如下:

    FILE * fopen ( const char * filename, const char * mode );

     Paramenters

    1. filename:文件路径
    2. mode:access mode访问方式
    "r"Read: 打开一个文件用于读取数据,此时文件必须存在
    "w"Write:创建一个新的文件用于写入数据,如果此时存在同名的文件,则会将里面内容抛弃,作为一个新的空文件对待
    "a"append:在文件的末尾写入数据
    /* fopen example */
    #include <stdio.h>
    int main ()
    {
      FILE * pFile;
      pFile = fopen ("myfile.txt","w");
      if (pFile!=NULL)
      {
        fputs ("fopen example",pFile);
        fclose (pFile);
      }
      return 0;
    }

    2. 关闭文件

    fclose函数用于关闭一个已经打开的文件,函数定义如下:

    int fclose ( FILE * stream );

     文件关闭成功返回0,失败返回EOF。

    /* fclose example */
    #include <stdio.h>
    int main ()
    {
      FILE * pFile;
      pFile = fopen ("myfile.txt","wt");
      fprintf (pFile, "fclose example");
      fclose (pFile);
      return 0;
    }

    3. 写入文件

    3.1 fprintf函数

    利用fprintf函数可以将格式化的数据写入到文件中, 函数定义如下:

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

     最常见的用例是在要写入字符串后面添加一个换行符,具体代码如下:

    #include <stdio.h>
     
    int main()
    {
       FILE *fp = NULL;
       char* str = "This is testing for fprintf...";
    
       fp = fopen("test.txt", "w+");
    
       fprintf(fp, "%s\n", str);
    
       fclose(fp);
    }

     这样得到的test.txt文本中会自动添加一个换行符,效果如下:

    3.2 fputs函数 

     fputs函数用于将一个字符串写入到文件中,工作原理是:复制从给定的字符串指针开始直到遇到空字符结束区间的内容,同时空字符并没copy到文件中。函数定义如下:

    int fputs ( const char * str, FILE * stream );

     通过写入两个连续的字符串,查看效果:

    #include <stdio.h>
     
    int main()
    {
       FILE *fp = NULL;
       char* str = "This is testing for fprintf...";
    
       fp = fopen("test.txt", "w");
    
       fputs(str, fp);
       fputs(str, fp);
       fclose(fp);
    }

    3.3. fwrite函数

     fwrite函数用于写入指定大小的内容到文件中, 函数定义如下:

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

    Parameters 

            1. size:每一个需要写入元素的字节大小

            2. count:需要写入数据的大小

    Return:返回值为最终成功写入元素的个数,应该与count大小相等。

    #include <stdio.h>
    #include <string.h>
    int main()
    {
       FILE *fp = NULL;
       char* str = "This is testing for fprintf...";
    
       fp = fopen("test.txt", "w");
    
       fwrite(str, sizeof(char), strlen(str), fp);
       fclose(fp);
    }

    4. 读取文件

    4.1 fread函数

    与fwrite函数类似,fread函数用于读取指定大小的内容,具体函数定义如下:

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

    参数含义与fwrite类似,就不多加介绍了。

    #include <stdio.h>
    #include <string.h>
    int main()
    {
       FILE *fp = NULL;
       char str[256] = {0};
    
       fp = fopen("test.txt", "r");
    
       fread(str, sizeof(char), sizeof(str), fp);
       printf("str: %s\n", str);
       fclose(fp);
    }

    此时的文本文件内容如下:

    输出的打印结果如下:

    也就是说,fread函数会一直读取数据,直到大小满足或者遇到EOF,才会结束读取数据,空白字符并不会影响读取的进度。 


    4.2 fgets函数

     fgets函数用于从文件中读取一个字符串,函数定义如下:

    char * fgets ( char * str, int num, FILE * stream );

     从stream中读取num个char元素,如果遇到换行符或者end-of-file就结束读取。数据读取完成会在str后面自动添加一个空字符

    应用举例:给定一个文本文件,每一行都是一个文件的路径,读取文件获取每个文件的路径信息。

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
    #define MAX_LINE 1024
     
    int main()
    {
    	char buf[MAX_LINE];  /*缓冲区*/
    	FILE* fp;            /*文件指针*/
    	int len;             /*行字符个数*/
    	if ((fp = fopen("bmpFiles.txt", "r")) == NULL)
    	{
    		perror("fail to read");
    		exit(1);
    	}
    
    	while (fgets(buf, MAX_LINE, fp) != NULL)
    	{
    		len = strlen(buf);
    		buf[len - 1] = '\0';  /*去掉换行符*/
    		printf("%s %d \n", buf, len - 1);
    	}
    	return 0;
    }

    输入的文本文件内容为:

    输出信息为:

     上述即为文本文件读写的基本操作!

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

    千次阅读 多人点赞 2022-02-03 22:07:05
    例如常见的有word 文档,txt文本文件,图片文件、音频文件等。 1.什么是文件? 文件是以计算机硬盘为载体存储在计算机上的信息集合。是数据源的一种,最主要的作用是保存数据。 在程序设计中,我们可将文件分为两...
  • C语言文件读写函数

    2022-04-01 19:21:24
    fopen( )函数来创建一个新的文件或者打开一个已有的文件,这个调用会初始化类型FILE的一个对象,类型FILE包含了所有用来控制流的必要的信息。下面是这个函数调用的原型: FILE *fopen( const char * filename, ...
  • 打开文件的函数原型 FILE *fopen( const char * filename, const char * mode ); 读、写文件的几种模式 模式 描述 ... 文件的类型为文本文件。 + 具有文件的读写权限。 r:以只读的方式打.
  • c语言文件读写格式

    2021-05-24 01:58:17
    c语言文件读写格式C程序文件读写操作在对文件进行读、写操作之前,首先要解决的问题是如何把程序中要读、写的文件与磁盘上实际的数据文件联系起来。在c语言中,其实这并不困难,只需要用c语言提供的库函数fopen...
  • C语言文件读写(1)-文本文件读操作

    万次阅读 多人点赞 2020-06-30 12:40:09
    C语言文件读写-之文本文件读写
  • 对于编程人员来说,文本文件和二进制文件就是一个声明,指明了你应该以什么方式(文本方式/二进制)打开这个文件,用什么函数读写这个文件(读写函数),怎么判断读到这个文件结尾等。 具体分析如下: 一、以哪种方式...
  • C语言文件读写操作

    千次阅读 2020-06-18 00:38:29
    很基础的用open, close, read 和 write 写的C语言文件读写代码
  • 本文主要介绍C语言 文件的随机读写,这里整理了相关资料及示例代码以便大家学习参考,学习此部分内容的朋友可以参考下
  • C语言文件读写

    2022-07-19 00:31:02
    C语言文件读写
  • C语言文本文件操作

    2020-08-24 21:01:27
    不想接传单了,看见老人也不想让座了,也不想为了别人考虑了,收起一切善良和心软,因为这个世界从来没有善待过我。。。 ---- 网易云热评 ...3、“w”,如果文件不存在,新建一个123.txt,如果存在,清.
  • 今天有同事的写文本文件时出了些问题,我查看了下,她的代码对于句柄的处理有些问题。每次打开后,没有close掉。经改正后,解决了问题。为了避免更多的同行避免这样的低级问题,我写了一段代码,供参考。概括来说...
  • /*打开文本文件 */ printer = fopen("PRN","w"); /*开启打印机*/ fp = fopen("weew.TXT","w"); do{ c = getc(funny); /* 从文件中得到一个字符 */ if(c != EOF) { putchar(c); //屏幕上显示字符 putc(c,...
  • 主要为大家详细介绍了C语言实现按行读写文件,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • C语言 文件读写的实现

    万次阅读 多人点赞 2019-04-26 11:55:33
    关于C语言文件读写,我将介绍下面这几种方式: 字符的读写:使用 fgetc() 函数 和 fputc() 函数; 字符串的读写:使用 fgets() 函数和 fputs() 函数; 格式化的读写(主要用于文本文件):使用 ...
  • C语言文件随机读写

    2022-04-08 09:00:56
    文件随机读写 ... 文本文件:零或ftell返回的值。(向前偏移则是负数,向后偏移是正数) origin:用作偏移量参考的位置。它由< cstdio >中定义的下列常量之一指定,专门用作此函数的参数: SEEK
  • ;文本文件读写 二进制文件的读写 文件的定位与随机读取;定义文件指针 打开文件 读写文件 关闭文件;读写文件;读写文件;读写文件;读写文件;读写文件;读写文件;读写文件;
  • C语言文件读写

    2022-01-17 18:02:25
    简要介绍了C语言文件读写的相关方式
  • C语言-文件读写

    2021-05-26 01:01:33
    文件读写打开文件fopen( 参数1,参数2)//例fopen("/Users/mac/Desktop/tmp/test.txt", "r")打开文件使用fopen()函数,函数可以接收两个参数,第一个参数表示文件位置,第二个参数表示打开之后可进行的操作参数1:参数...
  • C语言文件读写

    2021-08-19 18:35:53
    文本文件:把数据以字符的形式存储到文件中,可以直接打开,检查是否正确,但读写都需要进行数据转换 打开文件: FILE *fopen( const char *fname, const char *mode ); 功能:打开、创建文件 path:文件的路径 ...
  • C语言读写文件函数

    2022-02-26 21:11:01
    一:打开文件句柄 //参数1:文件路径 //参数2:文件打开模式 函数执行成功返回文件流指针,错误返回NULL。 FILE *fopen(const char *path, const char *mode);...模式 操作 区别 文件要求 ...r+ 读写 ...
  • 如何用C语言读写文件

    千次阅读 2021-05-25 06:13:42
    c语言读写文件程序:#include "stdio.h"#include main(){FILE *fp1;//定义文件流指针,用于打开读取的文件FILE *fp2;//定义文件流指针,用于打开写操作的文件char text[1024];//定义一个字符串数组,用于存储读取的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,857
精华内容 11,542
关键字:

c语言文本文件的读写

友情链接: springmassdamper.mdl.zip