文件操作
前言：当我们想要保存程序运作的结果，由于我们写的程序的数据是存储在电脑的内存中，如果程序退出，内存回收，数据就丢失了，等再次运行程序，是看不到上次程序的数据的，如果要将数据进行持久化的保存，我们可以使用文件。
一.什么是文件
- 文件：磁盘（硬盘）上的文件。
- 一个文件要有一个唯一的文件名（文件标识），以便用户识别和引用。
- 文件名包含3部分：文件路径（相对路径，绝对路径）+文件名主干+文件后缀
例如： c:\code\test.txt
- 文件路径： c:\code\
- 文件名主干：test
- 文件后缀：.txt
二.文件的分类
1.程序文件
- 源程序文件（后缀为.c）。
- 目标文件（在windows环境下，后缀为.obj）。
- 可执行程序文件（在windows环境下，后缀为.exe）。
2.数据文件
- 在以前各章所处理数据的输入输出都是以终端（黑框框）为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。
- 其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件（数据文件）。
三.文本文件与二进制文件
- 二进制文件：数据在内存中以二进制的形式存储，如果不加转换的输出到外存（例如：硬盘）的文件中，就是二进制文件。
- 文本文件：如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。
一个数据在文件中是怎么存储的呢？
- 字符一律以ASCII形式存储。
- 数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。
例如：有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而以⼆进制形式输出，则在磁盘上只占4个字节。
#include <stdio.h>
int main()
{
int a = 10000;
FILE * pf = fopen("test.txt", "wb");
fwrite(&a, 4, 1, pf);//二进制的形式写到文件中
fclose(pf);
pf = NULL;
return 0;
}
四.文件的打开和关闭
1.流
- 我们程序的数据需要输出到各种外部设备（文件，光盘，软盘，U盘，网络，屏幕等），也需要从外部设备获取数据，不同的外部设备的输入输出操作各不相同。
- 为了方便程序员对各种设备进行方便的操作，我们抽象出了流的概念，我们可以把流想象成流淌着字符的河。
- C程序针对文件、画面、键盘等的数据输入输出操作都是通过流操作的。
- 一般情况下，我们要想向流里写数据，或者从流中读取数据。打开流，然后操作，关闭流。
- 流的类型是：FILE*。
2.标准流
思考：为什么我们从键盘输入数据，向屏幕上输出数据，并没有打开流呢？
因为C语言程序在启动的时候，默认打开了3个流：
- stdin —— 标准输入流，大多数的环境中从键盘输入，scanf函数就是从标准输⼊流中读取数据。
- stdout —— 标准输出流，大多数的环境中输出至显示器界面，printf函数就是将信息输出到标准输出流中。
- stderr —— 标准错误流，大多数环境中输出到显示器界面。
- stdin、stdout、stderr三个流的类型是： FILE * ，通常称为文件指针。C语言中，就是通过 FILE * 的文件指针来维护流的各种操作的。
3.文件指针
- 每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态，文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是由系统声明的，取名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.文件的打开与关闭
FILE * fopen ( const char * filename, const char * mode );//打开文件
解释：filename ：文件名，mode ：文件的打开方式，返回指向这个文件的文件指针。
- 如果打开文件成功，返回指向文件的指针。
- 如果打开文件失败，返回NULL指针。
int fclose ( FILE * stream );//关闭文件
解释：stream ：流。
- 如果关闭文件成功，则返回 0。
- 如果关闭文件关闭文件，则返回非0值。
文件的打开方式如下：
- 以读的方式的打开只能读。
- 以写的方式的打开只写读。
读与写的含义：
文件的打开与关闭的代码展示：
#include <stdio.h>
int main()
{
//以写的方式打开文件
FILE* pf = fopen("text.txt", "w");
//. 表示当前路径
//.. 表示上一级路径
//FILE* pf = fopen(".\\..\\text.txt", "w");//相对路径(当前路径的上一级路径)
//FILE* pf = fopen("C:\\Users\\OneDrive\\Desktop\\data.txt", "w");//绝对路径
if (pf == NULL)
{
perror("fopen");
return 1;
}
else
{
printf("文件打开成功\n");
}
//写文件
//关闭文件
fclose(pf);//pf为野指针
pf = NULL;
return 0;
}
五.文件的读写
1.fgetc与fputc
int fputc ( int character, FILE * stream );//写文件
解释：character ：要写入文件的字符，stream ：流（写的形式打开文件：文件输出流 或 stdout：标准输出流）。向流中写入一个字符，并推进位置指示器。该字符被写入到流的内部位置指示器所指示的位置，然后位置指示器会自动推进一个字符位置。
- 如果写入成功，则返回写入的字符的
ASCII值。 - 如果写入失败，则返回
EOF（end of file：文件结束标志）。
#include <stdio.h>
int main()
{
FILE* pf = fopen("text.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
int i = 0;
for (i = 'a'; i <= 'z'; i++)
{
fputc(i, pf);
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
int fgetc ( FILE * stream );//读文件
解释：stream ：流（读的形式打开文件：文件输入流 或 stdin：标准输入流）。从流中获取字符
返回指定流内部文件位置指示器当前指向的字符。然后内部文件位置指示器会向前移动到下一个字符。
- 如果读取成功，则返回读取到字符的
ASCII值。 - 如果读取失败，则返回
EOF。
#include <stdio.h>
int main()
{
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
int ch = 0;
while ((ch = fgetc(pf)) != EOF)
{
printf("%c", ch);
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
每读到一个字符，光标就往后移动一位。
注意：
fgetc与fputc适用于所有流。- 当然也适合
stdin：标准输入流 与 stdout：标准输出流。
例如：
#include <stdio.h>
int main()
{
int ch = fgetc(stdin);//从键盘（标准输入流）上读取
fputc(ch, stdout);//将字符输出到屏幕（标准输出流）
return 0;
}
2.fgets与fputs
int fputs ( const char * str, FILE * stream );//写文件
解释：该函数将由指针 str 指向的字符串写入到流中。该函数从指定地址str开始复制，直到遇到终止的空字符 '\0' 为止。这个终止的空字符不会被复制到流中。
- 成功时：函数返回一个非负值。
- 错误时：函数返回
EOF（end of file）。
请注意：fputs 与 puts 的区别在于目标流可以被指定，而且 fputs 不会写入额外的字符，而 puts 会自动在结尾添加一个换行符。
#include <stdio.h>
int main()
{
//以写的形式打开文件
FILE* pf = fopen("text.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fputs("Hello World!\n", pf);
fputs("I Love C\n", pf);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
char * fgets ( char * str, int num, FILE * stream );//读文件
解释：从流中读取字符，并将它们存储到字符串 str 中，直到读取了 (num-1) 个字符，或者遇到换行符或文件结束符（end-of-file），以先出现者为准。换行符会使 fgets 停止读取，但它被视为函数的有效字符，并包含在复制到 str 的字符串中。在复制到 str 后，会自动添加一个终止的空字符。
- 成功时：该函数返回
str。 - 错误时：返回一个空指针。
请注意：fgets 与 gets 有很大不同：fgets 不仅接受一个流参数，而且允许指定 str 的最大大小，并且在字符串中包括任何结尾换行符。
#include <stdio.h>
int main()
{
//以写的形式打开文件
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
char arr[20] = "xxxxxxxxxxxx";
fgets(arr, 7, pf);
printf("%s\n", arr);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
在键盘上读取代码如下：
#include <stdio.h>
int main()
{
char str[20] = "xxxxxxxxxx";
fgets(str, 20, stdin);
fputs(str, stdout);
return 0;
}
3.格式化输入输出函数
1.printf与fprintf
int printf ( const char * format, ... );
int fprintf ( FILE * stream, const char * format, ... );
printf默认操作标准输出流：stdout。fprintf适合所有流。format：格式化输出。...表示：可变参数列表。
#include <stdio.h>
typedef struct People
{
char name[20];
int age;
double height;
}People;
int main()
{
People s = { "zhangsan" , 20, 188.5 };
//以写的形式打开文件
FILE* pf = fopen("text.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
printf("%s %d %.1lf\n", s.name, s.age, s.height);//写到屏幕（终端）上
fprintf(stdout, "%s %d %.1lf\n", s.name, s.age, s.height);//写到屏幕（终端）上
fprintf(pf, "%s %d %.1lf",s.name, s.age, s.height);//写到文件中
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
2.scanf与fscanf
int scanf ( const char * format, ... );
int fscanf ( FILE * stream, const char * format, ... );
#include <stdio.h>
typedef struct People
{
char name[20];
int age;
double height;
}People;
int main()
{
People s = { 0 };
//以写的形式打开文件
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
scanf("%s %d %lf", s.name, &(s.age), &(s.height));//从键盘中读取
printf("%s %d %.1lf\n", s.name, s.age, s.height);
fscanf(stdin, "%s %d %lf", s.name, &(s.age), &(s.height));//从键盘中读取
printf("%s %d %.1lf\n", s.name, s.age, s.height);
fscanf(pf, "%s %d %lf", s.name, &(s.age), &(s.height));//从文件中读取
printf("%s %d %.1lf\n", s.name, s.age, s.height);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
3.sprintf与sscanf
int sprintf ( char * str, const char * format, ... );
解释：将格式化数据写入字符串。
#include <stdio.h>
typedef struct People
{
char name[20];
int age;
double height;
}People;
int main()
{
char str[100] = { 0 };
People p = { "zhangsan",20,185.5 };
//将p中的各个数据转化成字符串，存储到str中
sprintf(str, "%s %d %.1lf", p.name, p.age, p.height);
printf("%s\n", str);
return 0;
}
int sscanf ( const char * s, const char * format, ...);
解释：从字符串中读取格式化数据。
#include <stdio.h>
typedef struct People
{
char name[20];
int age;
double height;
}People;
int main()
{
char str[100] = { 0 };
People p = { "zhangsan",20,185.5 };
//临时变量
People temp = { 0 };
//将p中的各个数据转化成字符串，存储到str中
sprintf(str, "%s %d %.1lf", p.name, p.age, p.height);
//从字符串str中提取格式化的数据，存储到temp中
//scanf("%s %d %.1lf", temp.name, &(temp.age), &(temp.height));
sscanf(str, "%s %d %lf", temp.name, &temp.age, &temp.height);
printf("%s %d %.1lf", temp.name, temp.age, temp.height);
return 0;
}
总结：
scanf/printf：针对 标准输入流/标准输出流 的 格式化 输入/输出函数。fscanf/fprintf：针对 所有输入流/标准输出流 的 格式化 输入/输出函数。sscanf/sprintf：将格式化的数据转化成字符串 / 将字符串转化成格式化的数据。
4.fread与fwrite
size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
解释：将数据块写入流。从指针 ptr 指向的内存块写入 count 个元素，其中每个元素的大小为 size 字节，写入到流的当前位置。流的位置指示器会被写入的总字节数向前推进。在内部，函数会将指针 ptr 指向的块解释为类型为 unsigned char 的 (size*count) 元素数组，并将它们按顺序写入流，就好像对每个字节调用了 fputc 函数一样。
#include <stdio.h>
typedef struct People
{
char name[20];
int age;
double height;
}People;
int main()
{
People p = { "zhangsan", 20, 185.5 };
//以二进制的形式写文件
FILE* pf = fopen("text.txt", "wb");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fwrite(&p, sizeof(People), 1, pf);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
解释：从流中读取数据块。从流中读取 count 个元素的数组，每个元素的大小为 size 字节，并将它们存储在由 ptr 指定的内存块中。流的位置指示器会根据成功读取的总字节数向前推进。如果成功读取，总共读取的字节数为 (size*count)。
#include <stdio.h>
typedef struct People
{
char name[20];
int age;
double height;
}People;
int main()
{
People p = { 0 };
//以二进制的形式读取文件
FILE* pf = fopen("text.txt", "rb");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
fread(&p, sizeof(People), 1, pf);
printf("%s %d %.1f", p.name, p.age, p.height);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
六.文件的随机读写
使用fgetc函数读取，只能顺序读取（一个一个读取），那如果我们想要任意读取怎么办呢？就要使用随机读写函数。
1.fseek
int fseek ( FILE * stream, long int offset, int origin );
解释：根据文件指针的位置和偏移量来定位文件指针（文件内容的光标）。offset：偏移量，origin：起始位置。
参数origin的取值：
SEEK_SET：文件的起始位置。SEEK_CUR：文件指针的当前位置。SEEK_END：文件的末尾。
#include<stdio.h>
int main()
{
//以读的形式打开文件
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
int ch = 0;
ch = fgetc(pf);//a
printf("%c\n", ch);
ch = fgetc(pf);//b
printf("%c\n", ch);
//随机读取文件
fseek(pf, 2, SEEK_CUR);//定位文件指针：在文件的当前位置
ch = fgetc(pf);//e
printf("%c\n", ch);
fseek(pf, 4, SEEK_SET);//定位文件指针：在文件的开始
ch = fgetc(pf);//e
printf("%c\n", ch);
fseek(pf, -2, SEEK_END);//定位文件指针：在文件的末尾
ch = fgetc(pf);//e
printf("%c\n", ch);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
2.ftell
long int ftell ( FILE * stream );
解释：返回文件指针相对于起始位置的偏移量。
#include<stdio.h>
int main()
{
//以读的形式打开文件
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
int ch = 0;
ch = fgetc(pf);//a
printf("%c\n", ch);
ch = fgetc(pf);//b
printf("%c\n", ch);
//返回文件指针相对于起始位置的偏移量
printf("%d\n", ftell(pf));//2
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
3.rewind
void rewind ( FILE * stream );
解释：让文件指针的位置回到文件的起始位置。
#include<stdio.h>
int main()
{
//以读的形式打开文件
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
int ch = 0;
ch = fgetc(pf);//a
printf("%c\n", ch);
ch = fgetc(pf);//b
printf("%c\n", ch);
//让文件指针的位置回到文件的起始位置
rewind(pf);
ch = fgetc(pf);//a
printf("%c\n", ch);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
七.文件读取结束的判定
1.feof
int feof ( FILE * stream );
EOF：enf of file：文件结束标志。
牢记：在文件读取过程中，不能用feof函数的返回值直接来判断文件读取是否结束（文件读取是否结束包括：文件读取错误，遇到文件末尾）。
feof 的作用是：当文件读取结束的时候，判断读取结束的原因是否为：遇到文件末尾。
- 遇到文件末尾返回非0。
- 未遇到文件末尾返回0。
- 文本文件读取是否结束
fgetc判断是否为EOF。fgets判断返回值是否为NULL。
- 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
fread判断返回值是否小于实际要读的个数。
#include<stdio.h>
int main()
{
//以读的形式打开文件
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
int ch = 0;
while ((ch = fgetc(pf)) != EOF)
{
printf("%c ", ch);
}
if (feof(pf))//feof(pf)==1
{
printf("文件读取结束原因：遇到文件末尾\n");
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
2.与ferror
int ferror ( FILE * stream );
ferror 的作用是：当文件读取结束的时候，判断是读取结束的原因是否是：遇到文件读取错误。
- 遇到文件读取错误返回非0。
- 未遇到文件读取错误返回0。
遇到文件读取错误例如：以写的方式打开文件，但是以读的形式读取文件。
#include<stdio.h>
int main()
{
//以写的形式打开文件
FILE* pf = fopen("text.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//读文件
int ch = 0;
while ((ch = fgetc(pf)) != EOF)
{
printf("%c ", ch);
}
if (ferror(pf))//ferror(pf)==1
{
printf("文件读取结束原因：遇到文件读取错误\n");
}
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
3.文件结束判断例子
- 文本文件的例子：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int c; // 注意：int，非char，要求处理EOF
FILE* pf = fopen("test.txt", "r");
if (pf==NULL)
{
perror("File opening failed");
return EXIT_FAILURE;//1
}
//fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
while ((c = fgetc(pf)) != EOF)// 标准C I/O读取文件循环
{
putchar(c);
}
//判断是什么原因结束的
if (ferror(pf))
puts("I/O error when reading");
else if (feof(pf))
puts("End of file reached successfully");
fclose(pf);
pf = NULL;
}
- 二进制文件的例子：
#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);
fp = NULL;
}
八.拷贝文件
//拷贝文件
//test1.txt ——> test2.txt
#include<stdio.h>
int main()
{
//打开文件
FILE* pfread = fopen("test1.txt", "r");
if (pfread == NULL)
{
perror("fopen");
return 1;
}
FILE* pfwrite = fopen("test2.txt", "w");
if (pfwrite == NULL)
{
perror("fopen");
fclose(pfread);
pfread = NULL;
return 1;
}
//读/写文件
int ch = 0;
while ((ch = fgetc(pfread)) != EOF)
{
fputc(ch, pfwrite);
}
//关闭文件
fclose(pfread);
pfread = NULL;
fclose(pfwrite);
pfwrite = NULL;
return 0;
}
九.文件缓冲区
ANSIC标准采用 “缓冲文件系统” 处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序中每⼀个正在使用的文件开辟一块 “文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C编译系统决定的。
验证文件缓冲区：
#include <stdio.h>
#include <windows.h>
//VS2022 WIN11环境测试
int main()
{
FILE* pf = fopen("test.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//先将代码放在输出缓冲区
fputs(" 《江城子·密州出猎》\n", pf);
fputs(" [宋] 苏轼\n", pf);
fputs("老夫聊发少年狂，左牵黄，右擎苍。\n", pf);
fputs(" 锦帽貂裘，千骑卷平冈。\n", pf);
fputs("为报倾城随太守，亲射虎，看孙郎。\n", pf);
fputs("酒酣胸胆尚开张，鬓微霜，又何妨？\n", pf);
fputs(" 持节云中，何日遣冯唐\n", pf);
fputs("会挽雕弓如满月，西北望，射天狼。\n", pf);
printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
Sleep(10000);
printf("刷新缓冲区\n");
fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
//注：fflush 在高版本的VS上不能使用了
printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");
Sleep(10000);
fclose(pf);
//注：fclose在关闭文件的时候，也会刷新缓冲区
pf = NULL;
return 0;
}
结论：因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。如果不做，可能导致读写文件的问题。
创作不易，如果能帮到你的话能赏个三连吗？感谢啦！！！
扫一扫
194
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
