C语言文件操作

前言

关于C语言文件操作这节内容实际上也是类似一种修炼内功一样的存在，很多教材可能都没有这一节内容，但是学习这种修炼内功一样的知识的确是可以提升我们的素养，让我们的编程能力更加扎实，好了，关于素养方面的好处自己体会即可。

为什么使用文件

我们写数据应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。
使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。

什么是文件

磁盘上的文件是文件。但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（从文件功能的角度来分类的）。

程序文件

包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）。

数据文件

文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。

文件名

一个文件要有一个唯一的文件标识，以便用户识别和引用。

文件名包含3部分：文件路径+文件名主干+文件后缀

例如： c:\code\test.txt

为了方便起见，文件标识常被称为文件名。

文件的打开与关闭

文件指针（FILE*）

缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。

每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是由系统声明的，取名FILE.

总之很容易看出FILE是一个结构体类型，而这个类型是用来存放文件信息的即可。

所以我们可以通过定义结构体指针来找到相应文件，

FILE* pf

定义pf是一个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。

文件的打开与关闭

我们想要拿到一个文件中的信息，第一步当然是要打开文件，我们要使用一个函数fopen，而关闭文件则需要用fclose。

//打开文件
FILE * fopen ( const char * filename, const char * mode );
//关闭文件
int fclose ( FILE * stream );

关闭文件很简单，直接拿指针传过去即可。而打开文件则有些复杂，

文件使用方式	含义	如果指定文件不存在
“r”（只读）	为了输入数据，打开一个已经存在的文本文件	出错
“w”（只写）	为了输出数据，打开一个文本文件	建立一个新的文件
“a”（追加）	向文本文件尾添加数据	建立一个新的文件
“rb”（只读）	为了输入数据，打开一个二进制文件	出错
“wb”（只写）	为了输出数据，打开一个二进制文件	建立一个新的文件
“ab”（追加）	向一个二进制文件尾添加数据	出错
“r+”（读写）	为了读和写，打开一个文本文件	出错
“w+”（读写）	为了读和写，建议一个新的文件	建立一个新的文件
“a+”（读写）	打开一个文件，在文件尾进行读写	建立一个新的文件
“rb+”（读写）	为了读和写打开一个二进制文件	出错
“wb+”（读写）	为了读和写，新建一个新的二进制文件	建立一个新的文件
“ab+”（读写）	打开一个二进制文件，在文件尾进行读和写	建立一个新的文件

表格中的“r”，“w”，“a”等就是文件打开的方式，也就是参数中的mode，我们使用文件之前要想好用什么方式去打开。

如果你看不懂也没有关系，我们下面会有例子。

文件的顺序读写

对文件进行读写我们需要掌握的就是以下几个函数，

功能	函数名	适用于
字符输入函数	fgetc	所有输入流
字符输出函数	fputc	所有输出流
文本行输入函数	fgets	所有输入流
文本行输出函数	fputs	所有输出流
格式化输入函数	fscanf	所有输入流
格式化输出函数	fprintf	所有输出流
二进制输入	fread	文件
二进制输出	fwrite	文件

fgetc和fputc

先来看fgetc和fputc，这两个一个是输入函数，一个是输出函数，但仅仅针对于字符，我们来举例：

先看两个函数的参数，很好理解：

int fputc ( int character, FILE * stream );
int fgetc ( FILE * stream );//该函数只能只能操作一个字符，从文件里读取字符到内存中。如果读取成功，返回该字符的ASCII码值；如果读取失败，则返回EOF

/*fputc example*/
int main()
{
   
   
    //打开文件 -- 写的方式
    FILE* pf = fopen("test.txt", "w");
    if (pf == NULL)
    {
   
   
        perror("fopen:");
        return;
    }
    //使用文件
    int ret = fputc('c', pf);
    printf("%c\n",ret);
    //关闭文件
    fclose(pf);
    pf = NULL;
    return 0;
}

以上我们就在当前目录下创建了一个test.txt的文件，使用fputc函数向里面写了一个字符c。这个在我们电脑上打开文件是可以看的到的。

int main()
{
   
   
    //打开文件 -- 读的方式
    FILE* pf = fopen("test.txt", "r");
    if (pf == NULL)
    {
   
   
        perror("fopen:");
        return;
    }
    //使用文件
    int ret = fgetc(pf);
    printf("%c\n", ret);
    //关闭文件
    fclose(pf);
    pf = NULL;
    return 0;
}

