文件处理不再难:带你轻松攻克C语言文件操作

文件的内容不一定是程序,而是程序运行时读写的数据,比如程序运行需要从中读取数据的文件,或者输出内容的文件.
在本章我们主要讨论的是数据文件
在以前我们处理数据的输入输出都是以终端为对象的,即从终端的键盘输入数据,运行结果到显示器上,但是有时候我们会把信息输出到磁盘上,当需要的时候再从磁盘上把数据读取到内存去进行使用,这个时候处理的就是磁盘上的文件.

2.3:文件名

一个文件要有一个唯一的标识符,以便用户识别和使用.

文件名包含以下三部分

文件路径.
文件名主干.
文件后缀.

例如:D:\VS代码\cplusplus\2_Classes_and_objects_part1\2_Classes_and_objects_part1\test.c

D:\VS代码\cplusplus\2_Classes_and_objects_part1\2_Classes_and_objects_part1是文件路径
test是文件名主干.
.c是文件名后缀.

3:二进制文件与文本文件

根据数据的组织形式,数据文件被称为文本文件或者二进制文件.

二进制文件:数据在内存中以二进制的形式进行存储,并且不加转换的输出到外存.
文本文件:以ASCII字符的形式存储的文件.

一个数据在内存中是怎么进行存储的呢?

字符型数据一律以ASCII码的形式进行存储.
数值型数据既可以用ASCII码形式存储,也可以使用二进制的形式进行存储.

4:文件的打开与关闭

4.1:流与标准流

4.1.1:流

我们的程序的数据需要输出到各种外部设备,也需要从外部设备获取数据,不同的外部设备的输入输出操作各不相同,为了方便程序员对各种设备进行方便的操作,则抽象出了流的概念,可以把流想象成流淌着字符的星河.C语言针对文件、画面、键盘等的数据输入输出操作都是同流操作的.

C程序针对文件、画面、键盘等的数据输入输出操作都是同流操作的.
一般情况下,如果想要往流里面写入数据,或者从流中读取数据,都是打开留,然后操作.

4.1.2:标准流

那么为什么我们从键盘输入数据,向屏幕上输出数据,并没有打开流呢那是因为C语言在程序启动的时候,默认打开了3个流.

stdin - 标准输入流,在大多数的环境中从键盘输入.
stdout - 标准输出流,大多数的环境中输出至显示器界面.
stderr - 标准错误流,大多数环境中输出到显示器界面.

这是默认打开了这三个流,我们使用scanf,printf等函数就可以直接进行输入输出操作的.

stdin、stdout、stder三个流的类型是:FILE *，通常称为文件指针.

C语言中,就是通过FILE * 的文件指针来维护流的各种操作的.

4.2:文件指针

在缓冲文件系统中,关键的概念是:"文件类型指针",简称"文件指针".

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

例如:VS2013编译环境提供的stdio.h头文件中有以下的文件类型声明:

struct _iobuf 
{
     char *_ptr;
     int _cnt;
     char *_base;
     int _flag;
     int _file;
     int _charbuf;
     int _bufsiz;
     char *_tmpfname;
 };
typedef struct _iobuf FILE;

不同的C语言编译器的FILE类包含的内容不完全相同,但是大同小异.

每当打开一个文件的时候,系统会根据文件的情况自动创建一个FILE结构的变量,并填充其中的信息,那么使用者其实不需要关系细节.

一般都是通过一个FILE的指针来维护这个FILE结构的变量,这样子的话使用起来更加方便.

我们可以创建一个FILE*的指针变量

FILE * pf;

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

4.3:文件的打开与关闭

文件在读写之前应该先打开文件,在使用结束之后应该关闭文件.
在编写程序的时候,在打开文件的同时,都会返回一个FILE*的指针变量指向该文件,也就相当于建立了指针与文件的关系.

ANSIC规定使用fopen函数打开文件,fclose来关闭文件.

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

mode表示文件的打开模式,以下均为文件的打开模式.

