精华内容
下载资源
问答
  • 2021-02-03 13:30:00

    打开文件

    file_object = open(file_name, access_mode='r', buffering=-1)

    功能:打开一个文件,返回一个文件对象。

    参数:file_name 文件名;

    access_mode 打开文件的方式,如果不写默认为‘r’

    buffering = 1表示有1行缓冲,默认则表示使用系统默认提供的缓冲机制。

    返回值:成功返回文件操作对象。

    操作完成需要使用file_object.close()关闭文件

    with open('file','r+') as f:

    功能:

    打开一个文件,赋值给f。

    with语句块结束后会自动释放f所以不再需要close().

    操作模式

    作用

    r

    以读方式打开,文件必须存在

    w

    以写方式打开,文件不存在则创建,存在清空原有内容

    a

    以追加模式打开,文件不存在则创建,存在则继续进行写操作

    r+

    以读写模式打开 文件必须存在

    w+

    以读写模式打开文件,不存在则创建,存在清空原有内容

    a+

    追加并可读模式,文件不存在则创建,存在则继续进行写操作

    rb

    以二进制读模式打开 同r

    wb

    以二进制写模式打开 同w

    ab

    以二进制追加模式打开 同a

    rb+

    以二进制读写模式打开 同r+

    wb+

    以二进制读写模式打开 同w+

    ab+

    以二进制读写模式打开 同a+

    注意 :

    以二进制方式打开文件,读取内容为字节串,写入也需要写入字节串

    无论什么文件都可以使用二进制方式打开,但是二进制文件则不能以文本方式打开,否则后续读写会报错。

    读取内容的方法

    file_object.read([size])

    file_object.read()

    功能:

    来直接读取文件中字符。

    参数: 如果没有给定size参数(默认值为-1)或者size值为负,文件将被读取直至末尾;给定size最多读取给定数目个字符(字节)。

    返回值: 返回读取到的内容

    file_object.readline([size])

    file_object.readline()

    功能:

    用来读取文件中一行

    参数: 如果没有给定size参数(默认值为-1)或者size值为负,表示读取一行,给定size表示最多读取制定的字符(字节)。

    返回值: 返回读取到的内容

    file_object.readlines([sizeint])

    file_object.readlines()

    功能:

    读取文件中的每一行作为列表中的一项

    参数: 如果没有给定size参数(默认值为-1)或者size值为负,文件将被读取直至末尾,给定size表示读取到size字符所在行为止。

    返回值: 返回读取到的内容列表

    for line in f:

    print(line)

    文件对象本身也是一个可迭代对象,在for循环中可以迭代文件的每一行

    写入文件方法

    方法1

    count = write(data)

    功能:

    把文本数据或二进制数据块的字符串写入到文件中去

    参数(data):要写入的内容

    返回值:写入的字符个数

    方法2

    writelines(str_list)

    功能:

    接受一个字符串列表作为参数,将它们写入文件。

    参数(str_list): 要写入的内容列表

    缓冲区

    说明:

    系统自动的在内存中为每一个正在使用的文件开辟一个空间,在对文件读写时都是先将文件内容加载到缓冲区,再进行读写。

    29102a884957a08540695dbb55e56faf.png

    作用:

    减少和磁盘的交互次数,保护磁盘。

    提高了对文件的读写效率。

    缓冲区设置

    设置参数

    作用

    注意事项

    buffering=-1

    系统自定义

    buffering=1

    行缓冲

    当遇到\n时刷新缓冲

    buffering>1

    指定缓冲区大小

    必须以二进制方式打开

    刷新缓冲区条件:

    缓冲区被写满

    程序执行结束或者文件对象被关闭

    程序中调用flush()函数

    file_obj.flush()

    文件偏移量

    定义:

    打开一个文件进行操作时系统会自动生成一个记录,记录每次读写操作时所处的文件位置,每次文件的读写操作都是从这个位置开始进行的。

    注意:

    r或者w方式打开,文件偏移量在文件开始位置

    a方式打开,文件偏移量在文件结尾位置

    方法:

    tell()

    功能:获取文件偏移量大小

    返回值:文件偏移量

    seek(offset,[whence])

    功能: 移动文件偏移量位置

    参数:offset 代表相对于某个位置移动的字节数。负数表示向前移动,正数表示向后移动。

    whence是基准位置的默认值为 0,代表从文件开头算起,1代表从当前位置算起,2 代表从文件末尾算起。

    注意:必须以二进制方式打开文件时,基准位置才能是1或者2

    更多相关内容
  • Qt txt文件读写

    2018-09-11 22:44:23
    Qt——txt文件选择、读取与写入 - CSDN博客 https://blog.csdn.net/qq_35451572/article/details/82630059
  • DWG文件读写开发库

    2018-12-22 14:04:08
    DWG文件读写开发库,支持c++,C#开发读写DWG文件的相关功能。
  • 基于QT实现XML文件读写,解析操作
  • android文件读写权限

    2013-11-04 14:57:09
    在android开发中,我们经常用到文件读写权限
  • linux C文件读写

    热门讨论 2012-12-27 10:41:40
    linux C文件读写 初学练手代码 内容很简单,就实现简单的文件读写功能
  • 纯 C++ 代码实现的 INI 文件读写类 纯 C++ 代码实现的 INI 文件读写类 纯 C++ 代码实现的 INI 文件读写类 纯 C++ 代码实现的 INI 文件读写类 纯 C++ 代码...
  • 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.字符串读写

    (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);
    }
    

    2.格式化读写

    (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);
        }
    }
    
    展开全文
  • 最好懂的python文件读写(详解)

    万次阅读 多人点赞 2020-02-23 17:13:12
      1、文件读写的流程   2、文件读写的几种常见模式   3、read、readline、readlines的区别   4、对于一个10G的大文件,怎么高效的查看文件中的内容呢? 1、文件读写的流程 1)类比windows中手动操作txt文档...

    目录

      1、文件读写的流程
      2、文件读写的几种常见模式(你不清楚的知识点)
      3、read、readline、readlines的区别
      4、对于一个10G的大文件,怎么高效的查看文件中的内容呢?

    1、文件读写的流程

    1)类比windows中手动操作txt文档,说明python中如何操作txt文件?
    ① windows中手动操作txt文件的步骤
    • 找到word文档
    • 打开word文档
    • 查看(或操作)word文档中的内容
    • 关闭word文档
    ② python操作txt文件的步骤
    • 获取被打开的文件的内存对象,该内存对象又叫做“文件句柄”。
    • 通过这个内存对象(文件句柄),来对文件进行操作(读取,写入等操作)。
    • 关闭文件
    2)什么是文件的内存对象(文件句柄)?

      使用python读取一个txt文件的时候,相当于把这个文件从硬盘上,读取到了内存中。我们如果想要操作这个文件,是不是先要获取这个文件对象?只有获取这个文件对象后,才能够真正的去操作这个文件,不管是读取文件中的内容,还是向文件中写入内容。
      这个“文件句柄”包含了文件的文件名、文件的字符集、文件的大小、文件在硬盘上的起始位置。

    3)演示怎么读取文件
    ① 演示如下
    f = open(r"G:\6Tipdm\file_read_write\yesterday.txt","r",encoding="utf-8")
    data  = f.read()
    print(data[:245])
    f.close()
    

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

    ② 一个很奇怪的现象?
    f = open(r"G:\6Tipdm\file_read_write\yesterday.txt","r",encoding="utf-8")
    data  = f.read()
    data1 = f.read()
    print(data[:245])
    print("-------------------------------------")
    print(data1[:245])
    f.close()
    

    结果如下:
    在这里插入图片描述
    问题:我们读取了2遍内容,为什么只显示了一次读取的结果呢?对于上述问题,我们用一张图回答上述问题。
    在这里插入图片描述
      通过上图我们可以发现,当我们操作这个“文件句柄”的read()方法去读取文件的时候,这个句柄会从文件的开头位置1,移动到文件的结束位置2。如果不做任何操作,读取完毕之后,句柄就会停止在2这个位置。因此当我们再次读取文件的时候,该句柄是从2这个位置,往后面读取内容。由于后面没有任何内容,因此第二次读取为空。
      那么,如果我们想要第二次同样能够读取到文件中的内容,应该怎么办呢?那么接着往下看。

    4)演示怎么写文件
    f = open(r"G:\6Tipdm\file_read_write\yesterday2.txt","w",encoding="utf-8")
    f.write("我爱北京天安门")
    f.close()
    

    结果如下:
    在这里插入图片描述
    假如我们在写一句“天安门上太阳升”,会出现啥情况呢?

    f = open(r"G:\6Tipdm\file_read_write\yesterday2.txt","w",encoding="utf-8")
    f.write("天安门上太阳升")
    f.write("很好,很好")
    f.close()
    

    结果如下:
    在这里插入图片描述
      意外发生。当我们再次写入新的内容的时候,发现之前写的内容不见了,这是为啥呢?这就是我们下面要讲述的“文件读写的几种常见模式”。
      

    2、文件读写的几种常见模式(你不清楚的知识点)

    在这里插入图片描述

    1)关于r+、w+、a+使用说明(易错点)

      当我们读取某个文件,向文件中写入某些内容(覆盖写),向文件中追加写入某写内容时,最好的方式就是分别使用r、w、a这三种模式。对于这三种模式,要么读,要么写,读模式就不能写,写模式就不能读。
      对于r+、w+、a+这三种模式,如果你不是特别清楚python文件读写的原理,就不要轻易使用,因为会出现很多问题,下面我们仅演示r+、w+、a+这三种模式。

    2)r+模式:可读可写

      对于这种模式,不管是读取文件中的内容,还是朝文件中写入内容。前提条件:文件存在。

    # 只读取文件中的内容
    f = open(r"G:\6Tipdm\file_read_write\yesterday1.txt","r+",encoding="utf-8")
    data = f.read()
    print(data)
    f.close()
    
    # 朝文件中写入内容后,立即读取,会出现啥问题?
    f = open(r"G:\6Tipdm\file_read_write\yesterday1.txt","r+",encoding="utf-8")
    f.write("丽丽姑娘")
    
    data = f.read()
    print(data)
    f.close()
    
    # 朝文件中写入内容后,调整句柄位置后,再读取,会出现啥问题?
    f = open(r"G:\6Tipdm\file_read_write\yesterday1.txt","r+",encoding="utf-8")
    f.write("丽丽姑娘")
    f.seek(0)
    data = f.read()
    print(data)
    f.close()
    

    结果如下:
    在这里插入图片描述
    结果分析:
      使用r+模式,当只读文件的时候,可以读取到其中的内容。
      当写入内容后,立即读取文件内容,发现什么也读取不到。这是由于当你写入内容后,文件句柄会放在写入内容的最后面,因此当你立即读取的时候,句柄会从上次内容最后的位置,朝后面读,因此读取为空。
      当朝文件中写入内容后,调整句柄位置后,再读取文件中的内容,发现就有了内容。这是由于我们使用了f.seek(0)方法,将句柄由内容末尾调整到了内容开头,因此就又有了内容。

    3)w+:可读可写
    # 直接往文件中写入内容
    f = open(r"G:\6Tipdm\file_read_write\yesterday3.txt","w+",encoding="utf-8")
    f.write("bbbbbb")
    f.close()
    
    # 直接读取上述文件,看看会发生啥问题?(特别注意这一步)
    f = open(r"G:\6Tipdm\file_read_write\yesterday3.txt","w+",encoding="utf-8")
    data = f.read()
    print(data)
    f.close()
    
    # 朝文件中写入内容后,立即读取,又会发生什么?
    f = open(r"G:\6Tipdm\file_read_write\yesterday3.txt","w+",encoding="utf-8")
    f.write("哈哈哈哈哈")
    data = f.read()
    print(data)
    f.close()
    
    # 朝文件中写入内容后,调整句柄位置后,再读取,会发生什么?
    f = open(r"G:\6Tipdm\file_read_write\yesterday3.txt","w+",encoding="utf-8")
    f.write("嘿嘿嘿嘿嘿")
    f.seek(0)
    data = f.read()
    print(data)
    f.close()
    

    结果如下:
    在这里插入图片描述
    结果分析:
      使用w+模式,当我们直接朝文件中写入bbbbbb,毋庸置疑,肯定是可以的。
      接着,我们直接读取这个文件中的内容,奇怪的现象发生了,什么都读取不到。这是因为w+模式,在进行文件读取的时候,默认是先写再读。但是我们确实没有写入任何东西呀?这是由于系统默认帮我们写入了一个空值,因此把原有内容覆盖了。所以再当我们读取文件中的内容的时候,发现读取为空。
      再接着,我们朝文件中,写入内容后再立即读取,这下仍然读取不到任何内容,这又是为什么呢?这是由于我们第一次写入“哈哈哈哈哈哈”的时候,句柄移动到了内容最后。当我们立即读取的时候,句柄从内容最后的位置,继续朝后面读,因此啥也没有。
      最后,当朝文件中写入内容后,调整句柄位置后,再读取文件中的内容,发现就有了内容。这是由于我们使用了f.seek(0)方法,将句柄由内容末尾调整到了内容开头,因此就又有了内容。

    4)a+:可读可写
    # 直接朝文件中写入内容
    f = open(r"G:\6Tipdm\file_read_write\yesterday4.txt","a+",encoding="utf-8")
    f.write("哈哈")
    f.close()
    
    # 直接读取文件中的内容
    f = open(r"G:\6Tipdm\file_read_write\yesterday4.txt","a+",encoding="utf-8")
    data = f.read()
    print(data)
    f.close()
    
    # 调整句柄位置后,再读取文件中的内容
    f = open(r"G:\6Tipdm\file_read_write\yesterday4.txt","a+",encoding="utf-8")
    f.seek(0)
    data = f.read()
    print(data)
    f.close()
    

    结果如下:
    在这里插入图片描述
    结果分析:
      使用a+模式,朝文件中写入内容,毋庸置疑,肯定是没问题的。
      接着,当我们读取上述文件中的内容,会发现什么也读取不到。这是由于,使用r+模式打开文件,文件句柄默认放在内容的最后面,因此你直接读取其中的内容,什么也没有。
      最后,在读取文件中内容之前,我们使用了f.seek(0)方法,将句柄由内容末尾调整到了内容开头,再次读取文件中的内容,发现就有了内容。

    3、read、readline、readlines的区别

    在这里插入图片描述

    1)read()方法的使用说明
    f = open(r"G:\6Tipdm\file_read_write\test.txt","r",encoding="utf-8")
    data = f.read()
    print(type(data))
    print(data)
    f.close()
    

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

    2)readline()方法的使用说明
    f = open(r"G:\6Tipdm\file_read_write\test.txt","r",encoding="utf-8")
    data = f.readline()
    print(type(data))
    print(data)
    f.close()
    
    f = open(r"G:\6Tipdm\file_read_write\test.txt","r",encoding="utf-8")
    for i in range(3):
        data = f.readline()
        print(data)
    f.close()
    

    结果如下:
    在这里插入图片描述
    去掉每一行末尾的换行符:

    f = open(r"G:\6Tipdm\file_read_write\test.txt","r",encoding="utf-8")
    for i in range(3):
        data = f.readline().strip()
        print(data)
    f.close()
    

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

    3)readlines()方法的使用说明
    f = open(r"G:\6Tipdm\file_read_write\test.txt","r",encoding="utf-8")
    data = f.readlines()
    print(type(data))
    print(data)
    f.close()
    

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

    4、对于一个10G的大文件,怎么高效的查看文件中的内容呢?

    1)相关说明

      当我们读取文件中的内容,相当于是把写在硬盘上的东西,读取到内存中。不管你是使用read()或者readlines()一次性读取到到内存中,还是使用readline()一行行的将整个内容读取到内存中,如果文件很大,都将会耗用很大的内存。同时,从硬盘读取文件内容到内存中,也会很慢。
      因此,有没有一种高效的方式?既让我们看到了文件中的内容,又不会占用内存呢?下面我们将进行说明。

    2)操作说明
    f = open(r"G:\6Tipdm\file_read_write\yesterday.txt","r",encoding="utf-8")
    for line in f:
        print(line.strip())
    

    部分截图如下:
    在这里插入图片描述
    结果说明:
      上述方式中,f相当于一个迭代器,我们使用for循环迭代f中元素。每循环一次,就相当于读取一行到内存中,并记住这一次读取到的位置。当进行下次迭代的时候,上一次读取到内存中的内容,就会被销毁了,当前内存中读取的就是第二行的内容。当进行第三次循环的时候,内存中第二行的内容也会被销毁,此时内存中只会保存第三行的内容,这样依次进行下去。直到最后一次循环,读取最后一行的内容,此时,内存中保留的也只是最后一行的内容。
      迭代器有一个特性:每次进行迭代的时候,就会记住当前读取的位置。当进行下一次迭代的时候,前面的内容会被销毁掉,在内存中只会保留当前循环得到的内容。

    展开全文
  • Android 文件读写最全解析

    万次阅读 多人点赞 2020-04-21 18:08:19
    本文目录文件读写概述读取raw目录文件读取assets目录文件data/data/(包名) 目录文件读写写数据读数据sdcard文件读写申请动态权限写数据读数据完整代码 文件读写概述 raw下的和assert下的文件可以以资源文件的形式...

    推荐阅读:
    Android 通过HttpURLConnection访问Http协议网络
    Android SQlite数据库使用详解
    Android xUtils框架最全使用详解
    Android 动态权限最全解析

    Android文件读写概述

    在这里插入图片描述
    在Androi中文件读写一共有以下目录

    • raw目录
    • asserts目录
    • data/data/包名
    • sdcard目录

    其中raw下的和asserts下的文件可以以资源文件的形式读取,这些目录的数据只能读取,不能写入,两者目录下的文件在打包后会原封不动的保存在apk包中,不会被编译成二进制。
    data/data/包名sdcard目录文件可读可写。其中data/data/包名目录不需要申请权限,sdcard目录需要申请权限

    读取raw目录文件

    Android工程默认是没有raw文件夹的在读文件前我们先把raw 文件夹以及文件建好

    • 点中工程的res目录 右键New -> Directory -> 弹窗中输入raw
    • 点中刚刚新建的raw目录 右键New -> File -> 弹窗中输入test.txt
    • 点开刚刚新建的test.txt文件 ,往里面输入hello world
      在这里插入图片描述
      读数据方法
       InputStream inputStream = null;
       Reader reader = null;
        BufferedReader bufferedReader = null;
        try {
            //得到资源中的Raw数据流
            inputStream = getResources().openRawResource(R.raw.test);
            reader = new InputStreamReader(inputStream);// 字符流
            bufferedReader = new BufferedReader(reader); //缓冲流
            StringBuilder result = new StringBuilder();
            String temp;
            while ((temp = bufferedReader.readLine()) != null) {
                result.append(temp);
            }
            Log.i("MainActivity", "result:" + result);
    
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
        }
    

    从打印的结果中我们可以看出数据读取成功
    在这里插入图片描述

    读取assets目录文件

    Android工程默认是没有assets文件夹的,在读文件前我们先把assets 文件夹以及文件建好

    • 点中工程 右键New -> Folder -> Assets Folder
    • 点中刚刚新建的Assets Folde目录 右键New -> File -> 弹窗中输入test.txt
    • 点开刚刚新建的test.txt文件 ,往里面输入hello world
    • 在这里插入图片描述
      读去assets文件中的数据方法
    		InputStream inputStream = null;
            Reader reader = null;
            BufferedReader bufferedReader = null;
            try {
                //得到资源中的asset数据流
                inputStream = getResources().getAssets().open("test.txt");
                reader = new InputStreamReader(inputStream);// 字符流
                bufferedReader = new BufferedReader(reader); //缓冲流
                StringBuilder result = new StringBuilder();
                String temp;
                while ((temp = bufferedReader.readLine()) != null) {
                    result.append(temp);
                }
                Log.i("MainActivity", "result:" + result);
    
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (bufferedReader != null) {
                    try {
                        bufferedReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
            }
    
    

    从打印的结果中我们可以看出数据读取成功
    在这里插入图片描述

    data/data/(包名) 目录文件读写

    将数据以普通文件的形式保存在 /data/data/包名中,该方法不需要申请权限。
    存放在数据区(/data/data/包名)的文件可以使用openFileOutputopenFileInput进行操作。
    也可以直接指定文件/data/data/包名路径读写。

    该目录存放文件类型规则如下:

    路径功能
    data/data/包名/shared_prefs存放SharedPreferences数据
    data/data/包名/databases存放数据库数据
    data/data/包名/files存放普通数据
    data/data/包名/cache存放缓存文件

    写数据

    方法1:openFileOutput

            FileOutputStream fileOutputStream = null;
            try {
                String text = "hello world";
                fileOutputStream = openFileOutput("test.txt", MODE_PRIVATE);
                fileOutputStream.write(text.getBytes());
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (fileOutputStream != null) {
                    try {
                        fileOutputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    

    openFileOutput方法参数详解

    	@Override
        public FileOutputStream openFileOutput(String name, int mode)
            throws FileNotFoundException {
            
        }
    
    • name 存储文件名字
    • mode 存储方式 其值的含义如下
    参数值参数含义
    Context.MODE_PRIVATE指定该文件数据只能被本应用程序读、写
    Context.MODE_WORLD_READABLE指定该文件数据能被其他应用程序读,但不能写
    Context.MODE_WORLD_WRITEABLE指定该文件数据能被其他应用程序读
    Context.MODE_APPEND该模式会检查文件是否存在,存在就往文件追加内容,否则就创建新文件;

    方法2:传统方法读写

       String text = "hello world";
       File file1=new File("/data/data/com.lucashu.file/","test.txt");
          FileOutputStream fileOutputStream = null;
         try {
             fileOutputStream = new FileOutputStream(file1);
             fileOutputStream.write(text.getBytes());
         } catch (Exception e) {
             e.printStackTrace();
         }finally {
             if (fileOutputStream != null) {
                 try {
                     fileOutputStream.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
    

    执行以后我们可以看到添加了一个文件
    在这里插入图片描述

    读数据

    方法1:openFileInput

    		FileInputStream fileInputStream = null;
            Reader reader = null;
            BufferedReader bufferedReader = null;
            try {
                fileInputStream = openFileInput("test.txt");
                reader = new InputStreamReader(fileInputStream);// 字符流
                bufferedReader = new BufferedReader(reader); //缓冲流
                StringBuilder result = new StringBuilder();
                String temp;
                while ((temp = bufferedReader.readLine()) != null) {
                    result.append(temp);
                }
                Log.i("MainActivity", "result:" + result);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fileInputStream != null) {
                    try {
                        fileInputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (bufferedReader != null) {
                    try {
                        bufferedReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    

    方法2:openFileInput

    		InputStream inputStream = null;
            Reader reader = null;
            BufferedReader bufferedReader = null;
            try {
    
                File file=new File("/data/data/com.lucashu.file/", "test.txt");
                inputStream = new FileInputStream(file);
                reader = new InputStreamReader(inputStream);
                bufferedReader = new BufferedReader(reader);
                StringBuilder result = new StringBuilder();
                String temp;
                while ((temp = bufferedReader.readLine()) != null) {
                    result.append(temp);
                }
                Log.i("MainActivity", "result:" + result);
    
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (bufferedReader != null) {
                    try {
                        bufferedReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
            }
    

    从打印的结果中我们可以看出数据读取成功

    在这里插入图片描述
    我们也可以用一下方法来获取改文件的路径

    getFilesDir();// data/data/包名/files 目录
    getFilesDir().getParent(),;// data/data/包名/ 目录
    

    sdcard文件读写

    sdcard读写的数据将数据保存在 /mnt/sdcard目录,该目录读写需要先申请动态权限,动态权限申请方法如下

    申请动态权限

    Android 动态权限最全解析
    在这里插入图片描述

    首先需要在manifest.xml中添加权限

    <!--文件读写权限-->
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    

    如果是AndroidQ 或者更高的版本还需要在manifest.xml文件中的application节点下加入
    android:requestLegacyExternalStorage="true"
    申请动态权限方法:

    private static final int REQUEST_EXTERNAL_STORAGE = 1;
    private static String[] PERMISSIONS_STORAGE = {"android.permission.READ_EXTERNAL_STORAGE",
                "android.permission.WRITE_EXTERNAL_STORAGE"};
    
    private void checkPermission() {
    //检查权限(NEED_PERMISSION)是否被授权 PackageManager.PERMISSION_GRANTED表示同意授权
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                != PackageManager.PERMISSION_GRANTED) {
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission
                    .WRITE_EXTERNAL_STORAGE)) {
                Toast.makeText(this, "请开通相关权限,否则无法正常使用本应用!", Toast.LENGTH_SHORT).show();
            }
            //申请权限
            ActivityCompat.requestPermissions(this, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
    
        } else {
            Toast.makeText(this, "已授权成功!", Toast.LENGTH_SHORT).show();
            writeSdcard();
    
        }
    }
    

    Activity中动态权限的回调方法

    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           String permissions[], int[] grantResults) {
        switch (requestCode) {
            case REQUEST_EXTERNAL_STORAGE: {
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(this, "授权成功!", Toast.LENGTH_SHORT).show();
                    writeSdcard();
                } else {
                    Toast.makeText(this, "授权被拒绝!", Toast.LENGTH_SHORT).show();
    
    
                }
                return;
            }
    
        }
    }
    
    

    写数据

    private void writeSdcard()  {
            String text = "hello world";
            if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
                if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                    File storage = Environment.getExternalStorageDirectory();
                    File tmepfile = new File(storage.getPath());
                    if (! tmepfile.exists()) {
                        tmepfile.mkdirs();
                    }
                    File file1=new File(tmepfile,"test.txt");
                    if (!file1.exists()){
                        try {
                            file1.createNewFile();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    FileOutputStream fileOutputStream = null;
                    try {
                        fileOutputStream = new FileOutputStream(file1);
                        fileOutputStream.write(text.getBytes());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }finally {
                        if (fileOutputStream != null) {
                            try {
                                fileOutputStream.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    

    执行以后我们可以看到添加了一个文件
    在这里插入图片描述

    读数据

    private void readSdcard() {
            if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
                if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                    InputStream inputStream = null;
                    Reader reader = null;
                    BufferedReader bufferedReader = null;
                    try {
                        File storage = Environment.getExternalStorageDirectory();
                        File tmepfile = new File(storage.getPath());
                        File file=new File(tmepfile, "test.txt");
                        inputStream = new FileInputStream(file);
                        reader = new InputStreamReader(inputStream);
                        bufferedReader = new BufferedReader(reader);
                        StringBuilder result = new StringBuilder();
                        String temp;
                        while ((temp = bufferedReader.readLine()) != null) {
                            result.append(temp);
                        }
                        Log.i("MainActivity", "result:" + result);
    
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        if (reader != null) {
                            try {
                                reader.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        if (inputStream != null) {
                            try {
                                inputStream.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        if (bufferedReader != null) {
                            try {
                                bufferedReader.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
    
                    }
                }
            }
        }
    

    在这里插入图片描述

    sdcard文件读写完整代码

    package com.lucashu.file;
    
    import androidx.appcompat.app.AppCompatActivity;
    import androidx.core.app.ActivityCompat;
    
    import android.Manifest;
    import android.content.pm.PackageManager;
    import android.os.Bundle;
    import android.os.Environment;
    import android.util.Log;
    import android.widget.Toast;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.Reader;
    import java.io.Writer;
    
    public class MainActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            checkPermission();
        }
    
    
        private void writeSdcard()  {
            String text = "hello world";
            if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
                if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                    File storage = Environment.getExternalStorageDirectory();
                    File tmepfile = new File(storage.getPath());
                    if (! tmepfile.exists()) {
                        tmepfile.mkdirs();
                    }
                    File file1=new File(tmepfile,"test.txt");
                    if (!file1.exists()){
                        try {
                            file1.createNewFile();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    FileOutputStream fileOutputStream = null;
                    try {
                        fileOutputStream = new FileOutputStream(file1);
                        fileOutputStream.write(text.getBytes());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }finally {
                        if (fileOutputStream != null) {
                            try {
                                fileOutputStream.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    
    
        private void readSdcard() {
            if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
                if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                    InputStream inputStream = null;
                    Reader reader = null;
                    BufferedReader bufferedReader = null;
                    try {
                        File storage = Environment.getExternalStorageDirectory();
                        File tmepfile = new File(storage.getPath());
                        File file=new File(tmepfile, "test.txt");
                        inputStream = new FileInputStream(file);
                        reader = new InputStreamReader(inputStream);
                        bufferedReader = new BufferedReader(reader);
                        StringBuilder result = new StringBuilder();
                        String temp;
                        while ((temp = bufferedReader.readLine()) != null) {
                            result.append(temp);
                        }
                        Log.i("MainActivity", "result:" + result);
    
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        if (reader != null) {
                            try {
                                reader.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        if (inputStream != null) {
                            try {
                                inputStream.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        if (bufferedReader != null) {
                            try {
                                bufferedReader.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
    
                    }
                }
            }
        }
        private static final int REQUEST_EXTERNAL_STORAGE = 1;
        private static String[] PERMISSIONS_STORAGE = {"android.permission.READ_EXTERNAL_STORAGE",
                "android.permission.WRITE_EXTERNAL_STORAGE"};
    
        private void checkPermission() {
            //检查权限(NEED_PERMISSION)是否被授权 PackageManager.PERMISSION_GRANTED表示同意授权
            if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    != PackageManager.PERMISSION_GRANTED) {
                if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission
                        .WRITE_EXTERNAL_STORAGE)) {
                    Toast.makeText(this, "请开通相关权限,否则无法正常使用本应用!", Toast.LENGTH_SHORT).show();
                }
                //申请权限
                ActivityCompat.requestPermissions(this, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
    
            } else {
                Toast.makeText(this, "已授权成功!", Toast.LENGTH_SHORT).show();
                readSdcard();
    
            }
        }
    
        @Override
        public void onRequestPermissionsResult(int requestCode,
                                               String permissions[], int[] grantResults) {
            switch (requestCode) {
                case REQUEST_EXTERNAL_STORAGE: {
                    if (grantResults.length > 0
                            && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                        Toast.makeText(this, "授权成功!", Toast.LENGTH_SHORT).show();
                        readSdcard();
                    } else {
                        Toast.makeText(this, "授权被拒绝!", Toast.LENGTH_SHORT).show();
    
                    }
                    return;
                }
    
            }
        }
    
    }
    
    

    作者:lucashu
    出处:https://blog.csdn.net/huweiliyi/category_8913738.html
    原创不易,欢迎转载,但未经作者同意请保留此段声明,并在文章页面明显位置给出原文链接。

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

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

    千次阅读 2021-01-13 21:27:01
    Python文件读写一,I/O操作I/O在计算机中是指Input/Output,也就是Stream(流)的输入和输出。这里的输入和输出是相对于内存来说的,Input Stream(输入流)是指数据从外(磁盘、网络)流进内存,Output Stream是数据从...
  • C语言 文件读写的实现

    万次阅读 多人点赞 2019-04-26 11:55:33
    关于C语言的文件读写,我将介绍下面这几种方式: 字符的读写:使用 fgetc() 函数 和 fputc() 函数; 字符串的读写:使用 fgets() 函数和 fputs() 函数; 格式化的读写(主要用于文本文件):使用 ...
  • ;文本文件读写 二进制文件读写 文件的定位与随机读取;定义文件指针 打开文件 读写文件 关闭文件;读写文件;读写文件;读写文件;读写文件;读写文件;读写文件;读写文件;
  • python的文件读写操作

    万次阅读 多人点赞 2019-04-28 08:30:49
    文件读写实现原理与操作步骤 文件打开模式 Python文件操作步骤示例 Python文件读取相关方法 文件读写与字符编码 一、I/O操作概述 I/O在计算机中是指Input/Output,也就是Stream(流)的输入和输出。这里的输入和...
  • VC++ 多线程文件读写操作实例

    热门讨论 2011-11-01 21:20:04
    VC++环境下编写的一个多线程文件读写操作的实例。简单的利用互斥变量、原子操作等技术实现多线程读写文件时的互斥,从而确保文件在操作过程中不会被破坏。例子并没有使用很多复杂的逻辑。适合刚接触多线程编程的新手...
  • 读写文件是最常见的操作之一,Python内置了open()函数,用于对文件进行读写操作。每当我们用open方法打开一个文件时,将返回一个文件对象。
  • linux下文件读写

    万次阅读 2019-06-23 10:25:26
    linux 下一切皆文件 文件读写 文件的打开open函数 涉及头文件: ubuntu 头文件所在目录:/usr/include/x86_64-linux-gnu/sys #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> ...
  • C语言 二进制文件读写实例讲解

    千次阅读 2021-03-22 19:48:37
    因此本文将结合一个具体的例子来介绍C语言中的二进制文件读写,这也是我自我学习的一个记录。 一、函数介绍 在本例中,我们尝试在一个文件中写入10个字节的数据,其中每个字节均为0xFF,然后我们再将数据读取出来...
  • C++文件读写操作

    千次阅读 2021-02-05 10:34:07
    C++文件操作C++文件操作C++文件操作 60.C++文件操作-文本文件-写文件 61.C++文件操作-文本文件-读文件 62.C++文件操作-二进制文件-写文件 63.C++文件操作-二进制文件-读文件 60.C++文件操作-文本文件-写文件 61....
  • C语言-文件读写操作

    千次阅读 2019-04-19 11:35:01
    即当读写一个文件时,可以不必关心文件的格式或结构。 2、文本文件和二进制文件: 计算机文件的存储,物理上都是二进制,所以文本文件与二进制文件的区别并不是物理上的, 而是逻辑上的。这两者只是在编码层次上有...
  • Linux下的文件读写

    千次阅读 2019-04-01 10:07:40
    应用程序(打开文件)-》各种库(标准库fopen)-》系统调用(open)-》内核(驱动)-》硬件(磁盘)。 系统调用:内核提供给外界访问的接口函数,调用这些函数将使进程进入内核态。 1、UNIX、Linux大部的系统...
  • Qt 二进制文件读写

    千次阅读 2021-02-25 21:39:28
    Qt 使用 QFile 和 QDataStream 进行二进制数据文件读写: QFile 负责文件的 IO 设备接口,即与文件的物理交互; QDataStream 以数据流的方式读取文件内容或写入文件内容。 QDataStream 保存文件时使用的数据编码...
  • fstream —文件读写操作

    千次阅读 2020-05-18 18:25:53
    1、文件读写的三种类型 ifstream:从一个给定文件中读取数据 。 ofstream:向一个给定的文件中写入数据 fstream:可以读写给定的文件。 它可以用IO库中的<<、>>、getline()等方式来读写文件。其中...
  • 用python进行文件读写

    千次阅读 2022-01-21 15:55:05
    1、读文件 打开文件-->读取文件-->关闭文件 file1 = open(r'C...as file1: #with open('文件地址','读写模式') as 变量名: #格式:冒号不能丢 file1.write('微尘') #格式:对文件的操作要缩进 #格式:无需用close()关闭
  • Linux监控文件读写

    千次阅读 2019-07-25 17:18:34
    如何去监测目标文件, 我思考了很久仍没有头绪,翻了翻开发大赛入围名单, 发现马艺诚同学使用了hook方法来监测进程操作目标文件。于是下午试了试, 确实可行(毕竟人家已经做出来了嘛)。下面讲解一下我下午尝试的...
  • 查看文件权限的语句:  在终端输入:ls -l xxx.xxx (xxx.xxx是文件名)  那么就会出现相类似的信息,主要都是这些:-rw-rw-r--  一共有10位数
  • QtXlsx读写excel文件

    2019-10-14 09:33:42
    QtXlsx读写excel文件库,可以对excel文件进行读写,很方便各位开发者去操作excel文件,有兴趣的可以下载进行学习和研究。
  • C++对文本文件读写方法

    千次阅读 2021-11-13 17:38:05
    1、创建流对象,打开文件 void open( const char *filename ); void open( const char *filename, openmode mode ); filename 文件名 mode:打开模式 ios::app 添加输出 ios::ate 当已打开时寻找到EOF ...
  • C++ 文件读写相关函数

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,067,460
精华内容 426,984
关键字:

文件读写