我们也可以用fgetc将字符读出来，然后打印验证一下，fgetc的确是可以的。

fgets和fputs

先看fputs的函数参数，很好理解，将要输入的字符串地址传入和要写入的文件地址传过去即可。

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

int main()
{
   
   
    FILE* pf = fopen("test.txt", "w");
    if (pf == NULL)
    {
   
   
        perror("fopen");
        return 1;
    }
    //写一行数据
    fputs("hello world\n", pf);
    fputs("hello\n", pf);

    fclose(pf);
    pf = NULL;
    return 0;
}

这样我们就向文件中写入了一行数据。

fgets看参数也并不复杂：

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

从文件中读取多少个数据，放到哪里，传入相应3个参数即可。

int main()
{
   
   
    FILE* pf = fopen("test.txt", "r");
    if (pf == NULL)
    {
   
   
        perror("fopen");
        return 1;
    }
    //读一行数据
    char buf[10] = {
   
    0 };
    char* pc=fgets(buf, 5, pf);//末尾会自动放一个\0
    printf(pc);

    fclose(pf);
    pf = NULL;
    return 0;
}

要注意的就是读取的字符串最后会放一个\0，所以在传参时要多加1。

fprintf和fscanf

先看fprintf的函数参数，很懵逼，其实这个比上面函数还要简单，后面的...其实叫做可变参数列表，但实际上就是格式化输入，在我们平时用的printf前多加了一个参数文件指针即可。

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

int main()
{
   
   
    FILE* pf=fopen("test.txt", "w");
    if (pf == NULL)
    {
   
   
        perror("fopen");
        return 1;
    }
    //
    fprintf(pf,"%s %d %d", "zhangsan", 18, 95);

    //
    fclose(pf);
    pf = NULL;
    return 0;
}

这样用fprintf向文件中写入了多个类型的一组数据。

fscanf和fprintf类似，只有在平时使用的scanf的基础上加上前面的地址即可，

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

typedef struct Stu
{
   
   
    char name[20];
    int age;
    int score;
}Stu;

int main()
{
   
   
    Stu s = {
   
    0 };
    FILE* pf = fopen("test.txt", "r");
    if (pf == NULL)
    {
   
   
        perror("fopen");
        return 1;
    }

    fscanf(pf, "%s %d %d", s.name, &(s.age), &(s.score));

    printf("%s %d %d\n", s.name, s.age, s.score);
    fclose(pf);
    pf = NULL;
    return 0;
}

同理可以使用fscanf将文件中的数据格式化取出。

fread和fwrite

这两种均是以二进制的形式进行读写，

这两个函数是比较重要的，先来看函数参数，fwrite是以二进制进行写入，fread是以二进制进行读取，需要解释的是参数：

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

这两个函数参数基本一致，ptr是指针，在fwrite中是将ptr指向的数据写到文件中，size是要写入数据的大小，count是要写入的数量。在fread中就是反过来，从文件中读取数据放到ptr指向的空间中去。

struct S
{
   
   
    char name[20];
    int age;
    float score;
};
int main()
{
   
   
    struct S s={
   
   "zhangsan",20,95.5};
    FILE* pf = fopen("test.txt", "wb");
    if (pf == NULL)
    {
   
   
        perror("fopen");
        return 1;
    }
    //二进制输入
    fwrite(&s, sizeof(struct S), 1, pf);
    //char* pc = "abcdef 12345";
    //char* p = "张三";
    //fwrite(pc, sizeof(char), 20, pf);
    //fwrite(p, sizeof(char), 6, pf);
    //
    fclose(pf);
    pf = NULL;
    return 0;
}

int main()
{
   
   
    struct S s = {
   
    0 };
    FILE* pf = fopen("test.txt", "rb");
    if (pf == NULL)
    {
   
   
        perror("fopen");
        return 1;
    }
    //二进制输出
    fread(&s, sizeof(struct S), 1, pf);
    printf("%s %d %f\n", s.name, s.age, s.score);
    fclose(pf);
    pf = NULL;
    return 0;
}

对比两组函数

scanf/fscanf/sscanf
printf/fprintf/sprintf

这里还要在额外介绍一下sscanf和sprintf，

sprint是将格式化数据合并成到一个字符串中，

sscanf是将一个字符串进行数据格式化读取。

int sprintf ( char * str, const char * format, ... );
int sscanf ( const char * s, const char * format, ...);

