精华内容
下载资源
问答
  • c语言文件读写函数有:“fgetc”和“fputc”(字符读写函数)、“fgets”和“fputs”(字符串读写函数)、“freed”和“fwrite”(数据块读写函数)、“fscanf”和“fprinf”(格式化读写函数)。对文件的读和写是最常用的...

    c语言文件读写函数有:“fgetc”和“fputc”(字符读写函数)、“fgets”和“fputs”(字符串读写函数)、“freed”和“fwrite”(数据块读写函数)、“fscanf”和“fprinf”(格式化读写函数)。

    e1b8ace04d87b38967c26996f65da767.png

    对文件的读和写是最常用的文件操作。

    在C语言中提供了多种文件读写的函数:

    字符读写函数 :fgetc和fputc

    字符串读写函数:fgets和fputs

    数据块读写函数:freed和fwrite

    格式化读写函数:fscanf和fprinf

    下面分别予以介绍。使用以上函数都要求包含头文件stdio.h。

    示例:#include

    main(){

    FILE *fp;

    char ch;

    if((fp=fopen("d:\\jrzh\\example\\c1.txt","rt"))==NULL){

    printf("\nCannot open file strike any key exit!");

    getch();

    exit(1);

    }

    ch=fgetc(fp);

    while(ch!=EOF){

    putchar(ch);

    ch=fgetc(fp);

    }

    fclose(fp);

    }

    推荐教程:《C语言》

    展开全文
  • C语言文件读写函数总结

    千次阅读 多人点赞 2018-04-30 23:51:59
    1、字符写入文件函数 fputc 2、从文件中读取字符 fgetc 二、字符串的读写 1、字符串写入文件函数 fputs 2、从文件中读取字符 fgets 三、块数据读写 1、向文件中写入块数据fwrite 2、从文件中读取块数据fread ...

    一、字符读写

    1、字符写入文件函数 fputc

    fputc函数的原型如下:
    
        int fputc( int c, FILE *fp );
    
    参数说明:
        其中,c是要写入的字节,它虽被定义为整型,但只使用最低位的一字节,fp是文件指针。
    
    fputc的功能:
        将字节c输出至fp所指向的文件。如果成功,位置指针自动后 移1字节的位置,并且返回c;否则返回EOF。
    

     

    2、从文件中读取字符 fgetc

    fgetc函数的原型如下:
    
        int fgetc( FILE *fp );
    
    参数说明:
        其中fp为文件指针。
    
    fgetc的功能:
        从fp所指向的文件中读取一个字节,如果成功则返回读取的字节,位置指针自动后移1字节的位置;否则返回EOF。

     

    二、字符串的读写

    1、字符串写入文件函数 fputs

    fputs函数的原型如下:
    
        int fputs( const char *s, FILE *fp );
    
    参数说明:
        其中,s是要写入的字符串,fp是文件指针。
    
    fputs的功能:
        将字符串s输出至fp所指向的文件(不含'\0')。如果成功,位置指针自动后移,函数返回一个非负整数;否则返回EOF。

     

    2、从文件中读取字符 fgets

    fgets函数的原型如下:
    
        char *fgets( char *s, int n, FILE *fp );
    
    参数说明:
        其中,s指向待赋值字符串的首地址,n是控制读取个数的参数,fp为文件指针。 
    
    fgets的功能:
        从位置指针开始读取 一行或n-1个字符,并存入s,存储时自动在字符串结尾加上'\0'。如果函数执行成功,位置指针自动后移,
    并返回s的值,否则返回NULL。

     

    三、块数据读写

    所谓块读写,就是读写n块以m个字节为单位的二进制数据,可以是一个字符(一个字符为一字节,则块大小为1*1),可以是一个长度为n字符串(块大小1*n),可以是长度为n的整型数组(整型以4字节算,块大小4*n),也可以是结构体等任意数据类型,并没有什么限制。

    1、向文件中写入块数据fwrite

    fwrite函数的原型如下:
    
        size_t fwrite ( void * ptr, size_t size, size_t count, FILE *fp );
    
    参数说明:
        ptr:指向保存读写数据的内存的指针,它可以指向数组、变量、结构体等。
        size:表示每个数据块的字节数。
        count:表示要读写的数据块的块数。
        fp:表示文件指针。
        理论上,每次读写 size*count 个字节的数据。
    
    fwrite的功能:
        从内存中的ptr指向的地址开始,将连续n*size字节的内容写入fp文件中。该函数的返回值是实际写入的数据块个数。

     

    2、从文件中读取块数据fread

    fread函数的原型如下:
    
        size_t fread ( void *ptr, size_t size, size_t count, FILE *fp );
    //size_t 是在 stddef.h 头文件中使用 typedef 定义的数据类型,表示无符号整数,也即非负数,常用来表示数量。
    
    参数说明:
        见fwrite
    
    fread的功能:
        从文件fp中,连续读取n*size字节的内容,并存入ptr指向的内存空间。该函数的返回值是实际读入的数据块个数。

     

    四、格式化读写

    格式化读写函数包括fprintf和fscanf两个函数,它们只用于文本文件的读写,不能用于二进制文件的读写。文本文件与二进制文件的区别下面注意点中有介绍。

    1、格式化写入文件fprintf

    fprintf函数的原型如下:
    
        int fprintf( FILE *fp, const char* format, 输出参数1, 输出参数2… );
    
    参数说明:
        其中,fp是文件指针,format为格式控制字符串,输出参数列表为待输出的数据。 
    
    fprintf的功能:
        根据指定的格式(format参数)发送数据(输出参数)到文件fp。

    例:

    #include <stdio.h>
      
    int main()
    {
        FILE *fp;
        fp = fopen("a.txt","w");
        int a = 10;
        double f = 11.11;
        fprintf(fp, "%d%lf", a, f);
        fclose(fp);
        return 0;
    }
    
    注意:fprintf()按格式输入到流,其用法和printf()相同,不过不是写到控制台,而是写到流罢了。注意的是
    返回值为此次操作写入到文件的字节数。如int c =fprintf(fp, "%s %s %d %f", str1,str2, a, b) ;
    假设str1:10字节;str2:10字节;a:2字节;b:8字节;则最终c为33,因为写入时不同的数据间自动加入一个空格。

     

    2、从文件中格式化读取fscanf

    fscanf函数的原型如下:
    
        int fscanf( FILE *fp,  const char* format, 地址1,地址2… );
    
    函数说明:
        其中,fp是文件指针,format为格式控制字符串,地址列表为输入数据的存放地址。 
    
    fscanf的功能:
        根据指定的格式(format参数)从文件fp中读取数据至内存(地址)。

    例:

    #include <stdio.h>
      
    int main()
    {
        FILE *fp;   
        fp = fopen("a.txt","r"); //需要创建a.txt文件,然后写入两个数据,空格隔开
        int i=0;
        double f=0;
        fscanf( fp, "%d%lf", &i, &f );
        fclose(fp);
        printf("%d\n%lf\n",i,f);
        return 0;
    }
    

    五、一些注意点

    (上面的都是网上抄的,下面的是我自己总结的,大佬们有砖的话轻点拍)

    1、fputc和fgetc注意点

    fputc 每次只能存一个字节,如果将整型、浮点型等数据类型入文件(因为整型浮点型每个数据都需要好几个字节,由于平台不同不固定,具体自己查不列出),就会造成数据只截取最后一个字节导致数据出错;同理fgetc每次也只能读取一个字节。这时用 fprintf 和 fscanf 函数格式化读写比较合适。

    fgetc 每次调用只能获取一个字节,如果是中文字符,utf8 编码会占用三个字节,因此要用 fgets 来读取。当然你不嫌累也可以用 fgetc 读三次,然后拼成一个中文字符。

     

    2、fputs和fgets注意点

    fgets 有局限性,每次最多只能从文件中读取一行内容,因为 fgets 遇到换行符就结束读取。如果希望读取多行内容,需要使用 fread 函数;相应地写入函数为 fwrite。

     

    3、fwrite和fread注意点

    fwrite和fread直接读写二进制文本。

    Ⅰ、这里有人可能有疑问,二进制文件和文本文件有什么区别?

    参考:

    1、https://www.zhihu.com/question/19971994

    2、https://www.cnblogs.com/zhangjiankun/archive/2011/11/27/2265184.html

            直观上的区别是:文本文件打开后我们可以看懂,而二进制文件打开会是一堆“乱码”。但是,其实所有的文件在计算机中都是二进制,导致“乱码”是因为编码上不同。

            举个例子,比如在代码中的整型数65,用fwrite方式写入文件,我们打开文件时就会惊奇的发现,文件中并不是65,而是一个大写的 'A' 。而我们用fprintf却不会出现这个问题,65还是65。这是为什么呢?

            因为fwrite是直接将数据65写进了文件,而fprintf是将65拆成两个字符,‘6’和‘5’,‘6’和‘5’在ASCII编码表中分别是54和53,于是将54和53写进文件。写进文件后我们再来看打开文件时发生了什么?

            文件软件首先将文件中的数据读进内存,然后再将内存中的数据根据这个文本软件设置的编码格式(比如utf-8)进行解码。来看fwrite写入的文件,文件软件读到 '65' 后去编码表中找到对应数据,是 'A' 然后就将 'A' 输出到屏幕上;再看用fprintf写入的文件,文件软件读到 '54' 和 '53' 后去编码表中找到对应数据,是 '6' 和 '5' ,因此最终我们在屏幕上看到的是65。

            更详细的解释去看我发的参考链接,可能讲的更清楚。

    注:上面直观上的区别说法不是很准确。当读写采用不同编码表时就会产生乱码,比如你是以utf-8格式写入文件,然后将文件软件换个编码格式,比如 "GB2312" ,这时再打开也会是乱码,根本原因是相同的字符在不同编码中的编号是不同的,比如 "你" 字,"utf-8" 中的编码为e4 bd a0,而在 "GB2312" 中的编码为 c4 e3,你用e4 bd a0在 "GB2312" 为编码下打开,就会在 "GB2312" 中去找对应的字符,那么当然不会是 "你" 字了,也就会产生乱码。

     

    Ⅱ、fopen函数中以文本方式与二进制方式打开文件的区别

    参考:https://blog.csdn.net/recsysml/article/details/44195793

    a、Windows平台下 
    如果以“文本”方式打开文件,当读取文件的时候,系统会将所有的"/r/n"转换成"/n";当写入文件的时候,系统会将"/n"转换成"/r/n"写入。 
    如果以"二进制"方式打开文件,则读/写都不会进行这样的转换。 

    b、在Unix/Linux平台下

    “文本”与“二进制”模式没有区别。

    读写二进制文件,在fopen函数中mode的参数要加上“b”,用来告诉函数库打开的文件为二进制文件,而非纯文字文件。不过在POSIX系统,包含Linux下会忽略该字符。

     

    Ⅲ、了解了文本方式与二进制方式区别我们来总结一下分别是哪些函数使用

    a、文本方式读写:fprintf/fscanf

    b、二进制方式读写:fgetc/fputc、fgets/fputs、fread/fwrite

     

    另:fwrite/fread与write/read的区别:

    https://blog.csdn.net/ljlstart/article/details/49535005

     

    4、fprintf和fscanf注意点

    fscanf将读取的ascii码转换成二进制放到内存中,效率略低;fgetc fputc 都是按照字节存取,无论文本模式还是二进制模式打开,都按照一个一个字节读取,不存在\r\n问题。

    还有一点是很多网站中文转utf-8的编码转换,utf-8编码是错的,它上面其实显示出来的是unicode编码,把我搞混好长时间。

     

     

    六、代码实例

    附上我的测试实例,有空的话自己打开一个个开关,编译运行看是否符合自己预期

    #include <stdio.h>
    #include <string.h>
    
    typedef struct 
    {
        char str1[6];
        char str2[6];
        char str3[6];    
    }STRS;
    
    
    int main()
    {
        FILE *fp;
        /*
         * fputc
         */
    
    #if 0
        fp = fopen("a.txt","w");
        //char a[3] = "你";
        //fputc(a[0],fp);
        //fputc(a[1],fp);
        //fputc(a[2],fp);
        int a=33;
        fputc(a,fp);
        fclose(fp);
    #endif
    
        /*
         * fgetc
         */
    
    #if 0 
        fp = fopen("a.txt","r");
        char c1 = fgetc(fp);
        char c2 = fgetc(fp);
        fclose(fp);
        printf("%c\n%c\n",c1,c2);
    #endif
    
        /*
         * fputs
         */
        
    #if 0
        fp = fopen("b.txt","w");
        char *s = "你好";
        fputs(s, fp);
        fclose(fp);
    #endif
    
        /*
         * fgets
         */
    
    #if 0
        fp = fopen("b.txt","r");
        STRS Strs;
        STRS *strs = &Strs;
    	    
        char hello1[6] = "hello";
        char hello3[6] = {'n','i','h','a','o'};
     
        memset(strs->str1,0,6);
        memcpy(strs->str1,hello1,6);
        memset(strs->str3,0,6);
        memcpy(strs->str3,hello3,6);
        //注意1:fgetc只能获取一位char字符,如果是中文字符,需要占三位char字符,因此要用fgets来读取;
        //注意2:读取的数据的长度要小于等于字符数组长度-1,因为字符串最后要存放'\0'。例如现在str2的长度为6,就会导致strs->str2最后不能加上‘\0’,从而会越界,连带输出str3,最终输出你好hello
        memset(strs->str2,0,6);
        fgets(strs->str2,7,fp);
        
        memset(strs->str3,0,6);
        memcpy(strs->str3,hello3,6);
        
        printf("%s\n",strs->str2);
        fclose(fp);
    #endif
    
        /*
         * fprintf
         */
    
    #if 0
        fp = fopen("c.txt","w");
        int b = 65;
        //double f = 1.11;
        //char s[3] = "你";
        //fprintf(fp, "%s", s);
        fprintf(fp, "%d", b);
        //fprintf(fp, "%d %lf", a, f);
        fclose(fp);
    #endif
    
        /*
         * fscanf
         */
    
    #if 0
        fp = fopen("c.txt","r+"); //需要创建a.txt文件,然后写入两个数据,空格隔开
        //int i=0;
        //double f=0;
        //fscanf( fp, "%d%lf", &i, &f );
        //printf("%d\n%lf\n",i,f);
        char c;
        fscanf( fp, "%c", &c);
        printf("%c\n",c);
        fclose(fp);
        
        fp = fopen("c.txt","r+");
        int fscanf_int;
        fscanf( fp, "%d", &fscanf_int );
        printf("%d",fscanf_int);
        fclose(fp);
    #endif
    #if 0
        fp = fopen("e.txt","r");
        double a = 0;
        fscanf( fp, "%lf", &a);
        fclose(fp);
        printf("%lf\n",a);
    #endif
         
        /*
         * fwrite
         */
        
    #if 0
        fp = fopen("e.txt","wb");
        //char array[3] = "你";
        //fwrite(array, sizeof(char), 3, fp);
        //double array[3] = {1.11, 2.22, 3.33};
        //fwrite(array, sizeof(double), 3, fp);
        //double a = 3.14159;
        //fwrite(&a, sizeof(double), 1, fp);
        char a=65;
        fwrite(&a, sizeof(char), 1, fp);
        fclose(fp);
    #endif
    
        /*
         * fread
         */
        
        /*
        fp = fopen("e.txt","rb");
        double array[3];
        fread(array, sizeof(double), 3,fp);
        fclose(fp);
        for(int i=0;i<3;i++)
        {
    	printf("%lf\n",array[i]);
        }
        */
    
        return 0;
    }

     

    展开全文
  • c语言文件读写函数

    2014-09-28 12:32:14
    字符读写函数:(fgetc和fputc) fputc函数:把一个字符写到磁盘文件上。具体格式如下:fputc(ch,fp) fgetc函数:从磁盘文件读取一个字符。其格式如下:ch=fgetc(fp) 字符串读写函数:(fgets和fputs) fputs函数:...
  • C语言读写文件

    2014-12-17 17:49:16
    c语言读写文件,并输出log

           上一篇文章android JNI 实例 中,讲到了如何实现用一个JNI用来读写文件,但是只是实现了对接口的调用,并未写出在c文件中是怎样实现文件读写的,这篇文章将写出c语言的具体实现,把WriteFile方法的具体实现补充完整。

       jstringJava_com_example_bootanim_FileOPT_WriteFile(JNIEnv *env,
    
           jobjectthiz, jstring oldpath, jstring newpath){//oldFile ="/system/build.prop";
    
                         int from_fd;
    
                          int to_fd;
    
                         long file_len=0;
    
                         int ret=1;
    
                         char buffer[BUFFER_SIZE];
    
                         char *ptr;
    
           //下面是把string转换成const char *型,在c语言中openfile的函数是constchar *
    
           const char *oldfilea =(*env)->GetStringUTFChars(env, oldpath, 0);
    
                        const char *newfilea =(*env)->GetStringUTFChars(env,newpath,0);
    
                        ALOGI("jniooooffff:%s",oldfilea);
    
                       if((from_fd=open(newfilea,O_RDONLY | O_NOFOLLOW))==-1) {
    
                                 ALOGI("jniooooxxx from_fd fail");//c文件中的log输出,参照后面的做法
    
                                 return "0";
    
                       }
    
                      ALOGI("jniooooxxx to_fdopen");
    
                       if((to_fd=open(oldfilea,O_WRONLY|O_NOFOLLOW))==-1) {
    
                                   ALOGI("jniooooxxx to_fd= fail");
    
                                    return "0";
    
                       }
    
                      file_len=lseek(from_fd,0L,SEEK_END);
    
                      lseek(from_fd,0L,SEEK_SET);
    
                       ALOGI("jniooooxxxwhile");
    
                      while(ret) {
    
                                ret= read(from_fd, buffer, BUFFER_SIZE);
    
                                if(ret==-1){
    
                                             ALOGI("jniooooxxx ret==-1");
    
                                            return "0";
    
                                }
    
                                write(to_fd, buffer, ret);
    
                                file_len-=ret;
    
                                 bzero(buffer,BUFFER_SIZE);
    
                      }
    
                      ALOGI("jniooooxxxclose");
    
                      close(from_fd);
    
                      close(to_fd);
    
                      return (*env)->NewStringUTF(env," opecccccccc!");
    
        }


    关于jni输出log,参照下面做法:

        1.android.mk中加入LOCAL_STATIC_LIBRARIES:= libcutils liblog

        2..c文件中加入:

           #include<utils/Log.h>

           #include<stdlib.h>

        3.ALOGI("jniooooffff:%s",oldfilea);//jniooooffffTAGoldfilea是我们要输出的字符串。




          

    展开全文
  • C语言文件读写函数详解

    千次阅读 2016-03-24 12:40:54
     fopen的原型是:FILE *fopen(const char *filename,const char *mode),fopen实现三个功能:为使用而打开一个流,把一个文件和此流相连接,给此流返回一个FILR指针。  参数filename指向要打开的文件名,mode表示...

    C语言/C++文帮助文档免积分下载(点击跳转)

    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。 

      例:tmpnam(str1);

     

     

     

    1.    首先要理解几个概念: 

    文件: 按一定规则存储在磁盘上的数据集合。 

    文件名: 能唯一标识某个磁盘文件的字符串。形式: 盘符:/ 路径 / 文件名.扩展名 

    文本文件:: 数据以其数字字符的ASCII码形式、一个字节一个字节地存储在磁盘上。 

    二进制文件:数据以二进制形式在存储在磁盘上。 

    设备文件:输入/输出设备 

    标准输入文件:键盘 

    标准输出文件/标准错误输出文件:显示器 

    文件型指针:C语言是通过名为FILE的结构型指针来管理文件读写的。FILE *<变量名> 

    文件的打开和关闭 :文件操作先建立文件与文件指针之间的关系,接着进行文件的读与写。建立文件与文件指针之间的联系的过程是文件的打开。终止这种联系就是文件的关闭。 

    FILE结构:定义在〈stdio.h〉中。形式如下: 

    typedef struct 



    int  _fd;   /*文件代号*/ 

    int  _cleft;       /* 文件缓冲区所剩字节数*/ 

    int  _mode;    /* 文件使用模式*/ 

    char  *nextc;     /* 下一个等待处理的字节地址, 即文件内部指针*/ 

    char  *buff;    /*  文件缓冲区首地址  */ 

    }FILE; 

    2. 主要操作函数用相应的使用 

    1) 文件的打开与关闭:  

    #include <stdio.h> 

    FILE *fp; 

    fp = fopen(char* filename,  char*  made); 

    if(fp == NULL) 



    exit(0); 



    fclose(fp) 

    mode和种类有: 

    r : 打开一个文本文件,供读取数据, 文件不存在,则返回NULL 

    w : 建立一个供写入的文本文件. 废弃原有内容 

    a: 打开或建立一个把数据追加到文件尾的文本文件 

    r+: 更新数据 

    w+ : 更新数据,废弃原有内容 

    a+ : 更新数据, 写入的数据追加到文件尾. 

    二进制在后面加"b" 

    标准输入/输出文件的文件型指针:  stdin, stdout, stderr 

    2)   文件的读与写: 

    把一个字符写入文件, 或从文件中读取一个字符:  文件内部指针自动移向下一位可读写的位置 

    int fputc(char ch, FILE *fp); 

    int fgetc( FILE *fp) 

    把一行数据写入文件, 或读取一行数据: 

    char * fputs(char *str, FILE *fp) 

    char * fgets(char *str, int n, FILE *fp) ; // 读取N-1 个字符,第N个字符补'/0' 

    把指定字节数的若干数据写入文件, 或读出文件. 

    int fwrite(char * buf, unsigned size, unsigned n, FILE *fp); size 每个数据的字节数,  n 个数据. 

    int fread(char *buf, unsigned size, unsigned n, FILE *fp); 

    把指定格式的数据写入文件, 或读取指定格式的数据 

    int fprintf(FILE *fp, char *format, e1,e2,......en); 

    int fscanf(FILE *fp, char *format, e1,e2,......en); 

      

    3) 文件位置的确定与指针管理. 

      

    文件尾的测试:  int feof(FILE *fp); //当前已到达文件尾返回非0, 否则返回0 

    不同的计算机系统以不同的键盘组合键形成文件的结束符. IBM PC及其兼容机是<ctrl> + z 

      

    把文件内部指针重新定位到文件的起始位置     int rewind(FILE *fp); 

      

    把文件内部指针定位到指定的位置:   int fseek(FILE *fp, long offset, int from);  

    from 是定位的起始点. 

    SEEK_SET    0    从文件头开始 

    SEEK_CUR    1    从文件内部指针当前位置开始 

    SEEK_END    2   从文件尾开始 

    offset 是以From 为起始点的依稀字节数,大于0表示向文件尾方向, 0 不移动,  

      

    文件操作出错测式   int ferror(FILE *fp);  

    用于对由FP指向的文件最近一次操作进行正确性测试. 出错返回非0,还没返回0 

      

    4)  文件的删除 

    int remove(char * filename); 

      

      3.  一些以前我没想到的知识点. 

    char ch; 

    ch = getchar ()  功能等价于 ch = fgetc(stdin)  功能等价于 scanf("%c",ch)   功能等价于 fscanf(stdin, "%c",ch) 

    putchar(ch)  功能等价于 printf("%c",ch)   功能等价于 fputc(stdout)   功能等价于 fprintf(stdout, "%c", ch)

    展开全文
  • C语言fputc()函数:写文件函数(将一指定字符写入文件流中) 头文件: #include 定义函数: int fputc(int c, FILE * stream); 函数说明:fputc 会将参数c 转为unsigned char 后写入参数...
  • C语言常用文件读写函数记录
  • C语言读写文件操作

    万次阅读 多人点赞 2018-12-28 20:05:11
    C语言中对于文件的操作是通过指针来完成的,要注意,文件指针不是指向一段内存空间的,它实际上指向的是描述这个文件相关信息的一个文件结构体。 声明文件指针变量的形式为: FILE *file; 定义好一个文件指针...
  • 文章主要例举一个c语言文件操作常用函数读写文件的代码,感性趣的朋友可以看看。
  • C语言读写文件与二进制文件

    千次阅读 2017-08-26 16:24:56
    读写文件有“w”和“wb”格式,分别是以文本形式读写和以二进制形式读写。 1、文本方式读取要把回车,换行两个字符变成一个字符...2、文本形式和二进制形式适用的结束符和读写函数不同。尤其是结束符的问题,很困扰人。
  • c语言读写文件fopen

    千次阅读 2013-08-15 19:56:13
     函数功能:打开一个文件  函数原型:FILE * fopen(const char * path,const char * mode);  相关函数:open,fclose,fopen_s[1],_wfopen  所需库:  返回值:文件顺利打开后,指向该流的文件指针就会被...
  • C语言文件操作函数

    千次阅读 2017-04-18 22:27:52
    C语言文件操作函数整体概述 endgrent():关闭文件(关闭组文件) endpwent():关闭文件(关闭密码文件) endutent():关闭文件(关闭utmp文件) fgetgrent():读取组格式函数 fgetpwent():读取密码格式 getdgid():...
  • C语言文件操作函数大全

    万次阅读 多人点赞 2018-01-19 20:35:35
    C语言文件操作函数大全 2018-1-19  13.1C语言文件 1,两种文件存取方式(输入,输出方式) 顺序存取 直接存取 2,数据的两种存放形式 文本文件 二进制文件 13.2文件指针 定义文件类型指针变量的一般...
  • C语言文件操作函数的封装
  • C语言读写文件内容的参数形式

    千次阅读 2018-01-03 10:41:29
    C语言中,大家常用到fopen打开文件,准备进行写操作,再用fwrite把数据写入文件,最后用fclose关闭文件。 如以下C代码:   #include char buf[10] = {10,10,10,10,10,10,10,10,10,10}; FILE *fp = fopen...
  • iphone开发 C语言读写文件

    千次阅读 2012-10-10 11:09:44
    //这个函数得到存取的路径,读写文件获取路径比较保持一致,比如都用下面函数。 - (char*)GetFilePathByfileName:(char*)filename {   NSArray *paths = NSSearchPathForDirectoriesInDomains...
  • fread() 函数用来从指定文件中读取块数据。所谓块数据,也就是若干个字节的数据,可以是一个字符,可以是一个字符串,可以是多行数据,并没有什么限制。fread() 的原型为: size_t fread ( void *ptr, size_t size...
  • C语言读写TXT文件

    2020-08-28 20:55:53
    其次是文件的打开函数: file=fopen(" "," "); (其中第一个双引号里是文件地址,第二个是打开类型) 打开类型汇总: r 以只读方式打开文件,该文件必须存在。 r+ 以可读写方式打开文件,该文件必须存在。 rb+ ...
  • c语言读写文件操作

    千次阅读 2011-10-20 14:12:55
    #include #include #include FILE *stream;//, *stream2; FILE *stream2; void main( void ) { int numclosed; ...//试图打开文件data.txt,如果该文件不存在,则自动创建 if( (str
  • 利用纯C语言实现的配置文件.ini读写函数,可跨平台使用。功能与Windows API函数 WritePrivateProfileString 和GetPrivateProfileString 一样
  • fopen,fread,fwrite:二进制读写的顺序是用fopen以二进制方式打开读写文件,然后使用fread和fwrite两个函数将数据写入二进制文件中 #include <stdio.h> #include <stdlib.h> #define MAXLEN 1024 int...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,894
精华内容 24,357
关键字:

c语言读写文件函数

c语言 订阅