文件使用方式	含义	如果指定文件不存在
"r"(只读)	为了输入数据,打开一个已经存在的文本文件	出错.
"w"(只写)	为了输出数据,打开一个文本文件.	建立一个新的文件.
"a"(追加)	向文本文件尾添加数据	建立一个新的文件
"rb"(只读)	为了输⼊数据，打开⼀个⼆进制⽂件	出错
"wb"(只写)	为了输出数据，打开⼀个⼆进制⽂件	建⽴⼀个新的⽂件
"ab"(追加)	向一个二进制文件尾添加数据	建立一个新的文件
"r+"(读写)	为了读和写,打开一个新的文件	出错
"w+"(读写)	为了读和写,建立一个新的文件	建立一个新的文件
"a+"(读写)	打开一个文件,在文件尾进行读写	建立一个新的文件
"rb+"(读写)	为了读和写打开一个二进制文件	出错
"wb+"(读写)	为了读和写,建立一个新的二进制文件	建立一个新的文件
"ab+"(读写)	打开一个二进制文件,在文件尾进行读写	建立一个新的文件

4.3.1:代码1

#include <stdio.h>

int main()
{
    //打开文件
    //r模式为只读模式,若文件不存在则进行报错
    FILE* pf = fopen("data.txt", "r");
    if (NULL == pf)
    {
        perror("fopen:");
        return 1;
    }
    /*
    * 关闭文件, 由于关闭文件后
    文件指针指向的地址还是原来的地址
    因此如果不将文件指针置为NULL的话
    那么指针pf会成野指针
    */
    fclose(pf);
    pf = NULL;
    return 0;
}

4.3.2:代码2

#include <stdio.h>

int main()
{
    //打开文件
    //w模式为只读模式,若文件不存在则建立一个新的文件
    FILE* pf = fopen("data.txt", "w");
    if (NULL == pf)
    {
        perror("fopen:");
        return 1;
    }
    /*
    * 关闭文件, 由于关闭文件后
    文件指针指向的地址还是原来的地址
    因此如果不将文件指针置为NULL的话
    那么指针pf会成野指针
    */
    fclose(pf);
    pf = NULL;
    return 0;
}

4.4:相对路径与绝对路径

4.4.1:相对路径

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

/*
* 相对路径
*  . :表示当前路径
  .. :表示上一级路径
*/
int main()
{
//打开文件;
FILE* pf = fopen("..\\data.txt", "r");
if (NULL == pf)
{
perror("fopen:");
return 1;
}
printf("该文件存在\n");
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}

4.4.2:绝对路径

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

/*
* 绝对路径:从磁盘的位置开始一层一层往下找
*/
int main()
{
//打开文件;
FILE* pf = fopen("D:\\VS代码\\data-structure\\7_test\\7_test\\data.txt", "r");
if (NULL == pf)
{
perror("fopen:");
return 1;
}
printf("该文件存在\n");
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}

5:文件的顺序读写

5.1:文件的顺序读写函数介绍

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

5.2:fputc函数

int fputc (int character,FILE * stream);

#include <stdio.h>

int main()
{
    //打开文件
    //w为只写模式,输出数据
    FILE* pf = fopen("data.txt", "w");
    if (NULL == pf)
    {
        perror("fopen:");
        return 1;
    }
    //写入数据,将26个字符写入进去,每5个为一行,
    int ch = 0;
    for (ch = 'a'; ch <= 'z'; ch++)
    {
        if (0 == ch % 5)
        {
            fputc('\n', pf);
        }
        fputc(ch, pf);
    }
    /*
    * 关闭文件, 由于关闭文件后
    文件指针指向的地址还是原来的地址
    因此如果不将文件指针置为NULL的话
    那么指针pf会成野指针
    */
    fclose(pf);
    pf = NULL;
    return 0;
}

5.3:fgetc函数

//读取失败则返回EOF
int fgetc (FILE * stream);

#include <stdio.h>

int main()
{
    //打开文件
    //w为只读模式,输入数据
    FILE* pf = fopen("data.txt", "r");
    if (NULL == pf)
    {
        perror("fopen:");
        return 1;
    }
    int ch = 0;
    while((ch = fgetc(pf)) != EOF)
    {
        printf(" %c", ch);
    }
    /*
    * 关闭文件, 由于关闭文件后
    文件指针指向的地址还是原来的地址
    因此如果不将文件指针置为NULL的话
    那么指针pf会成野指针
    */
    fclose(pf);
    pf = NULL;
    return 0;
}

