文件操作_文件操作类 - CSDN
精华内容
参与话题
  • C语言详解 FILE文件操作

    万次阅读 多人点赞 2019-12-23 13:17:11
    进行C语言文件的存取时,都会先进行“打开文件操作,这个操作就是在打开数据流,而“关闭文件操作就是关闭数据流。 1.2 缓冲区(Buffer): 指在程序执行时,所提供的额外内存,可用来暂时存放做准备执行的数据...

    1. 需要了解的概念

    需要理解的知识点包括:数据流、缓冲区、文件类型、文件存取方式
     

    1.1 数据流:

    指程序与数据的交互是以流的形式进行的。进行C语言文件的存取时,都会先进行“打开文件”操作,这个操作就是在打开数据流,而“关闭文件”操作就是关闭数据流。

    1.2 缓冲区(Buffer):

    指在程序执行时,所提供的额外内存,可用来暂时存放做准备执行的数据。它的设置是为了提高存取效率,因为内存的存取速度比磁盘驱动器快得多。

     C语言中带缓冲区的文件处理:

    C语言的文件处理功能依据系统是否设置“缓冲区”分为两种:一种是设置缓冲区,另一种是不设置缓冲区。由于不设置缓冲区的文件处理方式,必须使用较低级的I/O函数(包含在头文件io.h和fcntl.h中)来直接对磁盘存取,这种方式的存取速度慢,并且由于不是C的标准函数,跨平台操作时容易出问题。下面只介绍第一种处理方式,即设置缓冲区的文件处理方式:

    当使用标准I/O函数(包含在头文件stdio.h中)时,系统会自动设置缓冲区,并通过数据流来读写文件。当进行文件读取时,不会直接对磁盘进行读取,而是先打开数据流,将磁盘上的文件信息拷贝到缓冲区内,然后程序再从缓冲区中读取所需数据,如下图所示:

    事实上,当写入文件时,并不会马上写入磁盘中,而是先写入缓冲区,只有在缓冲区已满或“关闭文件”时,才会将数据写入磁盘,如下图所示。


    1.3 文件类型:

    分为文本文件和二进制文件两种。

    文本文件是以字符编码的方式进行保存的。二进制文件将内存中数据原封不至文件中,适用于非字符为主的数据。如果以记事本打开,只会看到一堆乱码。

    其实,除了文本文件外,所有的数据都可以算是二进制文件。二进制文件的优点在于存取速度快,占用空间小,以及可随机存取数据。
     

    1.4 文件存取方式:

    包括顺序存取方式和随机存取方式两种。

    顺序读取也就是从上往下,一笔一笔读取文件的内容。保存数据时,将数据附加在文件的末尾。这种存取方式常用于文本文件,而被存取的文件则称为顺序文件。

    随机存取方式多半以二进制文件为主。它会以一个完整的单位来进行数据的读取和写入,通常以结构为单位。


    2. 文本文件操作

    C语言中主要通过标准I/O函数来对文本文件进行处理。相关的操作包括打开、读写、关闭与设置缓冲区。
    相关的存取函数有:fopen(), fclose(), fgetc(), fputc(), fgets(), fputs(), fprintf(), fscanf()等。
     

    2.1 打开文件

    函数原型为:_CRTIMP FILE * __cdecl fopen(const char *, const char *);

    第一参数为文件名,第二个参数为打开模式。

    打开成功,fopen返回一个结构指针地址,否则返回一个NULL。如果没有指定文件路径,则默认为当前工作目录。如:

    FILE *fp;
    fp = fopen("c:\\temp\\test.txt", "r") //由于反斜杠\是控制字符,所以必须再加一个反斜杠

     

    使用fopen()函数打开的文件会先将文件复制到缓冲区。注意:所下达的读取或写入动作,都是针对缓冲区进行存取而不是磁盘,只有当使用fclose()函数关闭文件时,缓冲区中的数据才会写入磁盘。
     

      谈文件打开模式

    打开文本文件:

    "r":只能从文件中读数据,该文件必须先存在,否则打开失败
    "w":只能向文件写数据,若指定的文件不存在则创建它,如果存在则先删除它再重建一个新文件
    "a":向文件增加新数据(不删除原有数据),若文件不存在则打开失败,打开时位置指针移到文件末尾
    "r+":可读/写数据,该文件必须先存在,否则打开失败
    "w+":可读/写数据,用该模式打开新建一个文件,先向该文件写数据,然后可读取该文件中的数据
    "a+":可读/写数据,原来的文件不被删去,位置指针移到文件末尾

    打开二进制文件的模式与打开文本文件的含义是一样的,不同的是模式名称里面多一个字母'b’,以表示以二进制形式打开文件。
     

    2.2 关闭文件

    函数原型为:_CRTIMP int __cdecl fclose(FILE *);

    关闭成功返回值0,否则返回非零值。

    注:在执行完文件的操作后,要进行“关闭文件”操作。虽然程序在结束前会自动关闭所有的打开文件,但文件打开过多会导致系统运行缓慢,这时就要自行手动关闭不再使用的文件,来提高系统整体的执行效率。

     

    例1. 打开文件并进行判断和关闭文件

     

    FILE *fp;
    fp = fopen("c:\\temp\\test.txt", "r");

    if(fp == NULL)
        printf("fail to open the file! \n");
    else
    {
        printf("The file is open! \n");
        fclose(fp);
    }

     

     

    2.3 字符存取函数

    函数原型为:

    _CRTIMP int __cdecl fputc(int, FILE *);
    _CRTIMP int __cdecl fgetc(FILE *);

    字符读取函数fgetc()可从文件数据流中一次读取一个字符,然后读取光标移动到下一个字符,并逐步将文件的内容读出。

    如果字符读取成功,则返回所读取的字符,否则返回EOF(end of file)。EOF是表示数据结尾的常量,真值为-1。另外,要判断文件是否读取完毕,可利用feof()进行检查。未完返回0,已完返回非零值。

    feof()函数原型为:_CRTIMP int __cdecl feof(FILE *);

    例2. fgetc()函数的使用

    版本1:利用feof()函数检查文件是否读取完毕

     

    #include <stdio.h>

    main()
    {
        FILE *fp;
        fp = fopen("c:\\temp\\test.txt", "r");
        if(fp != NULL)
        {
            while(!feof(fp))
                printf("%c", fgetc(fp));
        }
        else
            printf("fail to open! \n");
        fclose(fp);

        return 0;
    }

     


    版本2:利用文件结束标志EOF(即-1)

     

    #include <stdio.h>

    main()
    {
        char ch;
        FILE *fp;
        fp = fopen("c:\\temp\\test.txt", "r");
        if(fp != NULL)
        {
            ch = fgetc(fp);
            while(ch != EOF)
            {
                putchar(ch);
                ch = fgetc(fp);
            }

        }
        else
            printf("fail to open! \n");
        fclose(fp);

        return 0;
    }

     


    版本3 - 重构版本2

     

    #include <stdio.h>

    main()
    {
        char ch;
        FILE *fp;
        if((fp = fopen("test.txt", "r")) != NULL)
            while((ch = fgetc(fp)) != EOF)
                putchar(ch);
        else
            printf("fail to open! \n");
        fclose(fp);

        return 0;
    }

     


    版本4 - 重构版本3 (不正确的重构)

     

    #include <stdio.h>

    main()
    {
        FILE *fp;
        if((fp = fopen("test.txt", "r")) != NULL)
            while(fgetc(fp) != EOF)
                putchar(fgetc(fp));
        else
            printf("fail to open! \n");
        fclose(fp);

        return 0;
    }

     



    若要将字符逐一写入文件,用fputc()函数。示例为:

    例3. fputc()函数的使用

     

    #include <stdio.h>
    #include <conio.h>

    main()
    {
        char filename[20], ch;
        FILE *fp;
        printf("Enter a filename: ");
        scanf("%s", filename);
        printf("Enter some characters to output to file: ");
        if((fp = fopen(filename, "w")) == NULL)
            printf("fail to open! \n");
        else
        {
            while((ch = getche()) != '\015')
                fputc(ch, fp);
        }
        fclose(fp);

        return 0;
    }

     


     

    2.4 字符串存取函数

    函数原型为:

    _CRTIMP int __cdecl fputs(const char *, FILE *);
    _CRTIMP char * __cdecl fgets(char *, int, FILE *);

    fgets函数的作用是从指定文件读入一个字符串,如:fgets(str, n, fp);

    参数n为要求得到的字符个数,但只从fp指向的文件输入n-1个字符,然后在最后加一个'\0'字符,因此得到的字符串共有n个字符,把它们放在字符数组str中。如果在读完n-1个字符之前遇到换行符或EOF,读入结束。

    fputs函数的作用是向指定文件输出一个字符串,如:fputs("Hey", fp);

    把字符串"Hey"输出到fp指向的文件。fputs函数的第一个参数可以是字符串常量、字符数组名或字符型指针。若输出成功,则返回0,否则返回EOF。

    实例略

     

    2.5 格式化存取函数

    函数原型为:

    _CRTIMP int __cdecl fprintf(FILE *, const char *, ...);
    _CRTIMP int __cdecl fscanf(FILE *, const char *, ...);

    它们与printf和scanf函数相仿,都是格式化读写函数。不同的是:fprintf和fscanf函数的读写对象不是终端(标准输入输出),而是磁盘文件。printf函数是将内容输出到终端(屏幕),因此,fprintf就是将内容输出到磁盘文件了。

    实例4. fprintf和fscanf函数的使用

     

    #include <stdio.h>

    void main()
    {
        FILE *fp;

        int num = 10;
        char name[10] = "Leeming";
        char gender = 'M';

        if((fp = fopen("info.txt", "w+")) == NULL)
            printf("can't open the file! \n");
        else
            fprintf(fp, "%d, %s, %c", num, name, gender); //将数据格式化输出到文件info.txt中

        fscanf(fp, "%d, %s, %c", &num, name, &gender); //从文件info.txt中格式化读取数据
        printf("%d, %s, %c \n", num, name, gender); //格式化输出到屏幕

        fclose(fp);
    }

     


     

    2.6 指针重返函数

    函数原型为:

    _CRTIMP void __cdecl rewind(FILE *);;

    rewind函数的作用是使位置指针重返回文件的开头,属于文件的定位。

     

    3. 二进制文件操作

    3.1 数据块存取函数

    函数原型:

    _CRTIMP size_t __cdecl fread(void *, size_t, size_t, FILE *);
    _CRTIMP size_t __cdecl fwrite(const void *, size_t, size_t, FILE *);

    当要求一次存取一组数据(如,一个数组、一个结构体变量的值),fread和fwrite函数可以解决该类问题。它们的调用形式一般为:

    fread(buffer, size, count, fp);
    fwrite(buffer, size, count, fp);

    buffer:对于fread来说,指的是读入数据的存放地址;对于fwrite来说,是要输出数据的地址。
    size:读写数据时,每笔数据的大小
    count:读写数据的笔数
    fp:文件指针
     

    实例5. fread和fwrite函数的使用

     

    #include <stdio.h>
    #define SIZE 3

    typedef enum { MM, GG } Gender;

    typedef struct
    {
        char name[10];
        int  age;
        Gender gender;
    } Person;

    void write2file(Person emp[SIZE])
    {
        FILE *fp;
        if((fp = fopen("emp.txt", "wb")) == NULL)
        {
            printf("cannot open file! \n");
            return;
        }

        for(int i=0; i<SIZE; i++)
            if(fwrite(&emp[i], sizeof(Person), 1, fp) != 1)
                printf("file write error! \n");
        fclose(fp);
    }

    void read_from_file(FILE *fp)
    {
        Person emp_out[SIZE];

        if((fp = fopen("emp.txt", "rb")) == NULL)
        {
            printf("cannot open file! \n");
            return;
        }

        printf("\n%d employee's information read: \n", SIZE);

        for(int i=0; i<SIZE; i++)
        {
            if(fread(&emp_out[i], sizeof(Person), 1, fp) != 1)
                if(feof(fp))
                {
                    fclose(fp);
                    return;
                }
                printf("%-5s %4d %5d \n", emp_out[i].name, emp_out[i].age, emp_out[i].gender);
        }
        fclose(fp);
    }

    void main()
    {
        FILE *fp = NULL;
        Person employee[SIZE];

        printf("Enter %d employee's information: \n", SIZE);
        for(int i=0; i<SIZE; i++)
            scanf("%s %d %d", employee[i].name, &employee[i].age, &employee[i].gender);

        write2file(employee);

        read_from_file(fp);
    }

     


     

    3.2 随机存取函数fseek()

    函数原型:

    _CRTIMP int __cdecl fseek(FILE *, long, int);

    对流式文件可以进行顺序读写,也可以进行随机读写。关键在于控制文件的位置指针,如果位置指针是按字节位置顺序移动的,就是顺序读写。如果能将位置指针按需要移动到任意位置,就可以实现随机读写。所谓随机读写,是指读完上一个字符(字节)后,并不一定要读写其后续的字符(字节),而可以读写文件中任意位置上所需要的字符(字节)。该函数的调用形式为:

    fseek(fp, offset, start);

    start:起始点。用0、1、2代替。0代表文件开始,名字为SEEK_SET,1代表当前位置,名字为SEEK_CUR,2代表文件末尾,名字为SEEK_END。

    fseek()函数一般用于二进制文件,因为文本文件要发生字符转换,计算位置时往往会发生混乱。

    调用实例如:

    fseek(fp, i*sizeof(Person), 0);

     

    https://blog.csdn.net/yong_sun/article/details/8921061

    展开全文
  • 文件操作

    2019-07-24 14:12:44
    文件操作 读取文件(开 - 读 - 关) file1 = open('/Users/Ted/Desktop/test/abc.txt',mode='r',encoding='utf-8') open()函数里面有三个参数: ①第一个参数是文件的保存地址,一定要写清楚,否则计算机找不到。 ...

    文件操作

    读取文件(开 - 读 - 关)

    file1 = open('/Users/Ted/Desktop/test/abc.txt',mode='r',encoding='utf-8') 

    open()函数里面有三个参数:

    ①第一个参数是文件的保存地址,一定要写清楚,否则计算机找不到。

    绝对路径和相对路径

    绝对路径就是最完整的路径,相对路径指的就是【相对于当前文件夹】的路径

    Windows系统里,常用\来表示绝对路径,/来表示相对路径

    \在Python中是转义字符,所以时常会有冲突。为了避坑,Windows的绝对路径通常要稍作处理,可以写成以下两种方式:

    open('C:\\Users\\Ted\\Desktop\\test\\abc.txt')
    #将'\'替换成'\\'
    
    open(r'C:\Users\Ted\Desktop\test\abc.txt')
    #在路径前加上字母r

    ②第二个参数表示打开文件时的模式。这里是字符串 'r',表示 read。

    ③第三个参数encoding='utf-8',表示的是返回的数据采用何种编码,一般采用utf-8或者gbk。

    file1 = open('/Users/Ted/Desktop/test/abc.txt','r',encoding='utf-8') 
    filecontent = file1.read()            
    print(filecontent)
    file1.close()  
    read()可以指定我们想要读取的内容数量

    1729998-20190715185945372-394719602.png

    写入文件(开 - 写 - 关)

    file1 = open('/Users/Ted/Desktop/test/abc.txt','w',encoding='utf-8') 

    以写入的模式打开了文件"abc.txt"。

    open() 中还是三个参数,其他都一样,除了要把第二个参数改成'w',表示write,即以写入的模式打开文件。

    'w'写入模式会给你暴力清空掉文件,然后再给你写入。如果你只想增加东西,而不想完全覆盖掉原文件的话,就要使用'a'模式,表示append,你学过,它是追加的意思。

    f1 = open('./1.txt','a',encoding='utf-8') 
    #以追加的方式打开一个文件,尽管并不存在这个文件,但这行代码已经创建了一个txt文件了
    f1.write('难念的经')
    #写入'难念的经'的字符串
    f1.close()           
    #关闭文件 
    
    f2 = open('./1.txt','r',encoding='utf-8')
    #以读的方式打开这个文件
    content = f2.read()
    #把读取到的内容放在变量content里面
    print(content)
    #打印变量content
    f2.close()
    #关闭文件
    
    #结果:
    难念的经

    1729998-20190715190002743-295193263.png

    'wb'的模式,它的意思是以二进制的方式打开一个文件用于写入。因为图片和音频是以二进制的形式保存的

    补充内容

    with open as f

    为了避免打开文件后忘记关闭,占用资源或当不能确定关闭文件的恰当时机的时候,我们可以用到关键字with,之前的例子可以写成这样:

    # 普通写法
    file1 = open('abc.txt','a') 
    file1.write('张无忌') 
    file1.close()
    
    # 使用with关键字的写法
    with open('abc.txt','a') as file1:
    #with open('文件地址','读写模式') as 变量名:
        #格式:冒号不能丢
        file1.write('张无忌') 
        #格式:对文件的操作要缩进
        #格式:无需用close()关闭

    readline()

    readline()读取每次只读取一行,注意点:readline()读取出来的数据在后面都有一个\n

    f = open('path1/小娃娃.txt',mode='r',encoding='utf-8')
    msg1 = f.readline()
    msg2 = f.readline()
    msg3 = f.readline()
    msg4 = f.readline()
    f.close()
    print(msg1)
    print(msg2)
    print(msg3)
    print(msg4)
    
    结果:
    高圆圆
    
    刘亦菲
    
    张柏芝
    
    杨紫

    结果这里每个一内容中间都有一个空行是因为咱们读取的内容后边都带有一个\n print()的时候会将这个\n执行

    f = open('path1/小娃娃.txt',mode='r',encoding='utf-8')
    msg1 = f.readline().strip()
    msg2 = f.readline().strip()
    msg3 = f.readline().strip()
    msg4 = f.readline().strip()
    f.close()
    print(msg1)
    print(msg2)
    print(msg3)
    print(msg4)
    
    结果:
    高圆圆
    刘亦菲
    张柏芝
    杨紫

    readlines()

    readlines() 将每一行形成一个元素,放到一个列表中,将所以的内容全部读出来,如果文件很大,占内存,容易崩盘。

    f = open('log',encoding='utf-8')
    print(f.readlines())
    f.close()
    # 结果['666666\n', 'fkja l;\n', 'fdkslfaj\n', 'dfsflj\n', 'df;asdlf\n', '\n', ]

    较大的文件读取我们不推介这种方法,推介下面写法:

    f = open('../path1/弟子规',mode='r',encoding='utf-8')
    for line in f:
        print(line)      #这种方式就是在一行一行的进行读取

    其他操作

    seek()

    seek操作:seek(n)光标移动到n位置,注意: 移动单位是byte,所有如果是utf-8的中文部分要是3的倍数

    seek(0,0)默认为0,移动到文件头

    seek(0,1)移动到当前位置

    seek(0,2)移动到文件尾

    f = open("小娃娃", mode="r+", encoding="utf-8")
    f.seek(0) # 光标移动到开头
    content = f.read() # 读取内容, 此时光标移动到结尾
    print(content)
    f.seek(0) # 再次将光标移动到开头
    f.seek(0, 2) # 将光标移动到结尾
    content2 = f.read() # 读取内容. 什么都没有
    print(content2)
    f.seek(0) # 移动到开头
    f.write("张国荣") # 写入信息. 此时光标在9 中文3 * 3个 = 9
    f.flush()
    f.close() 
    tell()

    tell()

    使用tell()可以帮我们获取当前光标在什么位置

    f = open("小娃娃", mode="r+", encoding="utf-8")
    f.seek(0) # 光标移动到开头
    content = f.read() # 读取内容, 此时光标移动到结尾
    print(content)
    f.seek(0) # 再次将光标移动到开头
    f.seek(0, 2) # 将光标移动到结尾
    content2 = f.read() # 读取内容. 什么都没有
    print(content2)
    f.seek(0) # 移动到开头
    f.write("张国荣") # 写入信息. 此时光标在9 中⽂文3 * 3个 = 9
    print(f.tell()) # 光标位置9
    f.flush()
    f.close()

    修改文件

    文件修改: 只能将文件中的内容读取到内存中, 将信息修改完毕, 然后将源文件删除, 将新文件的名字改成老文件的名字.

    import os
    with open("../path1/小娃娃", mode="r", encoding="utf-8") as f1,\
    open("../path1/小娃娃_new", mode="w", encoding="UTF-8") as f2:
        content = f1.read()
        new_content = content.replace("冰糖葫芦", "⼤白梨")
        f2.write(new_content)
    os.remove("../path1/小娃娃") # 删除源文件
    os.rename("../path1/小娃娃_new", "小娃娃") # 重命名新文件

    弊端: ⼀次将所有内容进行读取. 内存溢出. 解决方案: 一行一行的读取和操作

    import os
    with open("小娃娃", mode="r", encoding="utf-8") as f1,\
    open("小娃娃_new", mode="w", encoding="UTF-8") as f2:
        for line in f1:
            new_line = line.replace("大白梨", "冰糖葫芦")
            f2.write(new_line)
    os.remove("小娃娃") # 删除源⽂文件
    os.rename("小娃娃_new", "小娃娃") # 重命名新文件

    转载于:https://www.cnblogs.com/lifangzheng/p/11190765.html

    展开全文
  • 文件的基本操作总结

    2017-11-25 21:27:56
    C语言文件操作 一、标准文件的读写 1.文件的打开 fopen() 文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区,并将该结构的指针返回给用户程序,以后用户程序就可用此FILE指针来实现对指定文件的...

    C语言文件操作

    一、标准文件的读写

    1.文件的打开

    fopen() 文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区,并将该结构的指针返回给用户程序,以后用户程序就可用此FILE指针来实现对指定文件的存取操作了。当使用打开函数时,必须给出文件名、文件操作方式(读、写或读写),如果该文件名不存在,就意味着建立(只对写文件而言,对读文件则出错),并将文件指针指向文件开头。若已有一个同名文件存在,则删除该文件,若无同名文件,则建立该文件,并将文件指针指向文件开头。

    fopen(char *filename,char *type);

    其中*filename是要打开文件的文件名指针,一般用双引号括起来的文件名表示,也可使用双反斜杠隔开的路径名。而*type参数表示了对打开文件的操作方式。其可采用的操作方式如下: 方式 含义 "r" 打开,只读; "w" 打开,文件指针指到头,只写; "a" 打开,指向文件尾,在已存在文件中追加; "rb" 打开一个二进制文件,只读; "wb" 打开一个二进制文件,只写; "ab" 打开一个二进制文件,进行追加 ;"r+" 以读/写方式打开一个已存在的文件; "w+" 以读/写方式建立一个新的文本文件 ;"a+" 以读/写方式打开一个文件文件进行追加 ;"rb+" 以读/写方式打开一个二进制文件; "wb+" 以读/写方式建立一个新的二进制文件 ;"ab+" 以读/写方式打开一个二进制文件进行追加 ;当用fopen()成功的打开一个文件时,该函数将返回一个FILE指针,如果文件打开失败,将返回一个NULL指针。如想打开test文件,进行写:


        FILE *fp;  
        if((fp=fopen("test","w"))==NULL) {  
            printf("File cannot be opened/n");  
            exit();  
        }  
        else  
            printf("File opened for writing/n");  
        ……  
        fclose(fp);   

    DOS操作系统对同时打开的文件数目是有限制的,缺省值为5,可以通过修改CONFIG.SYS文件改变这个设置。

    2.关闭文件函数fclose()

    文件操作完成后,必须要用fclose()函数进行关闭,这是因为对打开的文件进行写入时,若文件缓冲区的空间未被写入的内容填满,这些内容不会写到打开的文件中去而丢失。只有对打开的文件进行关闭操作时,停留在文件缓冲区的内容才能写到该文件中去,从而使文件完整。再者一旦关闭了文件,该文件对应的FILE结构将被释放,从而使关闭的文件得到保护,因为这时对该文件的存取操作将不会进行。文件的关闭也意味着释放了该文件的缓冲区。

    int fclose(FILE *stream); 

    它表示该函数将关闭FILE指针对应的文件,并返回一个整数值。若成功地关闭了文件,则返回一个0值,否则返回一个非0值。常用以下方法进行测试:


    1.     if(fclose(fp)!=0) {  
              printf("File cannot be closed/n");   
              exit(1);   
          }   
          else  
              printf("File is now closed/n");   


    当打开多个文件进行操作,而又要同时关闭时,可采用fcloseall()函数,它将关闭所有在程序中打开的文件。 int fcloseall(); 该函数将关闭所有已打开的文件,将各文件缓冲区未装满的内容写到相应的文件中去,接着释放这些缓冲区,并返回关闭文件的数目。如关闭了4个文件,则当执行: n=fcloseall(); 时,n应为4。

    3.文件的读写

    (1).读写文件中字符的函数(一次只读写文件中的一个字符):

    int fgetc(FILE *stream);

    int getchar(void);

    int fputc(int ch,FILE *stream);

    int putchar(int ch);

    int getc(FILE *stream);

    int putc(int ch,FILE *stream);

    其中fgetc()函数将把由流指针指向的文件中的一个字符读出,例如: ch=fgetc(fp); 将把流指针fp指向的文件中的一个字符读出,并赋给ch,当执行fgetc()函数时,若当时文件指针指到文件尾,即遇到文件结束标志EOF(其对应值为-1),该函数返回一个-1给ch,在程序中常用检查该函数返回值是否为-1来判断是否已读到文件尾,从而决定是否继续。

    1. #include "stdio.h"   
    2. #include <stdlib.h>  
    3. int main() {   
    4.     FILE *fp;   
    5.     char ch;  
    6.     if((fp=fopen("myfile.txt","r"))==NULL) {  
    7.         printf("file cannot be opened/n");   
    8.         exit(1);   
    9.     }   
    10.     while((ch=fgetc(fp))!=EOF)   
    11.         fputc(ch,stdout);   
    12.     fclose(fp);   
    13. }   

    该程序以只读方式打开myfile.txt文件,在执行while循环时,文件指针每循环一次后移一个字符位置。用fgetc()函数将文件指针指定的字符读到ch变量中,然后用fputc()函数在屏幕上显示,当读到文件结束标志EOF时,关闭该文件。 上面的程序用到了fputc()函数,该函数将字符变量ch的值写到流指针指定的文件中去,由于流指针用的是标准输出(显示器)的FILE指针stdout,故读出的字符将在显示器上显示。又比如: fputc(ch,fp); 该函数执行结构,将把ch表示的字符送到流指针fp指向的文件中去。 在TC中,putc()等价于fputc(),getc()等价于fgetc()。 putchar(c)相当于fputc(c,stdout);getchar()相当于fgetc(stdin)。 注意,这里使用char ch,其实是不科学的,因为最后判断结束标志时,是看ch!=EOF,而EOF的值为-1,这显然和char是不能比较的。所以,某些使用,我们都定义成int ch。

    (2).读写文件中字符串的函数

    char *fgets(char *string,int n,FILE *stream);

    char *gets(char *s);

    int fprintf(FILE *stream,char *format,variable-list);

    int fputs(char *string,FILE *stream);

    int fscanf(FILE *stream,char *format,variable-list);

    其中fgets()函数将把由流指针指定的文件中n-1个字符,读到由指针string指向的字符数组中去,例如: fgets(buffer,9,fp); 将把fp指向的文件中的8个字符读到buffer内存区,buffer可以是定义的字符数组,也可以是动态分配的内存区。 注意,fgets()函数读到'/n'就停止,而不管是否达到数目要求。同时在读取字符串的最后加上'/0'。 fgets()函数执行完以后,返回一个指向该串的指针。如果读到文件尾或出错,则均返回一个空指针NULL,所以长用feof()函数来测定是否到了文件尾或者是ferror()函数来测试是否出错,例如下面的程序用fgets()函数读test.txt文件中的第一行并显示出来:

    1. #include "stdio.h"   
    2. int main() {  
    3.     FILE *fp;   
    4.     char str[128];   
    5.     if((fp=fopen("test.txt","r"))==NULL) {  
    6.         printf("cannot open file/n"); exit(1);  
    7.     }   
    8.     while(!feof(fp)) {  
    9.         if(fgets(str,128,fp)!=NULL)  
    10.         printf("%s",str);  
    11.     }  
    12.     fclose(fp);  
    13. }   

    gets()函数执行时,只要未遇到换行符或文件结束标志,将一直读下去。因此读到什么时候为止,需要用户进行控制,否则可能造成存储区的溢出。 fputs()函数想指定文件写入一个由string指向的字符串,'/0'不写入文件。 fprintf()和fscanf()同printf()和scanf()函数类似,不同之处就是printf()函数是想显示器输出,fprintf()则是向流指针指向的文件输出;fscanf()是从文件输入。 下面程序是向文件test.dat里输入一些字符:

    1. #include <stdio.h>  
    2. #include <stdlib.h>  
    3. int main() {  
    4.     char *s="That's good news";   
    5.     int i=617;   
    6.     FILE *fp;  
    7.     fp=fopen("test.dat""w"); /*建立一个文字文件只写*/   
    8.     fputs("Your score of TOEFL is",fp); /*向所建文件写入一串字符*/   
    9.     fputc(':', fp); /*向所建文件写冒号:*/   
    10.     fprintf(fp, "%d/n", i); /*向所建文件写一整型数*/   
    11.     fprintf(fp, "%s", s); /*向所建文件写一字符串*/   
    12.     fclose(fp);  
    13. }   

    用DOS的TYPE命令显示TEST.DAT的内容如下所示: 屏幕显示 Your score of TOEFL is: 617 That's good news 下面的程序是把上面的文件test.dat里的内容在屏幕上显示出来:

    1. #include <stdio.h>  
    2. int main() {  
    3.     char s[24], m[20];   
    4.     int i;  
    5.     FILE *fp;  
    6.     fp=fopen("test.dat""r"); /*打开文字文件只读*/  
    7.     fgets(s, 24, fp); /*从文件中读取23个字符*/  
    8.     printf("%s", s);   
    9.     fscanf(fp, "%d", &i); /*读取整型数*/  
    10.     printf("%d", i);   
    11.     putchar(fgetc(fp)); /*读取一个字符同时输出*/  
    12.     fgets(m, 17, fp); /*读取16个字符*/   
    13.     puts(m); /*输出所读字符串*/   
    14.     fclose(fp);   
    15. }   

    运行后屏幕显示: Your score of TOEFL is: 617 That's good news

    4.清除和设置文件缓冲区

    (1).清除文件缓冲区函数:

     int fflush(FILE *stream); 

    int flushall();

     fflush()函数将清除由stream指向的文件缓冲区里的内容,常用于写完一些数据后,立即用该函数清除缓冲区,以免误操作时,破坏原来的数据。 flushall()将清除所有打开文件所对应的文件缓冲区。

    (2).设置文件缓冲区函数

     void setbuf(FILE *stream,char *buf); 

    void setvbuf(FILE *stream,char *buf,int type,unsigned size); 

    这两个函数将使得打开文件后,用户可建立自己的文件缓冲区,而不使用fopen()函数打开文件设定的默认缓冲区。 对于setbuf()函数,buf指出的缓冲区长度由头文件stdio.h中定义的宏BUFSIZE的值决定,缺省值为512字节。当选定buf为空时,setbuf函数将使的文件I/O不带缓冲。而对setvbuf函数,则由malloc函数来分配缓冲区。参数size指明了缓冲区的长度(必须大于0),而参数type则表示了缓冲的类型,其值可以取如下值: type 值 含义 _IOFBF 文件全部缓冲,即缓冲区装满后,才能对文件读写 _IOLBF 文件行缓冲,即缓冲区接收到一个换行符时,才能对文件读写 _IONBF 文件不缓冲,此时忽略buf,size的值,直接读写文件,不再经过文件缓冲区缓冲。

    5.文件的随机读写函数

     前面介绍的文件的字符/字符串读写,均是进行文件的顺序读写,即总是从文件的开头开始进行读写。这显然不能满足我们的要求,C语言提供了移动文件指针和随机读写的函数,它们是:

    (1).移动文件指针函数:

     long ftell(FILE *stream);

     int rewind(FILE *stream);

     fseek(FILE *stream,long offset,int origin);

     函数ftell()用来得到文件指针离文件开头的偏移量。当返回值是-1时表示出错。 rewind()函数用于文件指针移到文件的开头,当移动成功时,返回0,否则返回一个非0值。 fseek()函数用于把文件指针以origin为起点移动offset个字节,其中origin指出的位置可有以下几种:

     origin 数值 代表的具体位置 

    SEEK_SET 0 文件开头

     SEEK_CUR 1 文件指针当前位置

     SEEK_END 2 文件尾 

    例如: fseek(fp,10L,0); 把文件指针从文件开头移到第10字节处,由于offset参数要求是长整型数,故其数后带L。

     fseek(fp,-15L,2); 把文件指针从文件尾向前移动15字节。

    (2).文件随机读写函数

     int fread(void *ptr,int size,int nitems,FILE *stream);

     int fwrite(void *ptr,int size,int nitems,FILE *stream);

     fread()函数从流指针指定的文件中读取nitems个数据项,每个数据项的长度为size个字节,读取的nitems数据项存入由ptr指针指向的内存缓冲区中,在执行fread()函数时,文件指针随着读取的字节数而向后移动,最后移动结束的位置等于实际读出的字节数。该函数执行结束后,将返回实际读出的数据项数,这个数据项数不一定等于设置的nitems,因为若文件中没有足够的数据项,或读中间出错,都会导致返回的数据项数少于设置的nitems。当返回数不等于nitems时,可以用feof()或ferror()函数进行检查。 fwrite()函数从ptr指向的缓冲区中取出长度为size字节的nitems个数据项,写入到流指针stream指向的文件中,执行该操作后,文件指针将向后移动,移动的字节数等于写入文件的字节数目。该函数操作完成后,也将返回写入的数据项数。

    二、非标准文件的读写

     这类函数最早用于UNIX操作系统,ANSI标准未定义,但有时也经常用到,DOS 3.0以上版本支持这些函数。它们的头文件为io.h。 由于我们不常用这些函数,所以在这里就简单说一下。

    1.文件的打开和关闭

     open()函数的作用是打开文件,其调用格式为: int open(char *filename, int access); 该函数表示按access的要求打开名为filename的文件,返回值为文件描述字,其中access有两部分内容: 基本模式和修饰符, 两者用" "("或")方式连接。修饰符可以有多个, 但基本模式只能有一个。 access的规定 -------------------------------------------------------- 基本模式 含义 修饰符 含 义 -------------------------------------------------------- O_RDONLY 只读 O_APPEND 文件指针指向末尾 O_WRONLY 只写 O_CREAT 文件不存在时创建文件, 属性按基本模式属性 O_RDWR 读写 O_TRUNC 若文件存在, 将其长度缩为0, 属性不变 O_BINARY 打开一个二进制文件 O_TEXT 打开一个文字文件 --------------------------------------------------------- open()函数打开成功, 返回值就是文件描述字的值(非负值), 否则返回-1。 close()函数的作用是关闭由open()函数打开的文件, 其调用格式为: int close(int handle); 该函数关闭文件描述字handle相连的文件。

    2.读写函数

     int read(int handle, void *buf, int count);

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

    3.随机定位函数

     lseek()函数的调用格式为: int lseek(int handle, long offset, int fromwhere); 

    该函数对与handle相连的文件位置指针进行定位,功能和用法与fseek()函数相同。 tell()函数的调用格式为: long tell(int handle); 该函数返回与handle相连的文件现生位置指针, 功能和用法与ftell()相同

    5. read 函数和 write 函数

    来源:蚂蚁的 C/C++ 标准编程 作者:antigloss

    1. read 

    #include ssize_t read(int filedes, void *buf, size_t nbytes); 返回值:读取到的字节数;0(读到 EOF);-1(出错) read 函数从 filedes 指定的已打开文件中读取 nbytes 字节到 buf 中。以下几种情况会导致读取到的字节数小于 nbytes :

    A. 读取普通文件时,读到文件末尾还不够 nbytes 字节。例如:如果文件只有 30 字节,而我们想读取 100 字节,那么实际读到的只有 30 字节,read 函数返回 30 。此时再使用 read 函数作用于这个文件会导致 read 返回 0 。

    B. 从终端设备(terminal device)读取时,一般情况下每次只能读取一行。

    C. 从网络读取时,网络缓存可能导致读取的字节数小于 nbytes 字节。

    D. 读取 pipe 或者 FIFO 时,pipe 或 FIFO 里的字节数可能小于 nbytes 。

    E. 从面向记录(record-oriented)的设备读取时,某些面向记录的设备(如磁带)每次最多只能返回一个记录。 F. 在读取了部分数据时被信号中断。读操作始于 cfo 。在成功返回之前,cfo 增加,增量为实际读取到的字节数。

    2. write

     #include ssize_t write(int filedes, const void *buf, size_t nbytes); 返回值:写入文件的字节数(成功);-1(出错)write 函数向 filedes 中写入 nbytes 字节数据,数据来源为 buf 。返回值一般总是等于 nbytes,否则就是出错了。常见的出错原因是磁盘空间满了或者超过了文件大小限制。 对于普通文件,写操作始于 cfo 。如果打开文件时使用了 O_APPEND,则每次写操作都将数据写入文件末尾。成功写入后,cfo 增加,增量为实际写入的字节数。

    展开全文
  • c++文件操作大全

    万次阅读 多人点赞 2019-01-17 15:43:06
    c++文件操作大全 基于C的文件操作   在ANSI C中,对文件的操作分为两种方式,即流式文件操作和I/O文件操作,下面就分别介绍之。 一、流式文件操作  这种方式的文件操作有一个重要的结构FILE,FILE在stdio.h中...

    c++文件操作大全

    基于C的文件操作 
      在ANSI C中,对文件的操作分为两种方式,即流式文件操作和I/O文件操作,下面就分别介绍之。

    一、流式文件操作 
    这种方式的文件操作有一个重要的结构FILE,FILE在stdio.h中定义如下:

    复制代码

    typedef struct { 
      int level;           /* fill/empty level of buffer */ 
      unsigned flags;        /* File status flags */ 
      char fd;            /* File descriptor */ 
      unsigned char hold;      /* Ungetc char if no buffer */ 
      int bsize;           /* Buffer size */ 
      unsigned char _FAR *buffer; /* Data transfer buffer */ 
      unsigned char _FAR *curp;  /* Current active pointer */ 
      unsigned istemp;      /* Temporary file indicator */ 
      short token;          /* Used for validity checking */ 
    } FILE;              /* This is the FILE object */ 

    复制代码

      FILE这个结构包含了文件操作的基本属性,对文件的操作都要通过这个结构的指针来进行,此种文件操作常用的函数见下表 函数 功能 

      fopen() 打开流 
      fclose() 关闭流 
      fputc() 写一个字符到流中 
      fgetc() 从流中读一个字符 
      fseek() 在流中定位到指定的字符 
      fputs() 写字符串到流 
      fgets() 从流中读一行或指定个字符 
      fprintf() 按格式输出到流 
      fscanf() 从流中按格式读取 
      feof() 到达文件尾时返回真值 
      ferror() 发生错误时返回其值 
      rewind() 复位文件定位器到文件开始处 
      remove() 删除文件 
      fread() 从流中读指定个数的字符 
      fwrite() 向流中写指定个数的字符 
      tmpfile() 生成一个临时文件流 
      tmpnam() 生成一个唯一的文件名


    下面就介绍一下这些函数

    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。

     

    borland c++ bulder的文件操作总结2

    二、直接I/O文件操作 
      这是C提供的另一种文件操作,它是通过直接存/取文件来完成对文件的处理,而上篇所说流式文件操作是通过缓冲区来进行;流式文件操作是围绕一个FILE指针来进行,而此类文件操作是围绕一个文件的"句柄"来进行,什么是句柄呢?它是一个整数,是系统用来标识一个文件(在WINDOWS中,句柄的概念扩展到所有设备资源的标识)的唯一的记号。此类文件操作常用的函数如下表,这些函数及其所用的一些符号在io.h和fcntl.h中定义,在使用时要加入相应的头文件。

      函数 说明 
      open() 打开一个文件并返回它的句柄 
      close() 关闭一个句柄 
      lseek() 定位到文件的指定位置 
      read() 块读文件 
      write() 块写文件 
      eof() 测试文件是否结束 
      filelength() 取得文件长度 
      rename() 重命名文件 
      chsize() 改变文件长度

    下面就对这些函数一一说明:

    1.open() 
      打开一个文件并返回它的句柄,如果失败,将返回一个小于0的值,原型是int open(const char *path, int access [, unsigned mode]); 参数path是要打开的文件名,access是打开的模式,mode是可选项。表示文件的属性,主要用于UNIX系统中,在DOS/WINDOWS这个参数没有意义。其中文件的打开模式如下表。

      符号 含义 符号 含义 符号 含义 
      O_RDONLY 只读方式 O_WRONLY 只写方式 O_RDWR 读/写方式 
      O_NDELAY 用于UNIX系统 O_APPEND 追加方式 O_CREAT 如果文件不存在就创建 
      O_TRUNC 把文件长度截为0 O_EXCL 和O_CREAT连用,如果文件存在返回错误 O_BINARY 二进制方式 
      O_TEXT 文本方式

      对于多个要求,可以用"|"运算符来连接,如O_APPEND|O_TEXT表示以文本模式和追加方式打开文件。

      例:int handle=open("c://msdos.sys",O_BINARY|O_CREAT|O_WRITE)

    2.close() 
      关闭一个句柄,原型是int close(int handle);如果成功返回0

      例:close(handle)

    3.lseek() 
      定位到指定的位置,原型是:long lseek(int handle, long offset, int fromwhere);参数offset是移动的量,fromwhere是移动的基准位置,取值和前面讲的fseek()一样,SEEK_SET:文件首部;SEEK_CUR:文件当前位置;SEEK_END:文件尾。此函数返回执行后文件新的存取位置。

      例:

      lseek(handle,-1234L,SEEK_CUR);//把存取位置从当前位置向前移动1234个字节。 
      x=lseek(hnd1,0L,SEEK_END);//把存取位置移动到文件尾,x=文件尾的位置即文件长度

    4.read() 
      从文件读取一块,原型是int read(int handle, void *buf, unsigned len);参数buf保存读出的数据,len是读取的字节。函数返回实际读出的字节。

      例:char x[200];read(hnd1,x,200);

    5.write() 
      写一块数据到文件中,原型是int write(int handle, void *buf, unsigned len);参数的含义同read(),返回实际写入的字节。

      例:char x[]="I Love You";write(handle,x,strlen(x));

    6.eof() 
      类似feof(),测试文件是否结束,是返回1,否则返回0;原型是:int eof(int handle);

      例:while(!eof(handle1)){……};

    7.filelength() 
      返回文件长度,原型是long filelength(int handle);相当于lseek(handle,0L,SEEK_END)

      例:long x=filelength(handle);

    8.rename() 
      重命名文件,原型是int rename(const char *oldname, const char *newname); 参数oldname是旧文件名,newname是新文件名。成功返回0

      例:rename("c://config.sys","c://config.w40");

    9.chsize(); 
      改变文件长度,原型是int chsize(int handle, long size);参数size表示文件新的长度,成功返回0,否则返回-1,如果指定的长度小于文件长度,则文件被截短;如果指定的长度大于文件长度,则在文件后面补'/0'。

      例:chsize(handle,0x12345);


    --------------------------------------------------------------------------------

      如果熟悉汇编可能会发现这种方式和汇编语言的DOS功能调用句柄式文件操作很像,比如open()就像DOS服务的3CH号功能调用,其实这种操作还有两种类型的函数就是直接用DOS功能来完成的,如_open(),_dos_open()等等。有兴趣可自已查询BCB的帮助。

      同流式文件操作相同,这种也提供了Unicode字符操作的函数,如_wopen()等等,用于9X/NT下的宽字符编程,有兴趣可自已查询BCB的帮助。

      另外,此种操作还有lock(),unlock(),locking()等用于多用户操作的函数,但在BCB中用得并不多,我就不介绍了,但如果要用C来写CGI,这些就必要的常识了,如果你有这方面的要求,那就得自已好好看帮助了。

      到这里,我就把基于C的文件操作介绍完了,下一篇将介绍基于C++的文件操作,敬请期待。

    在C++中,有一个stream这个类,所有的I/O都以这个"流"类为基础的,包括我们要认识的文件I/O,stream这个类有两个重要的运算符:

    1、插入器(<<) 
      向流输出数据。比如说系统有一个默认的标准输出流(cout),一般情况下就是指的显示器,所以,cout<<"Write Stdout"<<'/n';就表示把字符串"Write Stdout"和换行字符('/n')输出到标准输出流。

    2、析取器(>>) 
      从流中输入数据。比如说系统有一个默认的标准输入流(cin),一般情况下就是指的键盘,所以,cin>>x;就表示从标准输入流中读取一个指定类型(即变量x的类型)的数据。

    在C++中,对文件的操作是通过stream的子类fstream(file stream)来实现的,所以,要用这种方式操作文件,就必须加入头文件fstream.h。下面就把此类的文件操作过程一一道来。

    一、打开文件 
      在fstream类中,有一个成员函数open(),就是用来打开文件的,其原型是:

      void open(const char* filename,int mode,int access);

      参数:

      filename:  要打开的文件名 
      mode:    要打开文件的方式 
      access:   打开文件的属性 
      打开文件的方式在类ios(是所有流式I/O类的基类)中定义,常用的值如下:

      ios::app:   以追加的方式打开文件 
      ios::ate:   文件打开后定位到文件尾,ios:app就包含有此属性 
      ios::binary:  以二进制方式打开文件,缺省的方式是文本方式。两种方式的区别见前文 
      ios::in:    文件以输入方式打开 
      ios::out:   文件以输出方式打开 
      ios::nocreate: 不建立文件,所以文件不存在时打开失败  
      ios::noreplace:不覆盖文件,所以打开文件时如果文件存在失败 
      ios::trunc:  如果文件存在,把文件长度设为0 
      可以用"或"把以上属性连接起来,如ios::out|ios::binary

      打开文件的属性取值是:

      0:普通文件,打开访问 
      1:只读文件 
      2:隐含文件 
      4:系统文件 
      可以用"或"或者"+"把以上属性连接起来 ,如3或1|2就是以只读和隐含属性打开文件。

      例如:以二进制输入方式打开文件c:/config.sys

      fstream file1; 
      file1.open("c://config.sys",ios::binary|ios::in,0);

      如果open函数只有文件名一个参数,则是以读/写普通文件打开,即:

      file1.open("c://config.sys");<=>file1.open("c://config.sys",ios::in|ios::out,0);

      另外,fstream还有和open()一样的构造函数,对于上例,在定义的时侯就可以打开文件了:

      fstream file1("c://config.sys");

      特别提出的是,fstream有两个子类:ifstream(input file stream)和ofstream(outpu file stream),ifstream默认以输入方式打开文件,而ofstream默认以输出方式打开文件。

      ifstream file2("c://pdos.def");//以输入方式打开文件 
      ofstream file3("c://x.123");//以输出方式打开文件

      所以,在实际应用中,根据需要的不同,选择不同的类来定义:如果想以输入方式打开,就用ifstream来定义;如果想以输出方式打开,就用ofstream来定义;如果想以输入/输出方式来打开,就用fstream来定义。


    二、关闭文件 
      打开的文件使用完成后一定要关闭,fstream提供了成员函数close()来完成此操作,如:file1.close();就把file1相连的文件关闭。

    三、读写文件 
      读写文件分为文本文件和二进制文件的读取,对于文本文件的读取比较简单,用插入器和析取器就可以了;而对于二进制的读取就要复杂些,下要就详细的介绍这两种方式

      1、文本文件的读写 
      文本文件的读写很简单:用插入器(<<)向文件输出;用析取器(>>)从文件输入。假设file1是以输入方式打开,file2以输出打开。示例如下:

      file2<<"I Love You";//向文件写入字符串"I Love You" 
      int i; 
      file1>>i;//从文件输入一个整数值。

      这种方式还有一种简单的格式化能力,比如可以指定输出为16进制等等,具体的格式有以下一些

      操纵符 功能 输入/输出 
      dec 格式化为十进制数值数据 输入和输出 
      endl 输出一个换行符并刷新此流 输出 
      ends 输出一个空字符 输出 
      hex 格式化为十六进制数值数据 输入和输出 
      oct 格式化为八进制数值数据 输入和输出 
      setpxecision(int p) 设置浮点数的精度位数 输出

      比如要把123当作十六进制输出:file1<
      2、二进制文件的读写 
      ①put() 
      put()函数向流写入一个字符,其原型是ofstream &put(char ch),使用也比较简单,如file1.put('c');就是向流写一个字符'c'。

      ②get() 
      get()函数比较灵活,有3种常用的重载形式:

      一种就是和put()对应的形式:ifstream &get(char &ch);功能是从流中读取一个字符,结果保存在引用ch中,如果到文件尾,返回空字符。如file2.get(x);表示从文件中读取一个字符,并把读取的字符保存在x中。

      另一种重载形式的原型是: int get();这种形式是从流中返回一个字符,如果到达文件尾,返回EOF,如x=file2.get();和上例功能是一样的。

      还有一种形式的原型是:ifstream &get(char *buf,int num,char delim='/n');这种形式把字符读入由 buf 指向的数组,直到读入了 num 个字符或遇到了由 delim 指定的字符,如果没使用 delim 这个参数,将使用缺省值换行符'/n'。例如:

      file2.get(str1,127,'A');//从文件中读取字符到字符串str1,当遇到字符'A'或读取了127个字符时终止。

      ③读写数据块 
      要读写二进制数据块,使用成员函数read()和write()成员函数,它们原型如下:

      read(unsigned char *buf,int num); 
      write(const unsigned char *buf,int num);

      read()从文件中读取 num 个字符到 buf 指向的缓存中,如果在还未读入 num 个字符时就到了文件尾,可以用成员函数 int gcount();来取得实际读取的字符数;而 write() 从buf 指向的缓存写 num 个字符到文件中,值得注意的是缓存的类型是 unsigned char *,有时可能需要类型转换。

      例:

      unsigned char str1[]="I Love You"; 
      int n[5]; 
      ifstream in("xxx.xxx"); 
      ofstream out("yyy.yyy"); 
      out.write(str1,strlen(str1));//把字符串str1全部写到yyy.yyy中 
      in.read((unsigned char*)n,sizeof(n));//从xxx.xxx中读取指定个整数,注意类型转换 
      in.close();out.close();

    四、检测EOF 
      成员函数eof()用来检测是否到达文件尾,如果到达文件尾返回非0值,否则返回0。原型是int eof();

      例:  if(in.eof())ShowMessage("已经到达文件尾!");

    五、文件定位 
      和C的文件操作方式不同的是,C++ I/O系统管理两个与一个文件相联系的指针。一个是读指针,它说明输入操作在文件中的位置;另一个是写指针,它下次写操作的位置。每次执行输入或输出时,相应的指针自动变化。所以,C++的文件定位分为读位置和写位置的定位,对应的成员函数是 seekg()和 seekp(),seekg()是设置读位置,seekp是设置写位置。它们最通用的形式如下:

      istream &seekg(streamoff offset,seek_dir origin); 
      ostream &seekp(streamoff offset,seek_dir origin);

      streamoff定义于 iostream.h 中,定义有偏移量 offset 所能取得的最大值,seek_dir 表示移动的基准位置,是一个有以下值的枚举:

      ios::beg:  文件开头 
      ios::cur:  文件当前位置 
      ios::end:  文件结尾 
      这两个函数一般用于二进制文件,因为文本文件会因为系统对字符的解释而可能与预想的值不同。

      例:

      file1.seekg(1234,ios::cur);//把文件的读指针从当前位置向后移1234个字节 
      file2.seekp(1234,ios::beg);//把文件的写指针从文件开头向后移1234个字节

     

    ------------------------------------------------------------------------------------------------------------------------------------------

    在BCB中也提供了文件操作的函数,这些函数的功能和前面所介绍的大致相同,但这类函数和BCB关系紧密,能使用BCB中的AnsiString等数据类型,在BCB中用这种方式的文件操作是最方便的,下面我就把这种文件操作详细介绍。

    在BCB提供的这组文件操作函数中,可分为三种类型,就是:1、文件名函数,2、文件管理函数;3、文件I/O函数。

    1、文件名函数 
      文件名函数可以对文件的名称、所在子目录、驱动器和扩展名等进行操作。下表列出这些函数及其功能。

      函数 说明 
      ExpandFileName() 返回文件的全路径(含驱动器、路径) 
      ExtractFileExt() 从文件名中抽取扩展名 
      ExtractFileName() 从文件名中抽取不含路径的文件名 
      ExtractFilePath() 从文件名中抽取路径名 
      ExtractFileDir() 从文件名中抽取目录名 
      ExtractFileDrive() 从文件名中抽取驱动器名 
      ChangeFileExt() 改变文件的扩展名 
      ExpandUNCFileName() 返回含有网络驱动器的文件全路径 
      ExtractRelativePath() 从文件名中抽取相对路径信息 
      ExtractShortPathName() 把文件名转化为DOS的8·3格式 
      MatchesMask() 检查文件是否与指定的文件名格式匹配

      下面就把这些函数作一一介绍:

      ⑴ExpandFileName() 
      原型:extern PACKAGE AnsiString __fastcall ExpandFileName(const AnsiString FileName);

      功能:返回文件的全路径(含驱动器、路径)

      参数:FileName:要处理的文件名

      例:ShowMessage(ExpandFileName(Application->ExeName));//显示你的程序文件名,如C:/MyBCB/Sample1.EXE

      ⑵ExtractFileExt() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFileExt(const AnsiString FileName);

      功能:从文件名中抽取扩展名

      参数:FileName:要处理的文件名(全路径)

      例:ShowMessage(ExtractFileExt(Application->ExeName));//显示".exe"

      ⑶ExtractFileName() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFileName(const AnsiString FileName);

      功能:从文件名中抽取不含路径的文件名

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractFileExt("c://Winnt//SOL.EXE"));//显示"SOL.EXE"

      ⑷ExtractFilePath() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFilePath(const AnsiString FileName);

      功能:从文件名中抽取路径名

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractFilePath("Winnt//SOL.EXE"));//显示"Winnt/"

      ⑸ExtractFileDir() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFileDir(const AnsiString FileName);

      功能:从文件名中抽取目录名(和上个函数不同,不包括最后的"/")

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractFileDir("Winnt//SOL.EXE"));//显示"Winnt",注意和上个函数的区别

      ⑹ExtractFileDrive() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFileDrive(const AnsiString FileName);

      功能:从文件名中抽取驱动器名

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractFileDrive("c://Winnt//SOL.EXE"));//显示"c:"

      ⑺ChangeFileExt() 
      原型:extern PACKAGE System::AnsiString __fastcall ChangeFileExt(const System::AnsiString FileName, const System::AnsiString Extension);

      功能:更改文件名的扩展名,不是对真正的文件进行改名,只是对文件名这个字符串进行处理

      参数:FileName:要改名的文件名,Extension:新的扩展名

      例:ShowMessage(ChangeFileExt("c://Winnt//SOL.EXE",".OOO"));//显示"c:/winnt/SOL.OOO"

      ⑻ExpandUNCFileName() 
      原型:extern PACKAGE AnsiString __fastcall ExpandUNCFileName(const AnsiString FileName);

      功能:返回含有网络驱动器的文件全路径,格式为://机器名/共享名/文件名

      参数:FileName:要处理的文件名

      例:ShowMessage(ExpandUNCFileName("F://Winnt//SOL.EXE"));/*如果F:是映射的网络驱动器//NT40/WINNT,则显示"//NT40/WINNT/SOL.EXE"*/

      ⑼ExtractRelativePath() 
      原型:extern PACKAGE AnsiString __fastcall ExtractRelativePath(const AnsiString BaseName, const AnsiString DestName);

      功能:从文件名中抽取相对路径信息,如"../sss/ss.asd"这种形式

      参数:BaseName:基准文件名;DestName:目标文件名

      例:ShowMessage(ExtractRelativePath("D://Source//c//1.123","D://Source//Asm//dz.asm"));/*显示"../asm/dz.asm"*/

      (10) ExtractShortPathName() 
      原型:extern PACKAGE AnsiString __fastcall ExtractShortPathName(const AnsiString FileName);

      功能:把文件名转换为DOS的8、3格式

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractShortPathName("E://Program Files//Dual Wheel Mouse//4dmain.exe"));/*显示"E:/Progra~1/dualwh~1/4dmain.exe"*/

      ⑾MatchesMask() 
      原型:extern PACKAGE bool __fastcall MatchesMask(const AnsiString Filename, const AnsiString Mask);

      功能:检查文件是否与指定的文件名格式匹配

      参数:FileName:要处理的文件名;Mask:文件名格式,支持通配符

      例:ShowMessage(MatchesMask("Lxf.exe","*.?x?));//显示"true"

    2、文件管理函数 
      这类函数包括设置和读取驱动器、子目录和文件的有关的各种操作,下表列出这类操作常用的函数及其功能。

      函数 功能 
      CreateDir() 创建新的子目录 
      DeleteFile() 删除文件 
      DirectoryExists() 判断目录是否存在 
      DiskFree() 获取磁盘剩余空间 
      DiskSize() 获取磁盘容量 
      FileExists() 判断文件是否存在 
      FileGetAttr() 获取文件属性 
      FileGetDate() 获取文件日期 
      GetCurrentDir() 获取当前目录 
      RemoveDir() 删除目录 
      SetCurrentDir() 设置当前目录

      下面就把这些函数作一一介绍:

      ⑴CreateDir() 
      原型:extern PACKAGE bool __fastcall CreateDir(const System::AnsiString Dir);

      功能:建立子目录,如果成功返回true,否则返回false

      参数:Dir:要建立的子目录的名字

      例:Create("ASM");//在当前目录下建立一个名为ASM的子目录

      ⑵DeleteFile() 
      原型:extern PACKAGE bool __fastcall DeleteFile(const System::AnsiString FileName);

      功能:删除文件,如果成功返回true,否则返回false

      参数:FileName:要删除的文件名

      例:if(OpenDialog1->Execute())DeleteFile(OpenDialog1->FileName);

      ⑶DirectoryExists() 
      原型:extern PACKAGE bool __fastcall DirectoryExists(const System:: AnsiString Name);

      功能:检测目录是否存在,如果存在返回true,否则返回false

      参数:Name:要检测的目录名

      例:if(!DirectoryExists("ASM"))CreateDir("ASM");//如果ASM这个目录不存在则创建之

      ⑷DiskFree() 
      原型:extern PACKAGE __int64 __fastcall DiskFree(Byte Drive);

      功能:检测磁盘剩余空间,返回值以字节为单位,如果指定的磁盘无效,返回-1

      参数:Drive:磁盘的代号,0表示当前盘, 1=A,2=B,3=C 以此类推

      例:ShowMessage(DiskFree(0));//显示当前盘的剩余空间

      ⑸DiskSize() 
      原型:extern PACKAGE __int64 __fastcall DiskSize(Byte Drive);

      功能:检测磁盘容量,返回值以字节为单位,如果指定的磁盘无效,返回-1

      参数:Drive:磁盘的代号,0表示当前盘, 1=A,2=B,3=C 以此类推

      例:ShowMessage(DiskFree(0));//显示当前盘的容量

      ⑹FileExists() 
      原型:extern PACKAGE bool __fastcall FileExists(const AnsiString FileName);

      功能:检测文件是否存在,如果存在返回true,否则返回false

      参数:FileName:要检测的文件名

      例:if(FileExists("AAA.ASM"))DeleteFile("AAA.ASM");

      ⑺FileGetAttr() 
      原型:extern PACKAGE int __fastcall FileGetAttr(const AnsiString FileName);

      功能:取得文件属性,如果出错返回-1

      返回值如下表,如果返回$00000006表示是一个具有隐含和系统属性的文件(4+2)

      常量 值 含义 
      faReadOnly $00000001 只读文件 
      faHidden $00000002 隐含文件 
      faSysFile $00000004 系统文件 
      faVolumeID $00000008 卷标 
      faDirectory $00000010 目录 
      faArchive $00000020 归档文件

      例:if(FileGetAttr("LLL.TXT")&0x2)ShowMessage("这是一个有隐含属性的文件");

      与此对应的有FileSetAttr() ,请自已查阅帮助系统


      ⑻FileGetDate() 
      原型:extern PACKAGE int __fastcall FileGetDate(int Handle);

      功能:返回文件的建立时间到1970-1-1日0时的秒数

      参数:Handle:用FileOpen()打开的文件句柄。

      例:

      int i=FileOpen("C://autoexec.bat",fmOpenRead); 
      ShowMessage(FileGetDate(i)); 
      FileClose(i);

      与此对应的有FileSetDate(),请自已查阅帮助系统

      ⑼GetCurrentDir() 
      原型:extern PACKAGE AnsiString __fastcall GetCurrentDir();

      功能:取得当前的目录名

      例:ShowMessage(GetCurrentDir());

      ⑽RemoveDir() 
      原型:extern PACKAGE bool __fastcall RemoveDir(const AnsiString Dir);

      功能:删除目录,如果成功返回true,否则返回false

      参数:Dir:要删除的目录名

      例:if(DiectoryExists("ASM"))RemoveDir("ASM");

      ⑾SetCurrentDir() 
      原型:extern PACKAGE bool __fastcall SetCurrentDir(const AnsiString Dir);

      功能:设置当前目录,如果成功返回true,否则返回false

      参数:Dir:要切换到的目录名

      例:SetCurrentDir("C://WINDOWS");


    3、文件I/O函数 
      这类函数完成对文件的读写相关的操作,这种类型的操作和C的基于I/O文件操作类似,下表列出这类操作常用的函数及其功能。


      FileOpen() 打开文件 
      FileClose() 关闭文件 
      FileRead() 读文件 
      FileSeek() 文件定位 
      FileWrite() 写文件 
      FileCreate() 创建文件

      下面就对这些函数作详细介绍。

      ⑴FileOpen() 
      原型:extern PACKAGE int __fastcall FileOpen(const AnsiString FileName, int Mode);

      功能:打开文件,如果成功返回其句柄,否则返回-1

      参数:FileName:要打开的文件名;Mode:打开的方式,取值如下表,可用"或"("|")运算符连接。

      常量 值 说明 
      ------------------------------------------------------------- 
      fmOpenRead 0 以只读属性打开 
      fmOpenWrite 1 以只写属性打开 
      fmOpenReadWrite 2 以读/写属性打开 
      fmShareCompat 0 兼容FCB方式(汇编中有相应的DOS功能调用,感兴趣自已查阅相关资料) 
      fmShareExclusive 16 共享方式:以独占方式打开,在关闭以前,别人不能访问 
      fmShareDenyWrite 32 共享方式:拒绝写访问 
      fmShareDenyRead 48 共享方式:拒绝读访问 
      fmShareDenyNone 64 共享方式:无限制,允许读写 
      例:int i=FileOpen("C://WINDOWS//Win.ini",fmOpenReadWrite|fmShareExclusive);

      ⑵FileClose() 
      原型:extern PACKAGE void __fastcall FileClose(int Handle);

      功能:关闭打开的句柄。

      参数:Handle:要关闭的句柄

      例:FileClose(i);

      ⑶FileRead() 
      原型:extern PACKAGE int __fastcall FileRead(int Handle, void *Buffer, int Count);

      功能:读文件,返回实际读取的字节数,句柄必须首先由FileOpen或FileCreate创建。

      参数:Handle:要读取的句柄;Buffer:存放读取的数据的缓冲区;Count:想读取的字节数

      例:char str[400];FileRead(hnd1,str,400);

      ⑷FileSeek() 
      原型:extern PACKAGE int __fastcall FileSeek(int Handle, int Offset, int Origin);

      功能:移动文件读取指针,成功返回文件指针的位置,失败返回-1

      参数:Handle:相关联的句柄;Offset:移动的量;Orgin:移动的基准,0=文件头,1=当前位置,2=文件尾。

      例:ShowMessage(FileSeek(hnd1,0,2));//取得文件的长度

      ⑸FileWrite() 
      原型:extern PACKAGE int __fastcall FileWrite(int Handle, const void *Buffer, int Count);

      功能:写文件,返回实际写入的字节数,句柄必须首先由FileOpen或FileCreate创建。

      参数:Handle:要写入的句柄;Buffer:存放写入数据的缓冲区;Count:想写入的字节数

      例:char str[]="I Love You";FileWrite(hnd1,str,strlen(str));

      ⑹FileCreate() 
      原型:extern PACKAGE int __fastcall FileCreate(const AnsiString FileName);

      功能:创建文件。成功返回其句柄,否则返回-1

      参数:FileName:要创建的文件名

      例:if(!FileExists("KC.C"))hnd1=FileCreate("KC.C");

    展开全文
  • C文件操作(全)

    千次阅读 2019-07-14 11:51:59
    文件 文件的基本概念 所谓“文件”是指一组...实际上在前面的各章中我们已经多次使用了文件,例如源程序文件、目标文件、可执行文件、库文件 (头文件)等。文件通常是驻留在外部介质(如磁盘等)上的,在使用时...
  • 常见文件操作(java代码)

    万次阅读 2018-02-23 16:00:12
    主要用于读取图片,MP3,AVI视频文件。 字符流:字符流使用了字节流读到一个或多个字节,如读取中文时,就会一次读取2个字节。只要是处理纯文本数据,就要优先考虑使用字符流。 字节流和字符流区别 字节流...
  • C语言对文件操作

    万次阅读 多人点赞 2018-12-20 23:08:52
    前言在谭浩强的C语言设计的第10张讲了有关文件的知识, 以往我们写的C程序的数据都是由键盘输入的 现在我们要对文件进行操作文件操作系统的基本单位。是我们专业领域的重要的一部分。 就拿我们的编译器来说...
  • c/c++文件操作

    千次阅读 2018-12-22 15:09:30
    简单方便用法: 读:freopen('a.txt','w',stdin); 写:freopen('b.txt','r', stdout)  文件是存储在某种长期储存设备...磁盘文件操作系统中的文件系统统一管理,也只有文件系统才能直接操作文件。所以编写C+...
  • C语言文件操作详解

    万次阅读 多人点赞 2016-03-04 15:50:58
    C语言文件操作函数 函数介绍 文件打开与关闭操作 fopen():文件打开操作 头文件:stdio.h 函数定义:FILE *fopen(char *pname, char *mode) 函数说明:pname是文件名,mode是打开文件的方式 mode:"r" 打开一...
  • Python进阶(十五)-file文件操作

    万次阅读 2017-03-19 09:25:13
    Python进阶(十五)-file文件操作  Python下文件操作与Java差不多。打开文件的模式有三种: r,只读模式(默认)。 w,只写模式。【不可读;不存在则创建;存在则删除内容;因为会清空原有文件的内容,一定要慎用】 ...
  • 5-Python-文件操作、异常、模块

    万次阅读 2019-01-04 10:27:48
    文件操作 &lt;1&gt;打开文件 在python,使用open函数,可以打开一个已经存在的文件,或者创建一个新文件 示例如下: open(文件名,访问模式) f = open('test.txt', 'w') 说明: 访问模式 说明 ...
  • linux文件操作总结

    千次阅读 2017-04-26 16:11:46
    简单的说,C中基本的的printf()函数,scanf()函数,其实都属于文件操作。 对于文件操作,虽然都是通过函数调用的方式实现,却还是能分为两类:系统调用和库函数。 这篇文章将先介绍linux中文件的概念,系统...
  • Python之文件操作

    万次阅读 2018-07-11 18:31:17
    文件操作初识文件操作 使用python来读写文件是非常简单的操作. 我们使用open()函数来打开某个文件, 获取到文件句柄. 然后通过文件句柄就可以进行各种各样的操作了. 根据打开形式的不同能够执行的操作也会有相应的...
  • Python os模块文件操作(一)

    千次阅读 2019-09-15 10:53:32
    Python os模块文件操作(一) 一、文件描述符 在使用代码对文件进行操作时,为了指定操作的文件,避免不了要使用文件描述符,所以我们先介绍什么是文件描述符。 操作系统为了高效管理已经被打开的文件,会给每个...
  • FTP文件操作之下载文件

    千次阅读 热门讨论 2013-05-22 10:25:41
    FTP文件操作之上传文件 FTP文件操作之下载文件 FTP文件操作之删除文件 FTP文件操作之创建目录 FTP文件操作之获取文件列表 前面写了采用ftp上传文件,有了上传怎么能够没有下载呢?如果只有上传没有...
  • NodeJS 文件操作 —— fs 基本使用

    千次阅读 2019-04-26 13:13:39
    在 NodeJS 中,所有与文件操作都是通过 fs 核心模块来实现的,包括文件目录的创建、删除、查询以及文件的读取和写入,在 fs 模块中,所有的方法都分为同步和异步两种实现,具有 sync 后缀的方法为同步方法,不具有 ...
  • 23. Perl 文件操作-文件类型判断

    千次阅读 2019-08-27 16:03:19
    perl 语言提供了很多对于判断文件属性的操作符, 笔者只列出个人常用的一些文件操作符. 文件属性判断操作符通常与if 配合使用. 1. 常用文件操作符 1.1 判断文件权限 测试操作符 含义 -r 当前...
  • Qt之文件操作

    万次阅读 2011-06-17 02:45:00
     今天学习QT的文件操作1、QIODevice直接继承自QObjectQIODevice类是输入/输出设备的基类。QIODevice为设备提供了公共实现和抽象接口用于读写块数据。QIODevice是一个抽象类,不能被实例化。被Q3Socket,Q3
  • c语言关于文件操作的常用函数(新手入门看)

    万次阅读 多人点赞 2017-12-16 17:28:36
    C语言文件操作打开文件FILE *fp = fopen("要点一","要点二");要点一: 这里可以写单独的文件名,比如说“1.txt”,那么他就会在当前c文件的文件夹目录下查询文件是否存在,存在则返回这个文件的指针,不存在的话则...
  • C语言文件操作函数大全

    万次阅读 多人点赞 2018-01-20 11:43:22
    C语言文件操作函数大全 2018-1-19  13.1C语言文件 1,两种文件存取方式(输入,输出方式) 顺序存取 直接存取 2,数据的两种存放形式 文本文件 二进制文件 13.2文件指针 定义文件类型指针变量的一般...
1 2 3 4 5 ... 20
收藏数 4,884,076
精华内容 1,953,630
关键字:

文件操作