struct S
{
   
   
    char name[20];
    int age;
    float score;
};
int main()
{
   
   
  sprintf -- 将格式化数据放到一个字符串中
    struct S s1 = {
   
    .name = "zhangsan",.age = 18,.score = 95.5 };
    char buf[100] = {
   
    0 };
    sprintf(buf, "%s %d %f", s1.name, s1.age, s1.score);
    printf("%s\n", buf);
    //sscanf  -- 从一个字符串中还原回格式化数据
    struct S s2 = {
   
    0 };
    sscanf(buf, "%s %d %f", s2.name, &s2.age, &s2.score);
    printf("%s %d %f\n", s2.name, s2.age, s2.score);
    return 0;
}

文件的随机读写

fseek

fseek的作用：根据文件指针的位置和偏移量来定位文件指针。

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

看函数参数，

offset参数是指你要移动的偏移量，重点要注意的就是最后一个参数，决定了你从哪个位置开始计算。

rewind

让文件指针的位置回到文件的起始位置

void rewind ( FILE * stream );

ftell

返回文件指针相对于起始位置的偏移量

这个很简单了，只有将指针传过去，返回偏移量用一个参数接受一下即可。

long int ftell ( FILE * stream );

int main()
{
   
   
    FILE* pf=fopen("test.txt", "r");
    if (pf == NULL)
    {
   
   
        perror("fopen");
        return 1;
    }
    fseek(pf, 2, SEEK_SET);
    int ch = fgetc(pf);
    printf("%c\n", ch);
    //ftell -- 返回相对起始位置的偏移量
    int num = ftell(pf);
    printf("%d\n", num);
    //rewind -- 调整指针指向起始位置
    rewind(pf);
    fclose(pf);
    pf = NULL;
    return 0;
}

文件读取结束的判定

牢记：在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。
而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束。

文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）

fgetc 判断是否为 EOF .

fgets 判断返回值是否为 NULL .

二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。

fread判断返回值是否小于实际要读的个数

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
   
   
    int c; // 注意：int，非char，要求处理EOF
    FILE* fp = fopen("test.txt", "r");
    if(!fp) {
   
   
    perror("File opening failed");
    return EXIT_FAILURE;
    }
    //fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
    while ((c = fgetc(fp)) != EOF) // 标准C I/O读取文件循环
    {
   
   
    putchar(c);
    }
    //判断是什么原因结束的 
    if (ferror(fp))
    puts("I/O error when reading");
    else if (feof(fp))
    puts("End of file reached successfully");
    fclose(fp);
}

#include <stdio.h>
enum {
   
    SIZE = 5 };
int main(void)
{
   
   
    double a[SIZE] = {
   
   1.,2.,3.,4.,5.};
    FILE *fp = fopen("test.bin", "wb"); // 必须用二进制模式
    fwrite(a, sizeof *a, SIZE, fp); // 写 double 的数组
    fclose(fp);
    double b[SIZE];
    fp = fopen("test.bin","rb");
    size_t ret_code = fread(b, sizeof *b, SIZE, fp); // 读 double 的数组
    if(ret_code == SIZE) {
   
   
    puts("Array read successfully, contents: ");
    for(int n = 0; n < SIZE; ++n) printf("%f ", b[n]);
    putchar('\n');
    } else {
   
    // error handling
    if (feof(fp))
    printf("Error reading test.bin: unexpected end of file\n");
    else if (ferror(fp)) {
   
   
    perror("Error reading test.bin");
    }
    }
    fclose(fp);
}

文件缓冲区

ANSIC 标准采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C编译系统决定的。

#include <stdio.h>
#include <windows.h>
int main()
{
   
   
    FILE*pf = fopen("test.txt", "w");
    fputs("abcdef", pf);//先将代码放在输出缓冲区
    printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
    Sleep(10000);
    printf("刷新缓冲区\n");
    fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
    printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");
    Sleep(10000);
    fclose(pf);
    //注：fclose在关闭文件的时候，也会刷新缓冲区
    pf = NULL;
    return 0;
}

因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。如果不做，可能导致读写文件的问题。

C语言文件操作

C语言文件操作

前言

为什么使用文件

什么是文件

程序文件

数据文件

文件名

文件的打开与关闭

文件指针（FILE*）

文件的打开与关闭

文件的顺序读写

fgetc和fputc

fgets和fputs

fprintf和fscanf

fread和fwrite

对比两组函数

文件的随机读写

fseek

rewind

ftell

文件读取结束的判定

文件缓冲区

热门文章

最新文章

相关课程

相关电子书