5.4:fputs函数

int fputs(const char * str,FILE * stream);
//成功则返回一个非负整数
//失败则返回EOF

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
    //打开文件
    //w为只写模式,输出数据
    FILE* pf = fopen("data.txt", "w");
    if (NULL == pf)
    {
        perror("fopen:");
        return 1;
    }
    char arr[100] = "0";
    scanf("%s", arr);
    //将arr的内容输出到文件指针pf所指向的文件
    fputs(arr, pf);
    /*
    * 关闭文件, 由于关闭文件后
    文件指针指向的地址还是原来的地址
    因此如果不将文件指针置为NULL的话
    那么指针pf会成野指针
    */
    fclose(pf);
    pf = NULL;
    return 0;
}

5.5:fgets函数

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

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
    FILE* pf = fopen("data.txt", "r");
    if (NULL == pf)
    {
        perror("fopen");
    }
    char arr[100] = "0";
    //从文件中读取(3 - 1)个字符放到num中
    fgets(arr, 3, pf);
    printf("%s", arr);
    fclose(pf);
    pf = NULL;
    return 0;
}

5.6:fscanf函数

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

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

struct S
{
    float a;
    char b;
    double d;
};
int main()
{
    struct S s1 = { 2.0f,'a',180.0};
    FILE* pf = fopen("data.txt", "r");
    if (NULL == pf)
    {
        perror("fopen");
        return 1;
    }
    //读取数据
    fscanf(pf, "%f %c %lf", &s1.a, &s1.b, &s1.d);
    printf("%f %c %lf", s1.a, s1.b, s1.d);
    fclose(pf);
    pf = NULL;
    return 0;
}

5.7:fprintf函数

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

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
struct S
{
float a;
char b;
double d;
};
int main()
{
FILE* pf = fopen("data.txt", "w");
if (NULL == pf)
{
perror("fopen");
return 1;
}
struct S s1 = { 5.0f,'w',250.0 };
//向文件指针pf所指向的文件写入数据;
fprintf(pf, "%f %c %lf", s1.a, s1.b, s1.d);
fclose(pf);
pf = NULL;
return 0;
}

5.8:fwrite函数

//将ptr指向的数据以二进制的方式写入到文件指针stream中
//size表示元素的大小
//count表示写入的数据数目
size_t fwrite (const void * ptr,size_t size,size_t count,FILE * stream);

#include <stdio.h>

int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    /*
* 打开文件,wb表示以二进制的方式写入信息
*/
FILE* pf = fopen("data.txt", "wb");
if (NULL == pf)
{
perror("fopen");
return 1;
}
    //将数组arr的数据写入到文件指针pf所指向的文件信息区中,第二个参数为元素大小,第三个参数为元素个数
    fwrite(arr,sizeof(arr[0]),sizeof(arr) / sizeof(arr[0]),pf);
    return 0;
}

5.9:fread函数

//将文件指针stream指向的文件信息区通过二进制的方式读取到ptr中
//size表示元素的大小
//count表示读取的数据数目
size_t fread(void * ptr,size_t size,size_t count,FILE * stream);

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
//rb代表以二进制的方式输入数据(文件向内存输入数据)
FILE* pf = fopen("data.txt", "rb");
if (NULL == pf)
{
perror("fopen");
return 1;
}
//第二个参数为元素的大小,第三个参数为元素个数
fread(arr, sizeof(arr[0]), sizeof(arr) / sizeof(arr[0]), pf);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}

5.95:对比函数

scanf/fscanf/sscanf
printf/fprintf/sprintf

scanf:是格式化的输入函数,针对的是标准输入流(键盘)。
printf:是格式化的输出函数,针对的是标准输出流(屏幕)。
fscanf:是针对所有输入流(文件流、标准输出流)的格式化输入函数。
fprintf:是针对所有输出流(文件流、标准输出流)的格式化输出函数
sprintf:将格式化的数据转换成字符串.
sscanf:将字符串转换成格式化的数据.

5.95.1:sprntf函数与sscanf函数

