精华内容
下载资源
问答
  • c++中的文件读写函数
    千次阅读
    2019-04-03 07:58:33


    头文件,命名空间

    #include <fstream>
    using name space std;


     

    //函数
    //构造函数,构造函数传入文件名称会尝试打开文件。
    explicit basic_ifstream( const char* filename,
                    std::ios_base::openmode mode = ios_base::in );	(2) 	
    				
    explicit basic_ifstream( const std::string& filename,
                    std::ios_base::openmode mode = ios_base::in );	(4) 	(since C++11)
    				
    explicit basic_ifstream( const std::filesystem::path& filename,
                    std::ios_base::openmode mode = ios_base::in );	(5) 	(since C++17)
    				
    basic_ifstream( basic_ifstream&& other ); 						(6) 	(since C++11)
    	
    /*
    explicit 不接受隐式转换	https://baike.baidu.com/item/explicit/4941869?fr=aladdin
    filename: 类型char*或string& ,要打开的文件名称,字符串内子目录符合是 "\\"
    mode: 类型ios_base::openmode,打开方式
    	ios::in 打开一个供读取的文件(ifstream流的默认值)
    	ios::out 打开一个供写入的文件(ofstream流的默认值)
    	ios::app 在写之前找到文件尾
    	ios::ate 打开文件后立即将文件定位在文件尾
    	ios::trunc 废弃当前文件内容
    	ios::nocreate(已不再支持) 如果要打开的文件并不存在,那么以此参数调用open()函数将无法进行
    	ios::noreplace (已不再支持) 如果要打开的文件已存在,试图用open()函数打开时将返回一个错误。
    	ios::binary 以二进制的形式打开一个文件,默认为文本文件
    官方手册没有第三个参数,实际有第三个参数
    第三个参数:读写权限。类型int.默认是0x40,允许其他进程对自己打开的文件进行读写。
    	#define _SH_DENYRW      0x10    /* deny read/write mode */拒绝对文件进行读写
    	#define _SH_DENYWR      0x20    /* deny write mode */拒绝写入文件
    	#define _SH_DENYRD      0x30    /* deny read mode */拒绝文件的读取权限
    	#define _SH_DENYNO      0x40    /* deny none mode */读取和写入许可
    	#define _SH_SECURE      0x80    /* secure mode */共享读取,独占写入
    
    */
    
    
    /*返回打开状态 */
    bool is_open();												(until C++11)
    bool is_open() const;										(since C++11)
    
    //文件打开和状态判断示例
    #include <string>
    #include <fstream>
    #include <iostream>
    //this file is called main.cpp
     
    bool file_exists(const std::string& str)
    {
       std::ifstream fs(str);
       return fs.is_open();
    }
     
    int main()
    {
      std::boolalpha(std::cout);
      std::cout << file_exists("main.cpp")  << '\n'
                << file_exists("strange_file") << '\n';
    }
    
    /* 读取一行文本
    basic_istream& getline( char_type* s, std::streamsize count );
    	(1) 	
    basic_istream& getline( char_type* s, std::streamsize count, char_type delim );
    	(2) 
    
    */
    //读取行文本示例
    #include <iostream>
    #include <sstream>
    #include <vector>
    #include <array>
     
    int main()
    {
        std::istringstream input("abc|def|gh");
        std::vector<std::array<char, 4>> v;
     
        // note: the following loop terminates when std::ios_base::operator bool()
        // on the stream returned from getline() returns false
        for (std::array<char, 4> a; input.getline(&a[0], 4, '|'); ) {
            v.push_back(a);
        }
     
        for (auto& a : v) {
            std::cout << &a[0] << '\n';
        }
    }
    
    /* 读取指定数量的字符
    basic_istream& read( char_type* s, std::streamsize count );
    		
    */
    
    //读取字符示例
    #include <iostream>
    #include <fstream>
    #include <sstream>
    #include <string>
    #include <cstdint>
     
    int main()
    {
        // read() is often used for binary I/O
        std::string bin = {'\x12', '\x12', '\x12', '\x12'};
        std::istringstream raw(bin);
        std::uint32_t n;
        if(raw.read(reinterpret_cast<char*>(&n), sizeof n))
            std::cout << std::hex << std::showbase << n << '\n';
     
        // prepare file for next snippet
        std::ofstream("test.txt", std::ios::binary) << "abcd1\nabcd2\nabcd3";
     
        // read entire file into string
        if(std::ifstream is{"test.txt", std::ios::binary | std::ios::ate}) {
            auto size = is.tellg();
            std::string str(size, '\0'); // construct string to stream size
            is.seekg(0);
            if(is.read(&str[0], size))
                std::cout << str << '\n';
        }
    }
    
    

    参考手册

    CPP参考手册中文
    https://zh.cppreference.com/w/%E9%A6%96%E9%A1%B5

    CPP参考手册
    https://en.cppreference.com/w/

    更多相关内容
  • C++文件读写函数介绍.pdf
  • 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;
    }

     

    展开全文
  • Linux下文件读写函数的使用最全总结

    千次阅读 2019-11-21 00:11:05
    Linux下文件读写函数的使用总结读、写、追加方式modefopen()函数用法char *fgets(str,n,fp)int fputs(const char *s, FILE *stream);fclose()函数1. 文件的顺序写函数文件的顺序读操作函数文件的随机读写函数 读、...


    注:本文对原文进行了一定的总结,文末已经申明了原文链接。

    读、写、追加方式mode

    r: 读打开, 不创建

    w: 写打开,创建/清空

    a: 写打开, 创建/追加


    r+: 读/写打开,不创建

    w+:读/写打开,创建/清空

    a+:读/写打开, 创建/追加

    衍生:

    rb,rb+,wb,wb+,ab,ab+; 对二进制操作

    rt,rt+,wt,wt+,at,at+; 对文本文件操作

    fopen()函数用法

    #include<stdio.h>
    #include<stdlib.h>
    
    void main()
    {
    FILE *fp;
    char str[16];
    if((fp=fopen("out.dat","rt"))==NULL)
    {
    printf("Cannot open file strike any key exit!");
    exit(1);
    }
    fgets(str,16,fp);
    printf("%s",str);
    fclose(fp);
    }
    

    char *fgets(str,n,fp)

    读字符串函数fgets函数的功能是从指定的文件中读一个字符串到字符数组中,函数调用的形式为: fgets(字符数组名,n,文件指针); 其中的n是一个正整数。表示从文件中读出的字符串不超过 n-1个字符。在读入的最后一个字符后加上串结束标志”。
    例如:fgets(str,n,fp);的意义是从fp所指的文件中读出n-1个字符送入 字符数组str中。

    对fgets函数有两点说明:

    1. 在读出n-1个字符之前,如遇到了换行符或EOF,则读出结束。

    2. fgets函数也有返回值,其返回值是字符数组的首地址。
      实例代码如下:

    #include<stdio.h>
    #include<stdlib.h>
    
    void main()
    {
    char *p;//创建一个字符指针接收fgets()返回值
    FILE *fp;
    char str[16];
    if((fp=fopen("out.dat","rt"))==NULL)//以读文本文件方式打开文件out.dat
    {
    printf("Cannot open file strike any key exit!");
    exit(1);
    }
    p = fgets(str,16,fp);
    printf("p:address=%p\n",p);
    printf("p:=%s\n",p);
    printf("%s",str);
    fclose(fp);
    }
    
    

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

    int fputs(const char *s, FILE *stream);
    int puts(const char *s);
    返回值:成功返回一个非负整数,出错返回EOF
    写字符串函数fputs向指定的文件写入一个字符串,puts向标准输出写入一个字符串。
    fputs函数的功能是向指定的文件写入一个字符串,其调用形式为: fputs(字符串,文件指针) 其中字符串可以是字符串常量,也可以是字符数组名, 或指针 变量,例如:
    fputs(“abcd“,fp);
    其意义是把字符串“abcd”写入fp所指的文件之中。
    实例代码如下:

    #include<stdlib.h>
    #include<stdio.h>
    main()
    {
    FILE *fp;
    char ch,st[20];
    if((fp=fopen("string","at+"))==NULL)
    {
    printf("Cannot open file strike any key exit!");
    //getch();
    exit(1);
    }
    printf("input a string:");
    scanf("%s",st);
    fputs(st,fp);
    rewind(fp);
    ch=fgetc(fp);
    while(ch!=EOF)
    {
    putchar(ch);//打印一个字符
    ch=fgetc(fp);/fgetc()函数的功能是从文件指针指定的文件中读入一个字符
    }
    fclose(fp);
    } 
    
    

    fclose()函数

    fclose()函数用来关闭一个由fopen()函数打开的文件 , 其调用格式为:
    int fclose(FILE *stream);
    该函数返回一个整型数。当文件关闭成功时, 返回0, 否则返回一个非零值。可以根据函数的返回值判断文件是否关闭成功。

    1. 文件的顺序写函数

    fprintf()、fputs()和fputc()函数
    函数fprintf()、fputs()和fputc()均为文件的顺序写操作函数, 其调用格式如下:
    int fprintf(FILE *stream, char *format, );
    int fputs(char *string, FILE *steam);
    int fputc(int ch, FILE *steam);

    一个实例囊括以上函数:

     #include<stdio.h>
         main()
         {
              char *s="That's good news"; /*定义字符串指针并初始化*/
              int i=618;                    /*定义整型变量并初始化*/
              FILE *fp;                     /*定义文件指针*/
              fp=fopen("example.dat", "w");    /*建立一个文字文件只写*/
              fputs("Hello  world", fp);/*向所建文件写入一串字符*/
              fputc(':', fp);               /*向所建文件写冒号:*/
              fprintf(fp, "%d\n", i);       /*向所建文件写一整型数*/
              fprintf(fp, "%s", s);         /*向所建文件写一字符串*/
              fclose(fp);                   /*关闭文件*/
         }
    
    

    结果如下:
    在这里插入图片描述

    文件的顺序读操作函数

    fscanf()、fgets()和fgetc()函数
    函数fscanf()、fgets()和fgetc()均为文件的顺序读操作函数, 其调用格式如下:
    int fscanf(FILE *stream, char *format, );
    char fgets(char *string, int n, FILE *steam);
    int fgetc(FILE *steam);
    fscanf()函数的用法与scanf()函数相似, 只是它是从文件中读到信息。 fscanf()函数的返回值为EOF(即-1), 表明读错误, 否则读数据成功。fgets()函数从文件中读取至多n-1个字符(n用来指定字符数), 并把它们放入string指向的字符串中, 在读入之后自动向字符串未尾加一个空字符, 读成功返回string指针, 失败返回一个空指针。fgetc()函数返回文件当前位置的一个字符, 读错误时返回EOF。
    实践代码如下:

      #include<stdio.h>
         main()
         {
              char *s, m[20];
              int i = 2020;
              FILE  *fp;
              fp=fopen("example.dat", "r");    /*打开文字文件只读*/
              fgets(s, 24, fp);             /*从文件中读取23个字符*/
              printf("%s", s);              /*输出所读的字符串*/
              fscanf(fp, "%d", &i);         /*读取整型数*/
              printf("%d", i);              /*输出所读整型数*/
              putchar(fgetc(fp));           /*读取一个字符同时输出*/
              fgets(m, 17, fp);             /*读取16个字符*/
              puts(m);                      /*输出所读字符串*/
              fclose(fp);                   /*关闭文件*/
             
         }
    
    

    结果如下:
    在这里插入图片描述

    文件的随机读写函数

    有时用户想直接读取文件中间某处的信息, 若用文件的顺序读写必须从文件头开始直到要求的文件位置再读, 这显然不方便。Turbo C2.0提供了一组文件的随机读写函数, 即可以将文件位置指针定位在所要求读写的地方直接读写。
    文件的随机读写函数如下:
    int fseek (FILE *stream, long offset, int fromwhere);
    int fread(void *buf, int size, int count, FILE *stream);
    int fwrite(void *buf, int size, int count, FILE *stream);
    long ftell(FILE *stream);
    fseek()函数的作用是将文件的位置指针设置到从fromwhere开始的第offset 字节的位置上, 其中fromwhere是下列几个宏定义之一:
    文件位置指针起始计算位置fromwhere

    符号常数数值含义
    SEEK_SET0 从文件开头
    SEEK_CUR1从文件指针的现行位置
    SEEK_END2从文件末尾

    offset是指文件位置指针从指定开始位置(fromwhere指出的位置)跳过的字节数。它是一个长整型量, 以支持大于64K字节的文件。fseek()函数一般用于对二进制文件进行操作。
    当fseek()函数返回0时表明操作成功, 返回非0表示失败。

     #include<stdlib.h>
     #include<stdio.h>
         main()
         {
    	  char ch;
              FILE *fp;
              if((fp=fopen("example.dat", "r"))==NULL)
                {
                  printf("Can't open file");
                  exit(1);
                }
              fseek(fp,7, SEEK_SET);
              ch = fgetc(fp);
    	  putchar(ch);
              fclose(fp);
         }
    

    结果如下:
    在这里插入图片描述
    说明:第7个偏移量是取到的字符是w,文件的第一个字节偏移量是0.

    fread()函数是从文件中读count个字段, 每个字段长度为size个字节, 并把它们存放到buf指针所指的缓冲器中。

     #include <stdio.h>
       #include <stdlib.h>
         main()
         {
              FILE *fp;
              int dat[100];
              fp=fopen("example.dat", "rb");/*打开一个二进制文件只读*/
              if(fread(dat, sizeof(int), 100, fp)!=100)
                                            /*判断是否读了100个数*/
                {
                   if(feof(fp))
                     printf("End of file"); /*不到100个数文件结束*/
                   else
                     printf("Read error");  /*读数错误*/
              fclose(fp);                   /*关闭文件*/
         }
    }
    

    fwrite()函数是把buf指针所指的缓冲器中, 长度为size个字节的count个字段写到stream指向的文件中去。

    #include <stdio.h>
         main()
         {
              char buf[]={"wohao"};
                             /*定义浮点数组并初始化*/
              int i;
              FILE *fp;
              fp=fopen("test_b999.txt", "wt"); /*创建一个二进制文件只写*/
              fwrite(buf, sizeof(char),5,fp);/*将6个浮点数写入文件中*/
              fclose(fp);                   /*关闭文件*/
         }
    
    

    当用标准文件函数对文件进行读写操作时, 首先将所读写的内容放进缓冲区, 即写函数只对输出缓冲区进行操作, 读函数只对输入缓冲区进行操作。例如向一个文件写入内容, 所写的内容将首先放在输出缓冲区中, 直到输出缓冲区存满或使用fclose()函数关闭文件时, 缓冲区的内容才会写入文件中。若无fclose() 函数, 则不会向文件中存入所写的内容或写入的文件内容不全。有一个对缓冲区进行刷新的函数, 即fflush(), 其调用格式为:
    int fflush(FILE *stream);
    该函数将输出缓冲区的内容实际写入文件中, 而将输入缓冲区的内容清除掉。
    feof()和rewind()函数
    这两个函数的调用格式为:
    int feof(FILE *stream);
    int rewind(FILE *stream);
    feof()函数检测文件位置指示器是否到达了文件结尾, 若是则返回一个非0 值, 否则返回0。这个函数对二进制文件操作特别有用, 因为二进制文件中, 文件结尾标志EOF也是一个合法的二进制数, 只简单的检查读入字符的值来判断文件是否结束是不行的。如果那样的话, 可能会造成文件未结尾而被认为结尾, 所以就必须有feof()函数。
    下面的这条语句是常用的判断文件是否结束的方法。
    while(!feof(fp))
    fgetc(fp);
    while为循环语句, 将在下面介绍。
    rewind()函数用于把文件位置指示器移到文件的起点处, 成功时返回0, 否则, 返回非0值。
    非标准文件函数
    这类函数最早用于UNIX操作系统, ANSI标准未定义, 但有时也经常用到, DOS 3.0以上版本支持这些函数。它们的头文件为io.h。
    一、文件的打开和关闭
    1. open()函数
    open()函数的作用是打开文件, 其调用格式为:
    int open(char *filename, int access);
    该函数表示按access的要求打开名为filename的文件, 返回值文件描述符, 其中access有两部分内容: 基本模式和修饰符, 两者用" "(“或”)方式连接。修饰符可以有多个, 但基本模式只能有一个。access的规定如表3-2。
    表3-2 access的规定基本模式含义

    修饰符含 义
    O_RDONLY只读
    O_APPEND文件指针指向末尾
    O_WRONLY只写
    O_CREAT文件不存在时创建文件,属性按基本模式属性
    O_RDWR读写
    O_TRUNC若文件存在, 将其长度缩为0, 属性不变
    O_BINARY打开一个二进制文件
    O_TEXT打开一个文字文件

    open()函数打开成功, 返回值就是文件描述字的值(非负值), 否则返回-1。

    1. close()函数
      close()函数的作用是关闭由open()函数打开的文件, 其调用格式为:
      int close(int handle);
      该函数关闭文件描述字handle相连的文件。

    二、读写函数

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

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

    3. create()函数
      create函数也能打开一个文件,如果文件不存在,则创建它。和open一样,creat也在调用成功后返回一个文件描述符,如果失败,则设置errno变量并返回-1.

    creat的原型为:

    int creat (const char *pathname,mode_t mode);
    实例如下:

    create("wen.txt",666);
    

    他等价于:

    open(pathname,O_CREAT | O_TRUNC | O_WRONLY,mode);

    在使用完某个函数后要关闭他,使用 close函数。close只有一个参数,即open返回的文件描述符.

    close的原型为:

              #include <unist.d>
    
               int close(int fd);    
    

    三、随机定位函数

    1. lseek()函数
      lseek()函数的调用格式为:
      int lseek(int handle, long offset, int fromwhere);
      该函数对与handle相连的文件位置指针进行定位, 功能和用法与fseek() 函数相同。

    2. tell()函数
      tell()函数的调用格式为:
      long tell(int handle);
      该函数返回与handle相连的文件现生位置指针, 功能和用法与ftell()相同。
      原文链接:https://blog.csdn.net/zwt0112/article/details/54582036

    展开全文
  • 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)

    展开全文
  • PB文件读写函数

    2013-06-20 15:38:47
    用于PB文件读写的必备函数,借口已经做了封装。欢迎试用。
  • c语言文件读写函数

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

    千次阅读 2017-12-12 10:03:10
    一、函数原型 ...path:文件路径 mode:打开方式 打开成功函数返回目标文件文件指针,否则返回空指针 size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream); ptr:保存数据的指针 siz
  • c文件读写函数

    2012-10-29 11:36:50
    liunix下常用c的文件读写函数比较,fprintf/fscanf,read/write,fread/fwrite等。
  • iso文件读写函数.docx

    2013-10-21 15:21:55
    iso文件读写函数.创建文件fileName文件名称,contents文件的内容,如果开始没有内容可以设置为nil,attributes文件的属性,初始为nil
  • C++ 文件读写相关函数

    千次阅读 2019-03-13 14:19:49
    几个C/C++语言文件读写函数 1、打开和关闭文件  (1)打开文件:FILE * fopen(const char *filename, const char *mode)  在使用打开文件函数时,我们要提供一个要打开的文件名,这里要提供一个当前用户有...
  • VC文件读写函数

    2011-11-10 21:53:47
    涉及VC文件读写函数,包括函数详解和相应的代码示例,是有益的参考
  • bcb 文件读写函数

    2011-06-17 11:13:28
    自己整理的有关 bcb 文件读写函数 共23个
  • PB 文件读写函数 将文件inport到程序中即可。 可将文件内容转换成blob形式存储; 可将blob数据存储为文件。
  • 1、打开文件(文件操作函数:fopen) 2、文件数据读取(文件操作函数:fgets、file、readfile、feof等) 3、关闭文件(文件操作函数:fclose) 下面仍然以PHP文件读写操作代码实例讲解文件读取方法的具体应用,...
  • txt文件读写

    2019-09-03 11:28:52
    txt文件读写,函数列表: WriteAtLastRow( ) WriteAtIndexRow( ) DeleteRow( ) ReviseRow( ) ReadAtLastRow( ) ReadAtIndexRow( )
  • fopen等文件读写函数

    千次阅读 2019-06-17 19:08:48
    fopen() 函数: FILE *fopen(const char *filename, const char *mode) https://www.runoob.com/cprogramming/c-function-fopen.html fseek() 函数: int fseek(FILE *stream, long int offset, int whence) ...
  • C++文件操作函数-读写文件

    千次阅读 2017-06-10 16:13:09
    文件读写是基础中的基础,关于此类知识的文章非常多,但还是想根据自己的使用心得去总结这么一些内容。 主要内容有:1.文件的打开和关闭;2.文件的读写操作(包括二进制文件的读写也介绍了一些)
  • pb版的文件读写函数,包含对大于32765的文档的读写
  • 文章主要例举一个c语言文件操作常用函数读写文件的代码,感性趣的朋友可以看看。
  • config文件读写函数

    2007-12-10 17:04:13
    config文件读写函数
  • C语言中为文件读写提供了多种函数: 字符读写函数:fgetc和fputc 字符串读写函数:fgets和fputs 数据块读写函数:fread和fwrite 格式化读写函数:fscanf和fprintf 以上函数头文件都是stdio.h。 字符读写函数fgetc和...
  • 主要介绍了Python打开文件、文件读写操作、with方式、文件常用函数,结合实例形式分析了Python文件的打开、读写及常用文件操作函数使用技巧,需要的朋友可以参考下
  • Matlab文件读写函数

    千次阅读 2012-11-29 21:15:32
    Matlab提供多种能够进行文件读写的函数,这些函数是Matlab语言的一部分,并不需要任何额外的工具箱的支持。 文本文件 Matlab中对文件的读写函数可以分为2大类:高级函数和低级函数。简单的说,高级函数的调用...
  • C++ 文件读写函数之——fopen、fread和fwrite

    万次阅读 多人点赞 2015-10-09 20:21:40
    C++文件读写 fopen fread fwrite
  • 内容简单,清晰,适合入门练习INI配置文件读写。 [DllImport("kernel32")] private static extern long WritePrivateProfileString(string section, string key, string val, string filePath); [DllImport(...
  • 常用的C/C++文本文件读写函数

    万次阅读 2015-12-28 22:12:39
    概述 文本文件读写是算法研究和工程应用中常见的功能模块。...对C和C++分开介绍,目的是让大家即能用C++读写文本文件,又能用C读写文本文件。不多不少,恰到好处地掌握好该掌握的读写知识。 C读写

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 434,575
精华内容 173,830
关键字:

文件读写的函数