//将格式化的数据转换为字符串
int sprintf(char * str,const char * format);

//将字符串转换为格式化的数据
int sscanf(const char * s,const char * format);

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
typedef struct S
{
    float a;
    char b;
    double c;
}S;
int main()
{
    char arr[100] = "0";
    S s1 = { 5.0f,'w',250.0 };
    S s2 = { 0 };
    //将结构体s1的数据转换为字符串存储到arr中
    sprintf(arr, "%f %c %d", s1.a, s1.b, s1.c);
    printf("%s\n", arr);
    //将字符串arr的数据格式化存储到s2中
    sscanf("arr","%f %c %d", &s2.a, &s2.b, &s2.c);
    printf("%f %c %d\n", s2.a, s2.b, s2.c);
    return 0;
}

6:文件的随机读写

6.1:fseek函数

//第二个参数为偏移量,第三个参数为设置偏移的位置
int fseek(FILE * stream,long int offset,int origin);
/*
SEEK_SET:从文件光标的开始位置;
SEEK_CUR:从当前位置开始;
SEEK_END:从文件的末尾;
*/

6.1.1:代码1

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{

    FILE* pf = fopen("data.txt", "r");
    if(NULL == pf)
    {
        perror("fopen");
        return 1;
    }
    for(int i = 0; i < 3;i++)
    {
        int ch = fgetc(pf);
        printf("%c", ch);
    }
    //从当前位置向左偏移两个
    fseek(pf,-2,SEEK_CUR);
    int ch = fgetc(pf);
    printf("%c\n",ch);

    return 0;
}

6.1.2:代码2

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{

    FILE* pf = fopen("data.txt", "r");
    if (NULL == pf)
    {
        perror("fopen");
        return 1;
    }
    for (int i = 0; i < 3; i++)
    {
        int ch = fgetc(pf);
        printf("%c", ch);
    }
    printf("\n");
    //从起始位置开始向右偏移三个位置
    fseek(pf, 3, SEEK_SET);
    int ch = fgetc(pf);
    printf("%c\n", ch);

    return 0;
}

6.2:ftell函数

long int ftell(FILE * stream);

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
FILE* pf = fopen("data.txt", "r");
if (NULL == pf)
{
perror("fopen");
return 1;
}
for (int i = 0; i < 3; i++)
{
fgetc(pf);
}
int position = ftell(pf);
//告知光标的偏移量
printf("%d", position);
fclose(pf);
pf = NULL;
return 0;
}

6.3:rewind函数

void rewind(FILE * stream);

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
FILE* pf = fopen("data.txt", "r");
if (NULL == pf)
{
perror("fopen");
return 1;
}
fseek(pf, -12, SEEK_END);
char ch = fgetc(pf);
printf("%c\n", ch);
//让文件指针的位置回到文件的起始位置
rewind(pf);
ch = fgetc(pf);
printf("%c\n", ch);
fclose(pf);
pf = NULL;
return 0;
}

7:文本文件与二进制文件

根据数据的组织形式,数据文件被称为文本文件或者二进制文件。
数据在内存中以二进制的形式存储,如果不加转换地输出到外存,就是二进制文件。
如果要求在外上以ASCII码的形式存储,则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件.

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 10000;
/*
* 打开文件,wb表示以二进制的方式写入信息
*/
FILE* pf = fopen("data.txt", "wb");
if (NULL == pf)
{
perror("fopen");
return 1;
}
//第二参数表示元素的大小,第三个参数表示元素的个数
fwrite(&a, 4, 1, pf);
fclose(pf);
pf = NULL;
return 0;
}

8:文件读取结束的判定

PS:在文件读取过程中,不能用feof函数的返回值直接用来判断文件的是否结束。

而是应用于当文件读取结束的时候,判断是读取失败结束,还是遇到文件尾结束。

1.文本文件读取是否结束,判断返回值是否为EOF(fgetc),或者NULL(fgets)：

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

例如:

(1):fgetc判断是否为EOF;
(2):fgets判断返回值是否为NULL

例如:

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

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
//将文件data的数据拷贝到data2里面去
FILE* pfread = fopen("data.txt", "r");
if (NULL == pfread)
{
perror("fopen");
return 1;
}

FILE* pfwrite = fopen("data2.txt", "w");
if (NULL == pfwrite)
{
perror("fopen");
fclose(pfread);
pfread = NULL;
return 1;
}
//拷贝数据
int ch = 0;
//读取pfread里头的数据
while ((ch = fgetc(pfread)) != EOF)
{
//将读取的到的数据进行输出
fputc(ch, pfwrite);
}

//关闭文件
fclose(pfread);
pfread = NULL;
fclose(pfwrite);
pfwrite = NULL;
return 0;
}

9:文件缓冲区

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

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <Windows.h>
int main()
{
FILE* pf = fopen("test.txt", "w");
fputs("abcdefg", pf);
printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
Sleep(10000);
printf("刷新缓冲区\n");
fflush(pf);
//刷新缓冲区时,才能输出缓冲区的数据写到文件(磁盘)
printf("再睡眠10秒 - 此时，再次打开test.txt文件，文件有内容了\n");
Sleep(10000);
fclose(pf);
pf = NULL;
return 0;
}

结论:

因为有缓冲区的存在,C语言在操作文件的时候,需要做刷新缓冲区或者在文件操作结束的时候关闭文件。

如果不做,能导致读写文件问题

好啦,uu们,C语言的文件这部分滴详细内容博主就讲到这里啦,如果uu们觉得博主讲的不错的话,请动动你们滴小手给博主点点赞,你们滴鼓励将成为博主源源不断滴动力,同时也欢迎大家来指正博主滴错误~

原文地址：https://blog.csdn.net/ABWSO/article/details/142639108

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：【C++】入门基础介绍（下）输入输出，函数重载，缺省与引用
下一篇：用Python制作数据可视化仪表盘：使用Dash与Plotly构建实时交互式仪表盘

G2O 通过工厂函数类 OptimizationAlgorithmFactory 来生成固定搭配的优化算法
[代码实践] G2O 学习记录（一）：2D 位姿图优化 [代码实践] G2O 学习记录（二）：3D 位姿图优化
阅读更多2024-10-07
杭电合集小tips
主要大家还是用C和C++多，但是注意的是，#include这个文件是G++自带的，这意味着调节语言的时候需要导到G++这个语言，不然会显示查不到此文件。同理，或者这个问题还是有问题，在配置vscode
阅读更多2024-10-07
面试经验02
秋招是一场持久战，需要耐心和策略。通过精心准备简历，突出你的技能和经验，你将大大增加获得面试机会的可能性。同时，了解市场行情和自身定位，将帮助你在求职过程中做出更明智的选择。希望这份指南能帮助你顺利找
阅读更多2024-10-07
【C语言】VS调试技巧
VS调试
阅读更多2024-10-07
为什么要虚析构，为什么不能虚构造
这行代码的意思是创建一个指向派生类对象（Derived）的基类指针（Base*），当通过delete basePtr基类指针删除派生类对象时，如果基类的析构函数不是虚函数，那么通过基类指针删除派生类对
阅读更多2024-10-07
springboot 通过aop+自定义注解，统一记录系统操作日志
当前操作的用户: 可以用拦截器+threadlocal实现。ip获取采用 ip2region。日志记录aop，使用环绕通知。需要记录日志的，添加注解。
阅读更多2024-10-07
helm 测试卸载或删除（redis）
查看redis 集群实例kubectl get all -n redis卸载集群实例helm uninstall redis -n redis删除pvckubectl get pvc -n redis
阅读更多2024-10-07
计算机毕业设计 | SpringBoot+vue学生成绩管理系统教务管理系统
本教务系统平台项目开发了电脑网页端，基于上海大学的教学计划，面向教师和学生两个不同的角色设计了不同的页面，同时提供不同的功能。当通过登入界面进入功能页面后，学生可以有选课、退课、成绩查询、课表查询几个
阅读更多2024-10-07
L-edit使用(1)
L-edit使用
阅读更多2024-10-07
HC、OC、JD 极简理解（招聘领域概念）
HC、OC、JD 极简理解（招聘领域概念）
阅读更多2024-10-07